Code:
/ Dotnetfx_Win7_3.5.1 / Dotnetfx_Win7_3.5.1 / 3.5.1 / DEVDIV / depot / DevDiv / releases / whidbey / NetFXspW7 / ndp / fx / src / xsp / System / Web / UI / TemplateControlParser.cs / 1 / 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.]
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
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, We should
// 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.]
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
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, We should
// 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
- UseLicense.cs
- SqlAggregateChecker.cs
- StringToken.cs
- DataGrid.cs
- StylusPoint.cs
- TransactionWaitAsyncResult.cs
- CategoryGridEntry.cs
- QueryCoreOp.cs
- Pen.cs
- TextTabProperties.cs
- SspiHelper.cs
- InterleavedZipPartStream.cs
- cryptoapiTransform.cs
- _SpnDictionary.cs
- TableLayoutPanel.cs
- NativeMethods.cs
- SourceFilter.cs
- MobileRedirect.cs
- StrongNameHelpers.cs
- ObjectDataSourceMethodEventArgs.cs
- DelegateTypeInfo.cs
- DesignerActionUIService.cs
- DatagridviewDisplayedBandsData.cs
- FontTypeConverter.cs
- LoadedOrUnloadedOperation.cs
- MenuStrip.cs
- SchemaCollectionPreprocessor.cs
- XPathDocumentIterator.cs
- LayoutManager.cs
- EllipticalNodeOperations.cs
- InstanceKeyView.cs
- TableItemPattern.cs
- assertwrapper.cs
- OleDbException.cs
- DeclarativeCatalogPart.cs
- CustomWebEventKey.cs
- ElementUtil.cs
- EnumType.cs
- RenderingEventArgs.cs
- ImageAutomationPeer.cs
- ComplexObject.cs
- TextureBrush.cs
- ActivationArguments.cs
- TimeoutValidationAttribute.cs
- MatrixUtil.cs
- WizardForm.cs
- XmlCharacterData.cs
- Rule.cs
- AttachmentCollection.cs
- Stylesheet.cs
- WorkflowServiceNamespace.cs
- WrappedIUnknown.cs
- StylusButton.cs
- SessionStateSection.cs
- DataControlImageButton.cs
- HybridWebProxyFinder.cs
- FilteredDataSetHelper.cs
- CallbackHandler.cs
- InputProviderSite.cs
- SapiRecognizer.cs
- StrokeSerializer.cs
- MediaContextNotificationWindow.cs
- BamlLocalizableResourceKey.cs
- MenuItemStyleCollectionEditor.cs
- ExternalFile.cs
- UrlMappingCollection.cs
- StringBuilder.cs
- WizardPanelChangingEventArgs.cs
- ProxyGenerator.cs
- SolidBrush.cs
- Publisher.cs
- TextProviderWrapper.cs
- NTAccount.cs
- NetworkAddressChange.cs
- AdjustableArrowCap.cs
- TransformCollection.cs
- GridEntryCollection.cs
- CTreeGenerator.cs
- SiteMembershipCondition.cs
- WindowsMenu.cs
- DefinitionBase.cs
- EditorReuseAttribute.cs
- DesignTimeResourceProviderFactoryAttribute.cs
- X500Name.cs
- DecoderBestFitFallback.cs
- AsyncOperationManager.cs
- PersistenceParticipant.cs
- GeneralTransform3D.cs
- HttpBrowserCapabilitiesBase.cs
- System.Data.OracleClient_BID.cs
- DataBindingCollection.cs
- ReferentialConstraint.cs
- SqlGenericUtil.cs
- VisualTarget.cs
- WindowsClientElement.cs
- Panel.cs
- StackSpiller.Bindings.cs
- CursorConverter.cs
- UniqueIdentifierService.cs
- FlowDocumentView.cs