Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / UI / TemplateControlParser.cs / 1305376 / TemplateControlParser.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* Implements the ASP.NET template parser
*
* Copyright (c) 1998 Microsoft Corporation
*/
namespace System.Web.UI {
using System.Text;
using System;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Reflection;
using System.Configuration;
using System.Web.Caching;
using System.Web.Util;
using System.Web.Compilation;
using HttpException = System.Web.HttpException;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Security.Permissions;
/*
* Parser for TemplateControl's (UserControls and Pages)
*/
///
/// [To be supplied.]
///
public abstract class TemplateControlParser : BaseTemplateParser {
// Attributes in <%@ outputcache ... %> directive
private IDictionary _outputCacheDirective;
private OutputCacheParameters _outputCacheSettings;
internal OutputCacheParameters OutputCacheParameters { get { return _outputCacheSettings; } }
internal bool FAutoEventWireup { get { return !flags[noAutoEventWireup]; } }
internal override bool RequiresCompilation {
get { return flags[requiresCompilation] || CompilationMode == CompilationMode.Always; }
}
// Get default settings from config
internal override void ProcessConfigSettings() {
base.ProcessConfigSettings();
if (PagesConfig != null) {
flags[noAutoEventWireup] = !PagesConfig.AutoEventWireup;
// If config has a non-default EnableViewState value, set it in the main directive
if (PagesConfig.EnableViewState != Control.EnableViewStateDefault)
_mainDirectiveConfigSettings["enableviewstate"] = Util.GetStringFromBool(PagesConfig.EnableViewState);
CompilationMode = PagesConfig.CompilationMode;
}
// if there is a filter, ask it if it wants to use a different mode
if (_pageParserFilter != null)
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
}
internal override void ProcessDirective(string directiveName, IDictionary directive) {
if (StringUtil.EqualsIgnoreCase(directiveName, "outputcache")) {
// Ignore the OutputCache directive in design mode (VSWhidbey 470314)
if (FInDesigner)
return;
if (_outputCacheSettings == null) {
_outputCacheSettings = new OutputCacheParameters();
}
// Make sure the outputcache directive was not already specified
if (_outputCacheDirective != null) {
throw new HttpException(
SR.GetString(SR.Only_one_directive_allowed, directiveName));
}
ProcessOutputCacheDirective(directiveName, directive);
_outputCacheDirective = directive;
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "reference")) {
// Ignore the OutputCache directive in design mode (VSWhidbey 517783)
if (FInDesigner) {
return;
}
// Even though this only makes sense for compiled pages, Sharepoint needs us to
// ignore instead of throw when the page in non-compiled.
// For historical reasons, the virtual path can be specified by 3 different attributes:
// virtualpath, page and control. They all do the same, and virtualpath is the recommended
// one (the other two are deprecated).
// Make sure that no more than one is specified.
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualpath");
bool enforcePage = false;
bool enforceControl = false;
VirtualPath tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "page");
if (tmp != null) {
if (virtualPath != null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
virtualPath = tmp;
enforcePage = true;
}
tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "control");
if (tmp != null) {
if (virtualPath != null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
virtualPath = tmp;
enforceControl = true;
}
// If we didn't get a virtual path, fail
if (virtualPath == null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
Type t = GetReferencedType(virtualPath);
if (t == null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If the 'page' attribute was used, make sure it's indeed a Page
if (enforcePage && !typeof(Page).IsAssignableFrom(t)) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If the 'control' attribute was used, make sure it's indeed a UserControl
if (enforceControl && !typeof(UserControl).IsAssignableFrom(t)) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
else {
base.ProcessDirective(directiveName, directive);
}
}
internal override void ProcessMainDirective(IDictionary mainDirective) {
// We want to make sure that we process the compilationmode attribute before any
// of the other main directive attributes, since its presence can cause other
// attributes to be illegal. So we handle it instead of in ProcessMainDirectiveAttribute.
object tmpObj = null;
try {
tmpObj = Util.GetAndRemoveEnumAttribute(mainDirective,
typeof(CompilationMode), "compilationmode");
}
// catch the exception here so we can continue to process the rest of the main directive
// when called from CBM
catch (Exception ex) {
ProcessError(ex.Message);
}
if (tmpObj != null) {
CompilationMode = (CompilationMode) tmpObj;
// if there is a filter, ask it if it wants to use a different mode
if (_pageParserFilter != null)
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
}
base.ProcessMainDirective(mainDirective);
}
internal override bool ProcessMainDirectiveAttribute(string deviceName, string name,
string value, IDictionary parseData) {
switch (name) {
// Ignore 'targetschema' attribute (ASURT 85670)
case "targetschema":
break;
case "autoeventwireup":
// This only makes sense for compiled pages
OnFoundAttributeRequiringCompilation(name);
flags[noAutoEventWireup] = !Util.GetBooleanAttribute(name, value);
break;
case "enabletheming":
// Return false to let the generic attribute processing continue
// which will cause the EnableTheming property to be set on the
// TemplateControl instance.
return false;
case CodeFileBaseClassAttributeName:
// Remember the base class for post processing
parseData[name] = Util.GetNonEmptyAttribute(name, value);
break;
default:
// We didn't handle the attribute. Try the base class
return base.ProcessMainDirectiveAttribute(deviceName, name, value, parseData);
}
// The attribute was handled
// Make sure no device filter or resource expression was specified
ValidateBuiltInAttribute(deviceName, name, value);
return true;
}
internal override void ProcessUnknownMainDirectiveAttribute(string filter, string attribName, string value) {
// Don't allow the id to be specified on the directive, even though it is
// a public member of the control class (VSWhidbey 85384)
if (attribName == "id") {
base.ProcessUnknownMainDirectiveAttribute(filter, attribName, value);
return;
}
// Process unknown attributes as regular control attribute, hence allowing
// arbitrary properties of the base class to be set.
// But turn off IAttributeAccessor support, otherwise any bad string on a
// user control's directive won't be caught.
try {
RootBuilder.PreprocessAttribute(filter, attribName, value, true /*mainDirectiveMode*/);
}
catch (Exception e) {
ProcessError(SR.GetString(SR.Attrib_parse_error, attribName, e.Message));
}
}
/*
* Add assembly dependencies for a collection of static objects
*/
private void AddStaticObjectAssemblyDependencies(HttpStaticObjectsCollection staticObjects) {
if (staticObjects == null || staticObjects.Objects == null) return;
IDictionaryEnumerator en = staticObjects.Objects.GetEnumerator();
while (en.MoveNext()) {
HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)en.Value;
AddTypeDependency(entry.ObjectType);
}
}
internal Type GetDirectiveType(IDictionary directive, string directiveName) {
string typeName = Util.GetAndRemoveNonEmptyNoSpaceAttribute(directive, "typeName");
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualPath");
Type resultType = null;
// If neither or both are specified, fail
if ((typeName == null) == (virtualPath == null)) {
throw new HttpException(SR.GetString(SR.Invalid_typeNameOrVirtualPath_directive, directiveName));
}
if (typeName != null) {
resultType = GetType(typeName);
AddTypeDependency(resultType);
}
else {
resultType = GetReferencedType(virtualPath);
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
return resultType;
}
internal override void HandlePostParse() {
base.HandlePostParse();
if (!FInDesigner) {
// Omit AutoEventWireup if there can't possibly be any events defined (ASURT 97772)
if (ScriptList.Count == 0 && BaseType == DefaultBaseType && CodeFileVirtualPath == null)
flags[noAutoEventWireup] = true;
_applicationObjects = HttpApplicationFactory.ApplicationState.StaticObjects;
AddStaticObjectAssemblyDependencies(_applicationObjects);
_sessionObjects = HttpApplicationFactory.ApplicationState.SessionStaticObjects;
AddStaticObjectAssemblyDependencies(_sessionObjects);
}
}
/*
* Process the contents of the <%@ OutputCache ... %> directive
*/
internal virtual void ProcessOutputCacheDirective(string directiveName, IDictionary directive) {
int duration = 0; // Unit is second
string varyByParams;
string varyByCustom;
string outputCacheProfile = null;
string varyByControls;
bool fHasDuration = Util.GetAndRemovePositiveIntegerAttribute(directive, "duration", ref duration);
if (fHasDuration) {
OutputCacheParameters.Duration = duration;
}
//
if (this is PageParser) {
outputCacheProfile = Util.GetAndRemoveNonEmptyAttribute(directive, "cacheProfile");
if (outputCacheProfile != null) {
OutputCacheParameters.CacheProfile = outputCacheProfile;
}
}
if (!fHasDuration && (outputCacheProfile == null || outputCacheProfile.Length == 0) && FDurationRequiredOnOutputCache)
throw new HttpException(SR.GetString(SR.Missing_attr, "duration"));
varyByCustom = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycustom");
if (varyByCustom != null) {
OutputCacheParameters.VaryByCustom = varyByCustom;
}
varyByControls = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontrol");
if (varyByControls != null) {
OutputCacheParameters.VaryByControl = varyByControls;
}
varyByParams = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyparam");
if (varyByParams != null) {
OutputCacheParameters.VaryByParam = varyByParams;
}
// VaryByParams is required (ASURT 76763)
if (varyByParams == null &&
varyByControls == null &&
(outputCacheProfile == null || outputCacheProfile.Length == 0) &&
FVaryByParamsRequiredOnOutputCache)
throw new HttpException(SR.GetString(SR.Missing_varybyparam_attr));
// If it's "none", set it to null
if (StringUtil.EqualsIgnoreCase(varyByParams, "none"))
OutputCacheParameters.VaryByParam = null;
if (StringUtil.EqualsIgnoreCase(varyByControls, "none"))
OutputCacheParameters.VaryByControl = null;
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive, UnknownOutputCacheAttributeError);
}
internal virtual bool FDurationRequiredOnOutputCache {
get { return true; }
}
internal virtual bool FVaryByParamsRequiredOnOutputCache {
get { return true; }
}
internal abstract string UnknownOutputCacheAttributeError {
get;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* Implements the ASP.NET template parser
*
* Copyright (c) 1998 Microsoft Corporation
*/
namespace System.Web.UI {
using System.Text;
using System;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Reflection;
using System.Configuration;
using System.Web.Caching;
using System.Web.Util;
using System.Web.Compilation;
using HttpException = System.Web.HttpException;
using System.Text.RegularExpressions;
using System.Globalization;
using System.Security.Permissions;
/*
* Parser for TemplateControl's (UserControls and Pages)
*/
///
/// [To be supplied.]
///
public abstract class TemplateControlParser : BaseTemplateParser {
// Attributes in <%@ outputcache ... %> directive
private IDictionary _outputCacheDirective;
private OutputCacheParameters _outputCacheSettings;
internal OutputCacheParameters OutputCacheParameters { get { return _outputCacheSettings; } }
internal bool FAutoEventWireup { get { return !flags[noAutoEventWireup]; } }
internal override bool RequiresCompilation {
get { return flags[requiresCompilation] || CompilationMode == CompilationMode.Always; }
}
// Get default settings from config
internal override void ProcessConfigSettings() {
base.ProcessConfigSettings();
if (PagesConfig != null) {
flags[noAutoEventWireup] = !PagesConfig.AutoEventWireup;
// If config has a non-default EnableViewState value, set it in the main directive
if (PagesConfig.EnableViewState != Control.EnableViewStateDefault)
_mainDirectiveConfigSettings["enableviewstate"] = Util.GetStringFromBool(PagesConfig.EnableViewState);
CompilationMode = PagesConfig.CompilationMode;
}
// if there is a filter, ask it if it wants to use a different mode
if (_pageParserFilter != null)
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
}
internal override void ProcessDirective(string directiveName, IDictionary directive) {
if (StringUtil.EqualsIgnoreCase(directiveName, "outputcache")) {
// Ignore the OutputCache directive in design mode (VSWhidbey 470314)
if (FInDesigner)
return;
if (_outputCacheSettings == null) {
_outputCacheSettings = new OutputCacheParameters();
}
// Make sure the outputcache directive was not already specified
if (_outputCacheDirective != null) {
throw new HttpException(
SR.GetString(SR.Only_one_directive_allowed, directiveName));
}
ProcessOutputCacheDirective(directiveName, directive);
_outputCacheDirective = directive;
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "reference")) {
// Ignore the OutputCache directive in design mode (VSWhidbey 517783)
if (FInDesigner) {
return;
}
// Even though this only makes sense for compiled pages, Sharepoint needs us to
// ignore instead of throw when the page in non-compiled.
// For historical reasons, the virtual path can be specified by 3 different attributes:
// virtualpath, page and control. They all do the same, and virtualpath is the recommended
// one (the other two are deprecated).
// Make sure that no more than one is specified.
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualpath");
bool enforcePage = false;
bool enforceControl = false;
VirtualPath tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "page");
if (tmp != null) {
if (virtualPath != null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
virtualPath = tmp;
enforcePage = true;
}
tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "control");
if (tmp != null) {
if (virtualPath != null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
virtualPath = tmp;
enforceControl = true;
}
// If we didn't get a virtual path, fail
if (virtualPath == null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive));
return;
}
Type t = GetReferencedType(virtualPath);
if (t == null) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If the 'page' attribute was used, make sure it's indeed a Page
if (enforcePage && !typeof(Page).IsAssignableFrom(t)) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If the 'control' attribute was used, make sure it's indeed a UserControl
if (enforceControl && !typeof(UserControl).IsAssignableFrom(t)) {
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
else {
base.ProcessDirective(directiveName, directive);
}
}
internal override void ProcessMainDirective(IDictionary mainDirective) {
// We want to make sure that we process the compilationmode attribute before any
// of the other main directive attributes, since its presence can cause other
// attributes to be illegal. So we handle it instead of in ProcessMainDirectiveAttribute.
object tmpObj = null;
try {
tmpObj = Util.GetAndRemoveEnumAttribute(mainDirective,
typeof(CompilationMode), "compilationmode");
}
// catch the exception here so we can continue to process the rest of the main directive
// when called from CBM
catch (Exception ex) {
ProcessError(ex.Message);
}
if (tmpObj != null) {
CompilationMode = (CompilationMode) tmpObj;
// if there is a filter, ask it if it wants to use a different mode
if (_pageParserFilter != null)
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
}
base.ProcessMainDirective(mainDirective);
}
internal override bool ProcessMainDirectiveAttribute(string deviceName, string name,
string value, IDictionary parseData) {
switch (name) {
// Ignore 'targetschema' attribute (ASURT 85670)
case "targetschema":
break;
case "autoeventwireup":
// This only makes sense for compiled pages
OnFoundAttributeRequiringCompilation(name);
flags[noAutoEventWireup] = !Util.GetBooleanAttribute(name, value);
break;
case "enabletheming":
// Return false to let the generic attribute processing continue
// which will cause the EnableTheming property to be set on the
// TemplateControl instance.
return false;
case CodeFileBaseClassAttributeName:
// Remember the base class for post processing
parseData[name] = Util.GetNonEmptyAttribute(name, value);
break;
default:
// We didn't handle the attribute. Try the base class
return base.ProcessMainDirectiveAttribute(deviceName, name, value, parseData);
}
// The attribute was handled
// Make sure no device filter or resource expression was specified
ValidateBuiltInAttribute(deviceName, name, value);
return true;
}
internal override void ProcessUnknownMainDirectiveAttribute(string filter, string attribName, string value) {
// Don't allow the id to be specified on the directive, even though it is
// a public member of the control class (VSWhidbey 85384)
if (attribName == "id") {
base.ProcessUnknownMainDirectiveAttribute(filter, attribName, value);
return;
}
// Process unknown attributes as regular control attribute, hence allowing
// arbitrary properties of the base class to be set.
// But turn off IAttributeAccessor support, otherwise any bad string on a
// user control's directive won't be caught.
try {
RootBuilder.PreprocessAttribute(filter, attribName, value, true /*mainDirectiveMode*/);
}
catch (Exception e) {
ProcessError(SR.GetString(SR.Attrib_parse_error, attribName, e.Message));
}
}
/*
* Add assembly dependencies for a collection of static objects
*/
private void AddStaticObjectAssemblyDependencies(HttpStaticObjectsCollection staticObjects) {
if (staticObjects == null || staticObjects.Objects == null) return;
IDictionaryEnumerator en = staticObjects.Objects.GetEnumerator();
while (en.MoveNext()) {
HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)en.Value;
AddTypeDependency(entry.ObjectType);
}
}
internal Type GetDirectiveType(IDictionary directive, string directiveName) {
string typeName = Util.GetAndRemoveNonEmptyNoSpaceAttribute(directive, "typeName");
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualPath");
Type resultType = null;
// If neither or both are specified, fail
if ((typeName == null) == (virtualPath == null)) {
throw new HttpException(SR.GetString(SR.Invalid_typeNameOrVirtualPath_directive, directiveName));
}
if (typeName != null) {
resultType = GetType(typeName);
AddTypeDependency(resultType);
}
else {
resultType = GetReferencedType(virtualPath);
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
return resultType;
}
internal override void HandlePostParse() {
base.HandlePostParse();
if (!FInDesigner) {
// Omit AutoEventWireup if there can't possibly be any events defined (ASURT 97772)
if (ScriptList.Count == 0 && BaseType == DefaultBaseType && CodeFileVirtualPath == null)
flags[noAutoEventWireup] = true;
_applicationObjects = HttpApplicationFactory.ApplicationState.StaticObjects;
AddStaticObjectAssemblyDependencies(_applicationObjects);
_sessionObjects = HttpApplicationFactory.ApplicationState.SessionStaticObjects;
AddStaticObjectAssemblyDependencies(_sessionObjects);
}
}
/*
* Process the contents of the <%@ OutputCache ... %> directive
*/
internal virtual void ProcessOutputCacheDirective(string directiveName, IDictionary directive) {
int duration = 0; // Unit is second
string varyByParams;
string varyByCustom;
string outputCacheProfile = null;
string varyByControls;
bool fHasDuration = Util.GetAndRemovePositiveIntegerAttribute(directive, "duration", ref duration);
if (fHasDuration) {
OutputCacheParameters.Duration = duration;
}
//
if (this is PageParser) {
outputCacheProfile = Util.GetAndRemoveNonEmptyAttribute(directive, "cacheProfile");
if (outputCacheProfile != null) {
OutputCacheParameters.CacheProfile = outputCacheProfile;
}
}
if (!fHasDuration && (outputCacheProfile == null || outputCacheProfile.Length == 0) && FDurationRequiredOnOutputCache)
throw new HttpException(SR.GetString(SR.Missing_attr, "duration"));
varyByCustom = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycustom");
if (varyByCustom != null) {
OutputCacheParameters.VaryByCustom = varyByCustom;
}
varyByControls = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontrol");
if (varyByControls != null) {
OutputCacheParameters.VaryByControl = varyByControls;
}
varyByParams = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyparam");
if (varyByParams != null) {
OutputCacheParameters.VaryByParam = varyByParams;
}
// VaryByParams is required (ASURT 76763)
if (varyByParams == null &&
varyByControls == null &&
(outputCacheProfile == null || outputCacheProfile.Length == 0) &&
FVaryByParamsRequiredOnOutputCache)
throw new HttpException(SR.GetString(SR.Missing_varybyparam_attr));
// If it's "none", set it to null
if (StringUtil.EqualsIgnoreCase(varyByParams, "none"))
OutputCacheParameters.VaryByParam = null;
if (StringUtil.EqualsIgnoreCase(varyByControls, "none"))
OutputCacheParameters.VaryByControl = null;
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive, UnknownOutputCacheAttributeError);
}
internal virtual bool FDurationRequiredOnOutputCache {
get { return true; }
}
internal virtual bool FVaryByParamsRequiredOnOutputCache {
get { return true; }
}
internal abstract string UnknownOutputCacheAttributeError {
get;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DataReaderContainer.cs
- EventMetadata.cs
- TreeViewTemplateSelector.cs
- SamlAudienceRestrictionCondition.cs
- Padding.cs
- UserInitiatedNavigationPermission.cs
- RootProfilePropertySettingsCollection.cs
- BigInt.cs
- PlatformCulture.cs
- SurrogateEncoder.cs
- DataGridHelper.cs
- ShaderEffect.cs
- NumberAction.cs
- ExplicitDiscriminatorMap.cs
- HMACSHA256.cs
- OracleMonthSpan.cs
- WebAdminConfigurationHelper.cs
- CommonObjectSecurity.cs
- DriveInfo.cs
- CookieParameter.cs
- DetailsViewPagerRow.cs
- InstanceData.cs
- NativeMethods.cs
- CompareValidator.cs
- XPathSingletonIterator.cs
- LocalizationCodeDomSerializer.cs
- ExpressionEditorSheet.cs
- SqlDependency.cs
- SqlTransaction.cs
- DeclaredTypeElement.cs
- SizeConverter.cs
- HttpListenerResponse.cs
- SystemWebCachingSectionGroup.cs
- InputLangChangeEvent.cs
- OpCellTreeNode.cs
- ZipFileInfoCollection.cs
- FormParameter.cs
- BindingContext.cs
- MatchAttribute.cs
- ContentValidator.cs
- StorageBasedPackageProperties.cs
- CanonicalizationDriver.cs
- CanonicalXml.cs
- QueryModel.cs
- PrintingPermission.cs
- FilterQuery.cs
- SqlConnectionPoolProviderInfo.cs
- ButtonColumn.cs
- Object.cs
- TextShapeableCharacters.cs
- Int32RectValueSerializer.cs
- AnimationStorage.cs
- ReaderWriterLock.cs
- WebPartEditorOkVerb.cs
- XmlSerializationWriter.cs
- WebPartRestoreVerb.cs
- XmlAttributeAttribute.cs
- CommandPlan.cs
- DataPointer.cs
- MatrixValueSerializer.cs
- NameValueCollection.cs
- StaticDataManager.cs
- ParentUndoUnit.cs
- ValidationPropertyAttribute.cs
- MouseButtonEventArgs.cs
- PropertyGridCommands.cs
- MimeMapping.cs
- TextTreeDeleteContentUndoUnit.cs
- ReadOnlyCollectionBase.cs
- WebZone.cs
- WebPartCatalogCloseVerb.cs
- IntellisenseTextBox.designer.cs
- StorageMappingFragment.cs
- sqlinternaltransaction.cs
- PageRanges.cs
- ProviderManager.cs
- SchemaElementDecl.cs
- FixedDSBuilder.cs
- RIPEMD160Managed.cs
- MultiPropertyDescriptorGridEntry.cs
- SafeCryptHandles.cs
- CodeNamespaceImport.cs
- ClientSettingsProvider.cs
- ToolStripDropDownClosingEventArgs.cs
- Rect3D.cs
- PropertyEntry.cs
- XmlHierarchyData.cs
- ToolboxItemFilterAttribute.cs
- ResetableIterator.cs
- CategoryGridEntry.cs
- ArithmeticException.cs
- SmiTypedGetterSetter.cs
- TransformBlockRequest.cs
- InfoCardRSACryptoProvider.cs
- WindowsRichEdit.cs
- ReadOnlyPropertyMetadata.cs
- Maps.cs
- FixedPageProcessor.cs
- CustomPopupPlacement.cs
- IncrementalHitTester.cs