private static object Load(Stream stream)
 {
     var pc = new ParserContext();
     MethodInfo loadBamlMethod = typeof (XamlReader).GetMethod("LoadBaml",
         BindingFlags.NonPublic | BindingFlags.Static);
     return loadBamlMethod.Invoke(null, new object[] {stream, pc, null, false});
 }

 /// <summary>
 /// Create a BamlWriter on the passed stream.  The stream must be writable.
 /// </summary>
 public BamlWriter(
     Stream stream)
 {
     if (null == stream)
     {
         throw new ArgumentNullException( "stream" );
     }
     if (!stream.CanWrite)
     {
         throw new ArgumentException(SR.Get(SRID.BamlWriterBadStream));
     }
     
     _parserContext = new ParserContext();
     if (null == _parserContext.XamlTypeMapper) 
     {
         _parserContext.XamlTypeMapper = new BamlWriterXamlTypeMapper(XmlParserDefaults.GetDefaultAssemblyNames(),
                                                                      XmlParserDefaults.GetDefaultNamespaceMaps());
     }
     _xamlTypeMapper = _parserContext.XamlTypeMapper;
     _bamlRecordWriter = new BamlRecordWriter(stream, _parserContext, true);
     _startDocumentWritten = false;
     _depth = 0;
     _closed = false;
     _nodeTypeStack = new ParserStack();
     _assemblies = new Hashtable(7);
    _extensionParser = new MarkupExtensionParser((IParserHelper)this, _parserContext);
    _markupExtensionNodes = new ArrayList();
 }

        private static void OnBoundDocumentChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            RichTextBox box = d as RichTextBox;

            if (box == null)
                return;

            RemoveEventHandler(box);

            string newXAML = GetBoundDocument(d);

            box.Document.Blocks.Clear();

            if (!string.IsNullOrEmpty(newXAML))
            {
                using (MemoryStream xamlMemoryStream = new MemoryStream(Encoding.ASCII.GetBytes(newXAML)))
                {
                    ParserContext parser = new ParserContext();
                    parser.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
                    parser.XmlnsDictionary.Add("x", "http://schemas.microsoft.com/winfx/2006/xaml");
                    FlowDocument doc = new FlowDocument();
                    Section section = XamlReader.Load(xamlMemoryStream, parser) as Section;

                    box.Document.Blocks.Add(section);

                }
            }

            AttachEventHandler(box);

        }

        public static object LoadBaml(Stream stream)
        {
            var presentationFrameworkAssembly = Assembly.GetAssembly(typeof(Button));

            if( Environment.Version.Major == 4)
            {
                var xamlAssembly = Assembly.Load("System.Xaml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
                var readerType = presentationFrameworkAssembly.GetType("System.Windows.Baml2006.Baml2006Reader");
                var reader = Activator.CreateInstance(readerType, stream);
                var schemaContextProperty = readerType.GetProperty("SchemaContext");
                var schemaContext = schemaContextProperty.GetGetMethod().Invoke(reader, null);
                var writerType = xamlAssembly.GetType("System.Xaml.XamlObjectWriter");
                var writer = Activator.CreateInstance(writerType, schemaContext);
                var readerReadMethod = readerType.GetMethod("Read");
                var writerWriteMethod = writerType.GetMethod("WriteNode");
                while( (bool)readerReadMethod.Invoke(reader, null))
                {
                    writerWriteMethod.Invoke(writer, new[] {reader});
                }
                var writerResultProperty = writerType.GetProperty("Result");
                return writerResultProperty.GetGetMethod().Invoke(writer, null);
            }
            else
            {
                var pc = new ParserContext();
                var readerType = presentationFrameworkAssembly.GetType("System.Windows.Markup.XamlReader");
                var method = readerType.GetMethod("LoadBaml", BindingFlags.NonPublic | BindingFlags.Static);
                return method.Invoke(null, new object[] {stream, pc, null, false});
            }
        }

 public static object DeSerializeObjectTree(string xaml)
 {
     Stream stream = ConvertTextToStream(xaml);
     ParserContext parserContext = new ParserContext();
     parserContext.BaseUri = new Uri("pack://siteoforigin:,,,/");
     return XamlReader.Load(stream, parserContext);
 }

        // ---------------------------------------------------------------------
        //
        // Internal Methods
        //
        // ---------------------------------------------------------------------

        #region Internal Methods

        public static FlowDocument DeserializeFlowDocument(string strFlowDocumentXML)
        {
            Debug.WriteLine("DeserializeFlowDocument: " + strFlowDocumentXML);
            try
            {
                MemoryStream memoryStream = new MemoryStream(strFlowDocumentXML.Length);
                using (StreamWriter streamWriter = new StreamWriter(memoryStream))
                {
                    streamWriter.Write(strFlowDocumentXML);
                    streamWriter.Flush();

                    memoryStream.Seek(0, SeekOrigin.Begin);

                    ParserContext parserContext = new ParserContext();

                    parserContext.BaseUri = new Uri(System.Environment.CurrentDirectory + "/");

                    return XamlReader.Load(memoryStream, parserContext) as FlowDocument;
                }
            }
            catch (Exception ex)
            {
                Debug.Assert(false, "Load flow document failed! :" +ex);
                //return new FlowDocument();
                throw ex;
            }
        }

        // <summary>
        // Creates an object instance from a Baml stream and it's Uri 
        // </summary>
        internal static object BamlConverter(Stream stream, Uri baseUri, bool canUseTopLevelBrowser, bool sandboxExternalContent, bool allowAsync, bool isJournalNavigation, out XamlReader asyncObjectConverter) 
        { 
            asyncObjectConverter = null;
 
            // If this stream comes from outside the application throw
            //
            if (!BaseUriHelper.IsPackApplicationUri(baseUri))
            { 
                throw new InvalidOperationException(SR.Get(SRID.BamlIsNotSupportedOutsideOfApplicationResources));
            } 
 
            // If this stream comes from a content file also throw
            Uri partUri = PackUriHelper.GetPartUri(baseUri); 
            string partName, assemblyName, assemblyVersion, assemblyKey;
            BaseUriHelper.GetAssemblyNameAndPart(partUri, out partName, out assemblyName, out assemblyVersion, out assemblyKey);
            if (ContentFileHelper.IsContentFile(partName))
            { 
                throw new InvalidOperationException(SR.Get(SRID.BamlIsNotSupportedOutsideOfApplicationResources));
            } 
 
            ParserContext pc = new ParserContext();
 
            pc.BaseUri = baseUri;
            pc.SkipJournaledProperties = isJournalNavigation;

            return Application.LoadBamlStreamWithSyncInfo(stream, pc); 
        }

        public static ResourceDictionary LoadFromPng( string FileName )
        {
            // read all file
            PngReader pngr = FileHelper.CreatePngReader(FileName);
            pngr.ReadSkippingAllRows();
            pngr.End();
            // we assume there can be at most one chunk of this type...
            PngChunk chunk = pngr.GetChunksList().GetById1(PngChunkSKIN.ID); // This would work even if not registered, but then PngChunk would be of type PngChunkUNKNOWN

            if (chunk != null) {
                // the following would fail if we had not register the chunk
                PngChunkSKIN chunkprop = (PngChunkSKIN)chunk;
                ParserContext pc = new ParserContext();
                pc.XamlTypeMapper = XamlTypeMapper.DefaultMapper;
              //  pc.XmlSpace

                //MimeObjectFactory s;

                var rd1 = (ResourceDictionary)XamlReader.Parse(chunkprop.Content);

              // Application.Current.Resources.MergedDictionaries.Add(rd1);

              //  var rd2 = (ResourceDictionary)XamlReader.Parse(chunkprop.Content);

              ////  Application.Current.Resources.MergedDictionaries.Add(rd2);

              //  if (rd1 == rd2) {
              //  }

                return rd1;
            } else {
                return null;
            }
        }

        public WpfContainer()
        {
            Context = new ParserContext();
            Context.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
            Context.XmlnsDictionary.Add("x", "http://schemas.microsoft.com/winfx/2006/xaml");

            XamlFile = null;
        }

 static XamlToObjectConverter()
 {
     // Initialize the parser context, which provides xml namespace mappings used when
     // the loose XAML is loaded and converted into a .NET object.
     parserContext = new ParserContext();
     parserContext.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
     parserContext.XmlnsDictionary.Add("x", "http://schemas.microsoft.com/winfx/2006/xaml");
 }

		public static FrameworkElement Parse(string xaml)
		{
			var context = new ParserContext();
			context.XmlnsDictionary.Add(string.Empty, "http://schemas.microsoft.com/winfx/2006/xaml/presentation");

			var element = (FrameworkElement)XamlReader.Parse(xaml, context);
			return element;
		}

        /// <summary>
        /// Parse a string to WPF object.
        /// </summary>
        /// <param name="str">string to be parsed</param>
        /// <returns>return an object</returns>
        public static object ParseXaml(string str)
        {
            MemoryStream ms = new MemoryStream(str.Length);
            StreamWriter sw = new StreamWriter(ms);
            sw.Write(str);
            sw.Flush();

            ms.Seek(0, SeekOrigin.Begin);

            ParserContext pc = new ParserContext();

            pc.BaseUri = new Uri(System.Environment.CurrentDirectory + "/");

            return XamlReader.Load(ms, pc);
        }

        /// <summary>
        /// Creates a new instance.
        /// </summary>
        public EnumComboBox()
        {
            var context = new ParserContext();

            context.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
            context.XmlnsDictionary.Add("lex", "http://wpflocalizeextension.codeplex.com");

            var xaml = "<DataTemplate><TextBlock><lex:EnumRun EnumValue=\"{Binding}\"";
            xaml += " PrependType=\"{Binding PrependType, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=lex:EnumComboBox}}\"";
            xaml += " Separator=\"{Binding Separator, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=lex:EnumComboBox}}\"";
            xaml += " Prefix=\"{Binding Prefix, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType=lex:EnumComboBox}}\"";
            xaml += " /></TextBlock></DataTemplate>";

            ItemTemplate = (DataTemplate)XamlReader.Parse(xaml, context);
        }

		public static FlexDocument ParseDocument(string configFilePath)
		{
			//try
			//{
			var parserContext = new ParserContext();
			var configFileStream = new FileStream(configFilePath, FileMode.Open);
			var configObject = XamlReader.Load(configFileStream, parserContext);
			var chartConfigObject = (FlexDocument)configObject;
			return chartConfigObject;
			//}
			//catch// (Exception ex)
			//{
			//	throw;// ex;// new Exception("Parser fail");
			//} 
		}

        public static ControlTemplate GetTemplate()
        {
            if (m_TemplateCache == null)
            {
                //m_TemplateCache = new ControlTemplate();

                //m_TemplateCache.VisualTree = new System.Windows.FrameworkElementFactory(typeof(TextErrorTemplateVisualtree));
                MemoryStream sr = new MemoryStream(Encoding.ASCII.GetBytes(c_TemplateXaml));
                ParserContext pc = new ParserContext();
                pc.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
                pc.XmlnsDictionary.Add("x", "http://schemas.microsoft.com/winfx/2006/xaml");
                m_TemplateCache = (ControlTemplate)XamlReader.Load(sr, pc);
            }
            return m_TemplateCache;
        }

            private static DataTemplate CreateTemplate(Type viewModelType, Type viewType)
            {
                var xaml = $"<DataTemplate DataType=\"{{x:Type vm:{viewModelType.Name}}}\"><v:{viewType.Name} /></DataTemplate>";

                var context = new ParserContext();

                context.XamlTypeMapper = new XamlTypeMapper(new string[0]);
                context.XamlTypeMapper.AddMappingProcessingInstruction("vm", viewModelType.Namespace, viewModelType.Assembly.FullName);
                context.XamlTypeMapper.AddMappingProcessingInstruction("v", viewType.Namespace, viewType.Assembly.FullName);

                context.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
                context.XmlnsDictionary.Add("x", "http://schemas.microsoft.com/winfx/2006/xaml");
                context.XmlnsDictionary.Add("vm", "vm");
                context.XmlnsDictionary.Add("v", "v");

                var template = (DataTemplate)XamlReader.Parse(xaml, context);
                return template;
            }

        private DataTemplate CreateTemplate()
        {
            const string xamlTemplate = "<DataTemplate x:Name=\"Tpl\">" +
                                        "   <TextBox Background=\"{{Binding Background, ElementName=Txt}}\"" +
                                        "            Text=\"{{Binding Value}}\" />" +
                                        "</DataTemplate>";
            var xaml = string.Format(xamlTemplate);

            var context = new ParserContext();

            var type = typeof(DataTemplateSampleView);
            context.XamlTypeMapper = new XamlTypeMapper(new string[0]);
            context.XamlTypeMapper.AddMappingProcessingInstruction("v", type.Namespace, type.Assembly.FullName);

            context.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
            context.XmlnsDictionary.Add("x", "http://schemas.microsoft.com/winfx/2006/xaml");
            context.XmlnsDictionary.Add("v", "v");

            var template = (DataTemplate) XamlReader.Parse(xaml, context);
            return template;
        }

        public override void Run()
        {
            String xamlFile = null;

              using (var writer = new System.IO.StringWriter()) {
            using (var ofd = new System.Windows.Forms.OpenFileDialog() {
                 Filter = "XAML File|*.xaml"
               }) {
              if (ofd.ShowDialog() != DialogResult.OK)
            return;
              xamlFile = ofd.FileName;
            }
              }
              var xamlStr = System.IO.File.ReadAllText(xamlFile);
              var pc = new ParserContext();
              //
              pc.XamlTypeMapper = new XamlTypeMapper(new string[] {  });
              //
              pc.XamlTypeMapper.AddMappingProcessingInstruction("ad", "AvalonDock", "AvalonDock");
              pc.XamlTypeMapper.AddMappingProcessingInstruction("adRes", "AvalonDock.Properties", "AvalonDock");
              pc.XamlTypeMapper.AddMappingProcessingInstruction("sys", "System", "mscorlib");
              pc.XamlTypeMapper.AddMappingProcessingInstruction("th", "ThemeTool","AnotherThemeTool");
              //
              pc.XmlnsDictionary.Add("ad", "ad");
              pc.XmlnsDictionary.Add("adRes", "adRes");
              pc.XmlnsDictionary.Add("sys", "sys");
              pc.XmlnsDictionary.Add("th", "th");
              Assembly.LoadWithPartialName("AnotherThemeTool");
            //      pc.BaseUri = new Uri(@"clr-namespace:AnotherThemeTool",UriKind.RelativeOrAbsolute);
              var rd = (ResourceDictionary)XamlReader.Parse(xamlStr);
              //
              AvalonDock.ThemeFactory.ResetTheme();
            //      System.Windows.Application.Current.Resources.MergedDictionaries.Add(
            //        new ResourceDictionary{Source=new Uri(@"/AvalonDock;component/themes/generic.xaml",UriKind.RelativeOrAbsolute)}
            //       );
              System.Windows.Application.Current.Resources.MergedDictionaries.Add(rd);
        }

        private static DataTemplate CreateContentTemplate()
        {
            const string xaml =
                "<DataTemplate><Border b:TabContent.InternalTabControl=\"{Binding RelativeSource={RelativeSource AncestorType=TabControl}}\" /></DataTemplate>";

            var context = new ParserContext();

            context.XamlTypeMapper = new XamlTypeMapper(new string[0]);
            context.XamlTypeMapper.AddMappingProcessingInstruction("b", typeof (TabContent).Namespace,
                typeof (TabContent).Assembly.FullName);

            context.XmlnsDictionary.Add("", "http://schemas.microsoft.com/winfx/2006/xaml/presentation");
            context.XmlnsDictionary.Add("b", "b");

            var template = (DataTemplate) XamlReader.Parse(xaml, context);
            return template;
        }

		public object LoadAsync (Stream stream, ParserContext context)
		{
			if (stream == null || context == null)
				throw new ArgumentNullException ();
			throw new NotImplementedException ();
		}