private object LoadAsync(XmlReader reader, ParserContext parserContext)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (parserContext == null)
{
parserContext = new ParserContext();
}
_xmlReader = reader;
object rootObject = null;
if (parserContext.BaseUri == null ||
String.IsNullOrEmpty(parserContext.BaseUri.ToString()))
{
if (reader.BaseURI == null ||
String.IsNullOrEmpty(reader.BaseURI.ToString()))
{
parserContext.BaseUri = BaseUriHelper.PackAppBaseUri;
}
else
{
parserContext.BaseUri = new Uri(reader.BaseURI);
}
}
_baseUri = parserContext.BaseUri;
System.Xaml.XamlXmlReaderSettings settings = new System.Xaml.XamlXmlReaderSettings();
settings.IgnoreUidsOnPropertyElements = true;
settings.BaseUri = parserContext.BaseUri;
settings.ProvideLineInfo = true;
XamlSchemaContext schemaContext = parserContext.XamlTypeMapper != null ?
parserContext.XamlTypeMapper.SchemaContext : GetWpfSchemaContext();
try
{
_textReader = new System.Xaml.XamlXmlReader(reader, schemaContext, settings);
_stack = new XamlContextStack <WpfXamlFrame>(() => new WpfXamlFrame());
System.Xaml.XamlObjectWriterSettings objectSettings = XamlReader.CreateObjectWriterSettings();
objectSettings.AfterBeginInitHandler = delegate(object sender, System.Xaml.XamlObjectEventArgs args)
{
if (rootObject == null)
{
rootObject = args.Instance;
_styleConnector = rootObject as IStyleConnector;
}
UIElement uiElement = args.Instance as UIElement;
if (uiElement != null)
{
uiElement.SetPersistId(_persistId++);
}
DependencyObject dObject = args.Instance as DependencyObject;
if (dObject != null && _stack.CurrentFrame.XmlnsDictionary != null)
{
XmlnsDictionary dictionary = _stack.CurrentFrame.XmlnsDictionary;
dictionary.Seal();
XmlAttributeProperties.SetXmlnsDictionary(dObject, dictionary);
}
};
_objectWriter = new System.Xaml.XamlObjectWriter(_textReader.SchemaContext, objectSettings);
_parseCancelled = false;
_skipJournaledProperties = parserContext.SkipJournaledProperties;
XamlMember synchronousModeProperty = _textReader.SchemaContext.GetXamlDirective("http://schemas.microsoft.com/winfx/2006/xaml", "SynchronousMode");
XamlMember synchronousRecordProperty = _textReader.SchemaContext.GetXamlDirective("http://schemas.microsoft.com/winfx/2006/xaml", "AsyncRecords");
System.Xaml.XamlReader xamlReader = _textReader;
IXamlLineInfo xamlLineInfo = xamlReader as IXamlLineInfo;
IXamlLineInfoConsumer xamlLineInfoConsumer = _objectWriter as IXamlLineInfoConsumer;
bool shouldPassLineNumberInfo = false;
if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) &&
(xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo))
{
shouldPassLineNumberInfo = true;
}
bool async = false;
bool lastPropWasSyncMode = false;
bool lastPropWasSyncRecords = false;
while (!_textReader.IsEof)
{
WpfXamlLoader.TransformNodes(xamlReader, _objectWriter, true /*onlyLoadOneNode*/, _skipJournaledProperties, shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer, _stack, _styleConnector);
if (xamlReader.NodeType == System.Xaml.XamlNodeType.StartMember)
{
if (xamlReader.Member == synchronousModeProperty)
{
lastPropWasSyncMode = true;
}
else if (xamlReader.Member == synchronousRecordProperty)
{
lastPropWasSyncRecords = true;
}
}
else if (xamlReader.NodeType == System.Xaml.XamlNodeType.Value)
{
if (lastPropWasSyncMode == true)
{
if (xamlReader.Value as String == "Async")
{
async = true;
}
}
else if (lastPropWasSyncRecords == true)
{
if (xamlReader.Value is int)
{
_maxAsynxRecords = (int)xamlReader.Value;
}
else if (xamlReader.Value is String)
{
_maxAsynxRecords = Int32.Parse(xamlReader.Value as String, TypeConverterHelper.InvariantEnglishUS);
}
}
}
else if (xamlReader.NodeType == System.Xaml.XamlNodeType.EndMember)
{
lastPropWasSyncMode = false;
lastPropWasSyncRecords = false;
}
if (async && rootObject != null)
{
break;
}
}
}
catch (Exception e)
{
// Don't wrap critical exceptions or already-wrapped exceptions.
if (MS.Internal.CriticalExceptions.IsCriticalException(e) || !ShouldReWrapException(e, parserContext.BaseUri))
{
throw;
}
RewrapException(e, parserContext.BaseUri);
}
if (!_textReader.IsEof)
{
Post();
//ThreadStart threadStart = new ThreadStart(ReadXamlAsync);
//Thread thread = new Thread(threadStart);
//thread.Start();
}
else
{
TreeBuildComplete();
}
if (rootObject is DependencyObject)
{
if (parserContext.BaseUri != null && !String.IsNullOrEmpty(parserContext.BaseUri.ToString()))
{
(rootObject as DependencyObject).SetValue(BaseUriHelper.BaseUriProperty, parserContext.BaseUri);
}
//else
// (rootObject as DependencyObject).SetValue(BaseUriHelper.BaseUriProperty, BaseUriHelper.PackAppBaseUri);
WpfXamlLoader.EnsureXmlNamespaceMaps(rootObject, schemaContext);
}
Application app = rootObject as Application;
if (app != null)
{
app.ApplicationMarkupBaseUri = GetBaseUri(settings.BaseUri);
}
return(rootObject);
}
/// <summary>
/// called when in async mode when get a time slice to read and load the Tree
/// </summary>
internal virtual void HandleAsyncQueueItem()
{
try
{
int startTickCount = MS.Win32.SafeNativeMethods.GetTickCount();
//bool moreData = true;
// for debugging, can set the Maximum Async records to
// read via markup
// x:AsyncRecords="3" would loop three times
// Todo: This should either be removed at some point
int maxRecords = _maxAsynxRecords;
System.Xaml.XamlReader xamlReader = _textReader;
IXamlLineInfo xamlLineInfo = xamlReader as IXamlLineInfo;
IXamlLineInfoConsumer xamlLineInfoConsumer = _objectWriter as IXamlLineInfoConsumer;
bool shouldPassLineNumberInfo = false;
if ((xamlLineInfo != null && xamlLineInfo.HasLineInfo) &&
(xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo))
{
shouldPassLineNumberInfo = true;
}
XamlMember synchronousRecordProperty = _textReader.SchemaContext.GetXamlDirective(XamlLanguage.Xaml2006Namespace, "AsyncRecords");
while (!xamlReader.IsEof && !_parseCancelled)
{
WpfXamlLoader.TransformNodes(xamlReader, _objectWriter, true /*onlyLoadOneNode*/, _skipJournaledProperties, shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer, _stack, _styleConnector);
if (xamlReader.NodeType == System.Xaml.XamlNodeType.Value && _stack.CurrentFrame.Property == synchronousRecordProperty)
{
if (xamlReader.Value is int)
{
_maxAsynxRecords = (int)xamlReader.Value;
}
else if (xamlReader.Value is String)
{
_maxAsynxRecords = Int32.Parse(xamlReader.Value as String, TypeConverterHelper.InvariantEnglishUS);
}
maxRecords = _maxAsynxRecords;
}
//Debug.Assert (1 >= RootList.Count, "Multiple roots not supported in async mode");
// check the timeout
int elapsed = MS.Win32.SafeNativeMethods.GetTickCount() - startTickCount;
// check for rollover
if (elapsed < 0)
{
startTickCount = 0; // reset to 0,
}
else if (elapsed > AsyncLoopTimeout)
{
break;
}
// decrement and compare with zero so the unitialized -1 and zero case
// doesn't break the loop.
if (--maxRecords == 0)
{
break;
}
}
}
catch (XamlParseException e)
{
_parseException = e;
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e) || !XamlReader.ShouldReWrapException(e, _baseUri))
{
_parseException = e;
}
else
{
_parseException = XamlReader.WrapException(e, null, _baseUri);
}
}
finally
{
if (_parseException != null || _parseCancelled)
{
TreeBuildComplete();
}
else
{
// if not at the EndOfDocument then post another work item
if (false == _textReader.IsEof)
{
Post();
}
else
{
// Building of the Tree is complete.
TreeBuildComplete();
}
}
}
}
// Token: 0x0600226A RID: 8810 RVA: 0x000AAE10 File Offset: 0x000A9010
private static object Load(XamlReader xamlReader, IXamlObjectWriterFactory writerFactory, bool skipJournaledProperties, object rootObject, XamlObjectWriterSettings settings, Uri baseUri)
{
XamlContextStack <WpfXamlFrame> stack = new XamlContextStack <WpfXamlFrame>(() => new WpfXamlFrame());
int persistId = 1;
settings.AfterBeginInitHandler = delegate(object sender, XamlObjectEventArgs args)
{
if (EventTrace.IsEnabled(EventTrace.Keyword.KeywordPerf | EventTrace.Keyword.KeywordXamlBaml, EventTrace.Level.Verbose))
{
IXamlLineInfo xamlLineInfo2 = xamlReader as IXamlLineInfo;
int num = -1;
int num2 = -1;
if (xamlLineInfo2 != null && xamlLineInfo2.HasLineInfo)
{
num = xamlLineInfo2.LineNumber;
num2 = xamlLineInfo2.LinePosition;
}
EventTrace.EventProvider.TraceEvent(EventTrace.Event.WClientParseXamlBamlInfo, EventTrace.Keyword.KeywordPerf | EventTrace.Keyword.KeywordXamlBaml, EventTrace.Level.Verbose, new object[]
{
(args.Instance == null) ? 0L : PerfService.GetPerfElementID(args.Instance),
num,
num2
});
}
UIElement uielement = args.Instance as UIElement;
if (uielement != null)
{
UIElement uielement2 = uielement;
int persistId = persistId;
persistId++;
uielement2.SetPersistId(persistId);
}
XamlSourceInfoHelper.SetXamlSourceInfo(args.Instance, args, baseUri);
DependencyObject dependencyObject = args.Instance as DependencyObject;
if (dependencyObject != null && stack.CurrentFrame.XmlnsDictionary != null)
{
XmlnsDictionary xmlnsDictionary = stack.CurrentFrame.XmlnsDictionary;
xmlnsDictionary.Seal();
XmlAttributeProperties.SetXmlnsDictionary(dependencyObject, xmlnsDictionary);
}
stack.CurrentFrame.Instance = args.Instance;
};
XamlObjectWriter xamlObjectWriter;
if (writerFactory != null)
{
xamlObjectWriter = writerFactory.GetXamlObjectWriter(settings);
}
else
{
xamlObjectWriter = new XamlObjectWriter(xamlReader.SchemaContext, settings);
}
IXamlLineInfo xamlLineInfo = null;
object result;
try
{
xamlLineInfo = (xamlReader as IXamlLineInfo);
IXamlLineInfoConsumer xamlLineInfoConsumer = xamlObjectWriter;
bool shouldPassLineNumberInfo = false;
if (xamlLineInfo != null && xamlLineInfo.HasLineInfo && xamlLineInfoConsumer != null && xamlLineInfoConsumer.ShouldProvideLineInfo)
{
shouldPassLineNumberInfo = true;
}
IStyleConnector styleConnector = rootObject as IStyleConnector;
WpfXamlLoader.TransformNodes(xamlReader, xamlObjectWriter, false, skipJournaledProperties, shouldPassLineNumberInfo, xamlLineInfo, xamlLineInfoConsumer, stack, styleConnector);
xamlObjectWriter.Close();
result = xamlObjectWriter.Result;
}
catch (Exception ex)
{
if (CriticalExceptions.IsCriticalException(ex) || !XamlReader.ShouldReWrapException(ex, baseUri))
{
throw;
}
XamlReader.RewrapException(ex, xamlLineInfo, baseUri);
result = null;
}
return(result);
}
