Code:
/ DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Markup / XamlReader.cs / 3 / XamlReader.cs
//---------------------------------------------------------------------------- // // File: XamlReader.cs // // Description: // base Parser class that parses XML markup into an Avalon Element Tree // // // History: // 6/06/01: rogerg Created as Parser.cs // 5/29/03: [....] Ported to wcp as Parser.cs // 8/04/05: [....] Split Parser into XamlReader and XamlWriter // // Copyright (C) 2003 by Microsoft Corporation. All rights reserved. // //--------------------------------------------------------------------------- using System; using System.Xml; using System.IO; using System.IO.Packaging; using System.Windows; using System.ComponentModel; using System.Collections; using System.Diagnostics; using System.Reflection; using MS.Utility; using System.Security; using System.Security.Permissions; using System.Security.Policy; using System.Text; using System.ComponentModel.Design.Serialization; using System.Globalization; using System.Windows.Markup.Primitives; using MS.Internal; using MS.Internal.IO.Packaging; namespace System.Windows.Markup { ////// Parsing class used to create an Windows Presentation Platform Tree /// public class XamlReader { #region Public Methods ////// Reads XAML from the passed stream,building an object tree and returning the /// root of that tree. /// /// input as stream ///object root generated after xml parsed //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 public static object Load(Stream stream) { bool etwTracingEnabled = false; object root = null; #if DEBUG_CLR_MEM bool clrTracingEnabled = false; // Use local pass variable to correctly log nested parses. int pass = 0; if (CLRProfilerControl.ProcessIsUnderCLRProfiler && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { clrTracingEnabled = true; pass = ++_CLRXamlPass; CLRProfilerControl.CLRLogWriteLine("Begin_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.normal)) { etwTracingEnabled = true; EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.StartEvent); } if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Start, TraceMarkup.Load ); } try { if (null == stream) { throw new ArgumentNullException("stream"); } ParserContext pc = new ParserContext(); // Is this really the right thing to do? Can this XamlTypeMapper be reused? if (null == pc.XamlTypeMapper) { pc.XamlTypeMapper = XmlParserDefaults.DefaultMapper; } // In some cases, the application constructor is not run prior to loading, // causing the loader not to recognize URIs beginning with �pack:� or �application:�. System.Runtime.CompilerServices.RuntimeHelpers.RunClassConstructor(typeof(System.Windows.Application).TypeHandle); root = XmlTreeBuildDefault(pc, stream, XamlParseMode.Synchronous, etwTracingEnabled); } finally { if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Stop, TraceMarkup.Load, root ); } if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.EndEvent); } #if DEBUG_CLR_MEM if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { CLRProfilerControl.CLRLogWriteLine("End_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM } return (root); } ////// Reads XAML using the passed XmlReader, building an object tree and returning the /// root of that tree. /// /// Reader of xml content. ///object root generated after xml parsed //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 public static object Load( XmlReader reader) { bool etwTracingEnabled = false; object root = null; #if DEBUG_CLR_MEM bool clrTracingEnabled = false; // Use local pass variable to correctly log nested parses. int pass = 0; if (CLRProfilerControl.ProcessIsUnderCLRProfiler && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { clrTracingEnabled = true; pass = ++_CLRXamlPass; CLRProfilerControl.CLRLogWriteLine("Begin_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.normal)) { etwTracingEnabled = true; EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.StartEvent); } if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Start, TraceMarkup.Load ); } try { if (null == reader) { throw new ArgumentNullException("reader"); } // Create the parser context, pulling existing XML context from the // XmlReader (Lang, Space, and BaseURI). ParserContext pc = new ParserContext( reader ); // Is this really the right thing to do? Can this XamlTypeMapper be reused? if (null == pc.XamlTypeMapper) { pc.XamlTypeMapper = XmlParserDefaults.DefaultMapper; } root = XmlTreeBuildDefault(pc, reader, true, XamlParseMode.Synchronous, etwTracingEnabled); } finally { if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Stop, TraceMarkup.Load, root ); } if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.EndEvent); } #if DEBUG_CLR_MEM if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { CLRProfilerControl.CLRLogWriteLine("End_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM } return (root); } ////// Reads XAML from the passed stream, building an object tree and returning the /// root of that tree. /// /// input as stream /// parser context ///object root generated after xml parsed //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 public static object Load( Stream stream, ParserContext parserContext) { bool etwTracingEnabled = false; object root = null; #if DEBUG_CLR_MEM bool clrTracingEnabled = false; // Use local pass variable to correctly log nested parses. int pass = 0; if (CLRProfilerControl.ProcessIsUnderCLRProfiler && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { clrTracingEnabled = true; pass = ++_CLRXamlPass; CLRProfilerControl.CLRLogWriteLine("Begin_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.normal)) { etwTracingEnabled = true; EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.StartEvent); } if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Start, TraceMarkup.Load ); } try { if (null == stream) { throw new ArgumentNullException("stream"); } if (null == parserContext) { throw new ArgumentNullException("parserContext"); } // Is this really the right thing to do? Can this XamlTypeMapper be reused? if (null == parserContext.XamlTypeMapper) { parserContext.XamlTypeMapper = XmlParserDefaults.DefaultMapper; } root = XmlTreeBuildDefault(parserContext, stream, XamlParseMode.Synchronous, etwTracingEnabled); } finally { if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Stop, TraceMarkup.Load, root ); } if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.EndEvent); } #if DEBUG_CLR_MEM if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { CLRProfilerControl.CLRLogWriteLine("End_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM } return (root); } ////// Loads XAML from the given stream, building an object tree. /// The load operation will be done asynchronously if the /// markup specifies x:SynchronousMode="async". /// /// stream for the xml content ///object root generated after xml parsed ////// Notice that this is an instance method /// public object LoadAsync(Stream stream) { if (null == stream) { throw new ArgumentNullException("stream"); } if (_treeBuilder != null) { // A XamlReader instance cannot be shared across two load operations throw new InvalidOperationException(SR.Get(SRID.ParserCannotReuseXamlReader)); } ParserContext parserContext = new ParserContext(); parserContext.XamlTypeMapper = XmlParserDefaults.DefaultMapper; _treeBuilder = new XamlTreeBuilder(parserContext, stream, XamlParseMode.Uninitialized); _treeBuilder.ParseCompleted += new EventHandler(OnLoadCompleted); return _treeBuilder.Parse(); } ////// Reads XAML using the given XmlReader, building an object tree. /// The load operation will be done asynchronously if the markup /// specifies x:SynchronousMode="async". /// /// Reader for xml content. ///object root generated after xml parsed ////// Notice that this is an instance method /// public object LoadAsync(XmlReader reader) { if (null == reader) { throw new ArgumentNullException("reader"); } if (_treeBuilder != null) { // A XamlReader instance cannot be shared across two load operations throw new InvalidOperationException(SR.Get(SRID.ParserCannotReuseXamlReader)); } ParserContext parserContext = new ParserContext(reader); parserContext.XamlTypeMapper = XmlParserDefaults.DefaultMapper; _treeBuilder = new XamlTreeBuilder(parserContext, reader, true, XamlParseMode.Uninitialized); _treeBuilder.ParseCompleted += new EventHandler(OnLoadCompleted); return _treeBuilder.Parse(); } ////// Loads XAML from the given stream, building an object tree. /// The load operation will be done asynchronously if the /// markup specifies x:SynchronousMode="async". /// /// stream for the xml content /// parser context ///object root generated after xml parsed ////// Notice that this is an instance method /// public object LoadAsync(Stream stream, ParserContext parserContext) { if (null == stream) { throw new ArgumentNullException("stream"); } if (_treeBuilder != null) { // A XamlReader instance cannot be shared across two load operations throw new InvalidOperationException(SR.Get(SRID.ParserCannotReuseXamlReader)); } if (parserContext == null) { parserContext = new ParserContext(); } if (null == parserContext.XamlTypeMapper) { parserContext.XamlTypeMapper = XmlParserDefaults.DefaultMapper; } _treeBuilder = new XamlTreeBuilder(parserContext, stream, XamlParseMode.Uninitialized); _treeBuilder.ParseCompleted += new EventHandler(OnLoadCompleted); return _treeBuilder.Parse(); } ////// Aborts the current async load operation if there is one. /// ////// Notice that the cancellation is an asynchronous operation in itself which means /// that there may be some amount of loading that happens before the operation /// actually gets aborted. /// public void CancelAsync() { if (null != _treeBuilder) { _treeBuilder.XamlTreeBuildCancel(); } } ////// This event is fired when either a sync or an async load operation has completed /// or when an async load operation is aborted. /// public event AsyncCompletedEventHandler LoadCompleted; #endregion Public Methods #region Internal Methods ////// This is the event listener for the ParseCompleted event on XamlTreeBuidler /// private void OnLoadCompleted(object sender, EventArgs args) { // Fire the LoadCompleted event listeners if (LoadCompleted != null) { LoadCompleted(this, new AsyncCompletedEventArgs(_treeBuilder.ParseException, _treeBuilder.ParseCancelled, null /*userState*/)); } // Clear the _treeBuilder _treeBuilder.ParseCompleted -= new EventHandler(OnLoadCompleted); _treeBuilder = null; } ////// Reads XAML from the passed stream, building an object tree and returning the /// root of that tree. Wrap a CompatibilityReader with another XmlReader that /// uses the passed reader settings to allow validation of xaml. /// /// XmlReader to use. This is NOT wrapped by any /// other reader /// Optional parser context. May be null /// Sets synchronous or asynchronous parsing ///object root generated after xml parsed // Note this is the internal entry point for XPS. XPS calls here so // its reader is not wrapped with a Markup Compat Reader. internal static object Load( XmlReader reader, ParserContext context, XamlParseMode parseMode) { bool etwTracingEnabled = false; object root = null; #if DEBUG_CLR_MEM bool clrTracingEnabled = false; // Use local pass variable to correctly log nested parses. int pass = 0; if (CLRProfilerControl.ProcessIsUnderCLRProfiler && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { clrTracingEnabled = true; pass = ++_CLRXamlPass; CLRProfilerControl.CLRLogWriteLine("Begin_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.normal)) { etwTracingEnabled = true; EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.StartEvent); } if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Start, TraceMarkup.Load ); } try { if (null == reader) { throw new ArgumentNullException("reader"); } if (context == null) { context = new ParserContext(); } // Is this really the right thing to do? Can this XamlTypeMapper be reused? if (null == context.XamlTypeMapper) { context.XamlTypeMapper = XmlParserDefaults.DefaultMapper; } root = XmlTreeBuildDefault(context, reader, false, parseMode, etwTracingEnabled); } finally { if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Stop, TraceMarkup.Load, root ); } if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.EndEvent); } #if DEBUG_CLR_MEM if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { CLRProfilerControl.CLRLogWriteLine("End_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM } return (root); } ////// Reads XAML from the passed stream, building an object tree and returning the /// root of that tree. /// /// input as stream /// hooks to callback during load /// parser context ///object root generated after xml parsed //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 // internal static object Load( Stream stream, ParserHooks hooks, ParserContext parserContext) { bool etwTracingEnabled = false; object root = null; #if DEBUG_CLR_MEM bool clrTracingEnabled = false; // Use local pass variable to correctly log nested parses. int pass = 0; if (CLRProfilerControl.ProcessIsUnderCLRProfiler && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { clrTracingEnabled = true; pass = ++_CLRXamlPass; CLRProfilerControl.CLRLogWriteLine("Begin_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.normal)) { etwTracingEnabled = true; EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.StartEvent); } if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Start, TraceMarkup.Load ); } try { if (null == stream) { throw new ArgumentNullException("stream"); } if (null == parserContext) { throw new ArgumentNullException("parserContext"); } // Is this really the right thing to do? Can this XamlTypeMapper be reused? if (null == parserContext.XamlTypeMapper) { parserContext.XamlTypeMapper = XmlParserDefaults.DefaultMapper; } root = XmlTreeBuildAssembly(parserContext, stream, hooks, etwTracingEnabled); } finally { if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Stop, TraceMarkup.Load, root ); } if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLGUID), MS.Utility.EventType.EndEvent); } #if DEBUG_CLR_MEM if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { CLRProfilerControl.CLRLogWriteLine("End_XamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM } return (root); } ////// Loads the given baml stream /// /// input as stream /// parent owner element of baml tree /// parser context /// True if stream should be closed by the /// parser after parsing is complete. False if the stream should be left open ///object root generated after baml parsed ////// Critical - because it sets _streamCreatedAssembly on the ParserContext, and that is /// SecurityCritical Data as this field is used by the BamlRecordReader to /// allow legitimate internal types in Partial Trust. /// Safe - because it gets this value from the stream if it implements an internal IStreamInfo /// interface and IStreamInfo.Assembly is set by the ResourceContainer code that is /// SecurityCritical, but treated as safe. /// [SecurityCritical, SecurityTreatAsSafe] //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 internal static object LoadBaml( Stream stream, ParserContext parserContext, object parent, bool closeStream) { Debug.Assert(stream != null && parserContext != null); bool etwTracingEnabled = false; object root = null; #if DEBUG_CLR_MEM bool clrTracingEnabled = false; // Use local pass variable to correctly log nested parses. int pass = 0; if (CLRProfilerControl.ProcessIsUnderCLRProfiler && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { clrTracingEnabled = true; pass = ++_CLRBamlPass; CLRProfilerControl.CLRLogWriteLine("Begin_BamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM if (EventTrace.IsEnabled(EventTrace.Flags.performance, EventTrace.Level.normal)) { etwTracingEnabled = true; EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEBAMLGUID), MS.Utility.EventType.StartEvent); } if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Start, TraceMarkup.Load ); } try { if (null == parserContext.XamlTypeMapper) { parserContext.XamlTypeMapper = XmlParserDefaults.DefaultMapper; } // // If the stream contains info about the Assembly that created it, // set StreamCreatedAssembly from the stream instance. // IStreamInfo streamInfo = stream as IStreamInfo; if (streamInfo != null) { parserContext.StreamCreatedAssembly = streamInfo.Assembly; } TreeBuilderBamlTranslator treeBuilder = new TreeBuilderBamlTranslator(stream, parserContext, parent, closeStream); root = treeBuilder.Parse(); Debug.Assert(parent == null || root == parent); } finally { if( TraceMarkup.IsEnabled ) { TraceMarkup.Trace( TraceEventType.Stop, TraceMarkup.Load, root ); } if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEBAMLGUID), MS.Utility.EventType.EndEvent); } #if DEBUG_CLR_MEM if (clrTracingEnabled && (CLRProfilerControl.CLRLoggingLevel >= CLRProfilerControl.CLRLogState.Performance)) { CLRProfilerControl.CLRLogWriteLine("End_BamlParse_{0}", pass); } #endif // DEBUG_CLR_MEM } return (root); } #endregion Internal Methods #region Private Methods ////// Reads XAML from the passed stream, building an object tree and returning the /// root of that tree. This override is used to pass settings used for validation. /// /// ParserContext /// XmlReader /// Should wrap 'reader' with an XML Compatibility Reader /// Sets synchronous or asynchronous parsing /// input as bool ///object root generated after xml parsed //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 private static object XmlTreeBuildDefault( ParserContext pc, XmlReader reader, bool wrapWithMarkupCompatReader, XamlParseMode parseMode, bool etwTracingEnabled) { XamlTreeBuilder treeBuilder = new XamlTreeBuilder(pc, reader, wrapWithMarkupCompatReader, parseMode); if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLINITIALIZEDGUID), MS.Utility.EventType.Info); } object root = treeBuilder.Parse(); return root; } ////// Reads XAML from the passed stream, building an object tree and returning the /// root of that tree. /// /// ParserContext /// input as stream /// Sets synchronous or asynchronous parsing /// input as bool ///object root generated after xml parsed //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 private static object XmlTreeBuildDefault( ParserContext pc, Stream stream, XamlParseMode parseMode, bool etwTracingEnabled) { XamlTreeBuilder treeBuilder = new XamlTreeBuilder(pc, stream, parseMode); if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLINITIALIZEDGUID), MS.Utility.EventType.Info); } object root = treeBuilder.Parse(); return root; } ////// Reads XAML from the passed stream, building an object tree and returning the /// root of that tree. /// /// ParserContext /// input as Stream /// hooks to callback during load /// input as bool ///object root generated after xml parsed //[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647 private static object XmlTreeBuildAssembly( ParserContext pc, Stream stream, ParserHooks hooks, bool etwTracingEnabled) { // When we have ParserHooks we need to load synchronously XamlTreeBuilder treeBuilder = new XamlTreeBuilder(pc, stream, XamlParseMode.Synchronous); treeBuilder.ParserHooks = hooks; if (etwTracingEnabled) { EventTrace.EventProvider.TraceEvent(EventTrace.GuidFromId(EventTraceGuidId.PARSEXMLINITIALIZEDGUID), MS.Utility.EventType.Info); } object root = treeBuilder.Parse(); return root; } #endregion PrivateMethods #region Data private XamlTreeBuilder _treeBuilder; #if DEBUG_CLR_MEM private static int _CLRBamlPass = 0; private static int _CLRXamlPass = 0; #endif #endregion Data } } // File provided for Reference Use Only by Microsoft Corporation (c) 2007. // Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- MarkupProperty.cs
- WorkflowServiceBehavior.cs
- ToolStripDropDownClosingEventArgs.cs
- RowToParametersTransformer.cs
- ISO2022Encoding.cs
- RootBuilder.cs
- XmlUtil.cs
- CipherData.cs
- IDQuery.cs
- PersonalizableTypeEntry.cs
- CapabilitiesRule.cs
- SqlDataSourceEnumerator.cs
- Rect.cs
- FilterQueryOptionExpression.cs
- UnknownWrapper.cs
- SchemaNotation.cs
- DataTemplateKey.cs
- FocusTracker.cs
- DebugController.cs
- AssociationType.cs
- TextHidden.cs
- XmlKeywords.cs
- SQLBinaryStorage.cs
- ReaderOutput.cs
- TraceListeners.cs
- ToolStripContentPanelDesigner.cs
- InstanceData.cs
- ConstraintStruct.cs
- IisNotInstalledException.cs
- Compiler.cs
- XmlTypeAttribute.cs
- XmlEventCache.cs
- KeyNotFoundException.cs
- SqlDependency.cs
- GlobalizationAssembly.cs
- InternalConfigSettingsFactory.cs
- XmlBinaryReader.cs
- WaitHandleCannotBeOpenedException.cs
- XmlBinaryReader.cs
- Regex.cs
- RootProfilePropertySettingsCollection.cs
- ColumnWidthChangingEvent.cs
- ListDataHelper.cs
- ObjectSet.cs
- Compress.cs
- HtmlInputHidden.cs
- X509Utils.cs
- DynamicExpression.cs
- StrokeCollectionConverter.cs
- LateBoundChannelParameterCollection.cs
- VerifyHashRequest.cs
- AutoGeneratedField.cs
- CacheOutputQuery.cs
- XmlSchemaExporter.cs
- FixedLineResult.cs
- DynamicILGenerator.cs
- WebBrowserSiteBase.cs
- RoleServiceManager.cs
- RoleGroup.cs
- ScriptIgnoreAttribute.cs
- HelpKeywordAttribute.cs
- RuleSettings.cs
- ScaleTransform3D.cs
- PersonalizableTypeEntry.cs
- DesignerSelectionListAdapter.cs
- Sql8ConformanceChecker.cs
- NotSupportedException.cs
- SatelliteContractVersionAttribute.cs
- WebPartDeleteVerb.cs
- ToolBarTray.cs
- PackagePart.cs
- ActionFrame.cs
- OutOfProcStateClientManager.cs
- AccessedThroughPropertyAttribute.cs
- DataControlFieldCell.cs
- SoapTypeAttribute.cs
- RegistryPermission.cs
- Container.cs
- ExpressionBuilderCollection.cs
- SqlDataSourceFilteringEventArgs.cs
- DropTarget.cs
- _ScatterGatherBuffers.cs
- ArglessEventHandlerProxy.cs
- ServiceEndpointElementCollection.cs
- ToolstripProfessionalRenderer.cs
- TreeNodeSelectionProcessor.cs
- SoundPlayer.cs
- StylusPointProperty.cs
- FocusWithinProperty.cs
- WebPartCancelEventArgs.cs
- translator.cs
- Permission.cs
- WebReferencesBuildProvider.cs
- TextParaLineResult.cs
- SelectionItemProviderWrapper.cs
- AppSecurityManager.cs
- DirectoryNotFoundException.cs
- ContentDisposition.cs
- CursorConverter.cs
- EpmContentDeSerializerBase.cs