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
- EntityDataSourceChangedEventArgs.cs
- FormViewCommandEventArgs.cs
- OutputCacheProfile.cs
- WindowsUpDown.cs
- DesignerSerializerAttribute.cs
- XPathNavigator.cs
- Viewport3DAutomationPeer.cs
- CurrencyManager.cs
- CollectionViewProxy.cs
- Selection.cs
- HitTestWithPointDrawingContextWalker.cs
- PersonalizableAttribute.cs
- CodeAttributeArgument.cs
- AssertUtility.cs
- XmlILStorageConverter.cs
- CodeTypeMemberCollection.cs
- XPathSelfQuery.cs
- TextDecorationLocationValidation.cs
- RestHandlerFactory.cs
- WeakReference.cs
- TypeToken.cs
- HostedTransportConfigurationBase.cs
- ExpandSegmentCollection.cs
- Utils.cs
- PropertyItemInternal.cs
- MasterPage.cs
- XmlDomTextWriter.cs
- ActiveXContainer.cs
- WebPartCatalogAddVerb.cs
- TimeSpanSecondsConverter.cs
- FileStream.cs
- FeatureAttribute.cs
- BrowserTree.cs
- RegexCharClass.cs
- ISO2022Encoding.cs
- IntegerValidatorAttribute.cs
- filewebresponse.cs
- Brush.cs
- ToolboxItemSnapLineBehavior.cs
- HandleCollector.cs
- SHA512CryptoServiceProvider.cs
- WebPartEventArgs.cs
- RightsManagementSuppressedStream.cs
- FtpWebRequest.cs
- UIntPtr.cs
- WebMethodAttribute.cs
- Panel.cs
- ExpressionNode.cs
- SendSecurityHeaderElement.cs
- EditModeSwitchButton.cs
- InfoCardRSAOAEPKeyExchangeFormatter.cs
- WindowsStatic.cs
- UInt32Converter.cs
- ServiceDescriptions.cs
- UserControl.cs
- __Filters.cs
- ProfileSection.cs
- HtmlInputPassword.cs
- CodeSubDirectoriesCollection.cs
- MgmtConfigurationRecord.cs
- InfoCardKeyedHashAlgorithm.cs
- RectangleConverter.cs
- IntellisenseTextBox.cs
- TextServicesCompartmentEventSink.cs
- UncommonField.cs
- ConstantExpression.cs
- XmlCountingReader.cs
- DrawingGroup.cs
- TextServicesCompartmentContext.cs
- ControlParser.cs
- KeyConverter.cs
- ScriptControlManager.cs
- ClientScriptManagerWrapper.cs
- ComponentManagerBroker.cs
- HttpModuleActionCollection.cs
- AttributeCollection.cs
- ISFClipboardData.cs
- SQLSingleStorage.cs
- NumericUpDownAccelerationCollection.cs
- SafeBitVector32.cs
- DescendantQuery.cs
- X509CertificateTrustedIssuerElementCollection.cs
- WebConvert.cs
- SystemIPInterfaceStatistics.cs
- XamlUtilities.cs
- XPathChildIterator.cs
- DataColumn.cs
- DateTimeFormat.cs
- UmAlQuraCalendar.cs
- WebPartChrome.cs
- CollectionTypeElement.cs
- PropertyTabChangedEvent.cs
- DefinitionBase.cs
- ObjectPersistData.cs
- SystemIPv4InterfaceProperties.cs
- InitializerFacet.cs
- sqlnorm.cs
- ResourceManager.cs
- SparseMemoryStream.cs
- PropertySet.cs