C# XmlReaderSettings.GetType方法代码示例

        public static XmlReader OpenXml(string content)
        {
            var settings = new XmlReaderSettings();
            settings.CloseInput = true;
            settings.IgnoreComments = true;
            settings.IgnoreProcessingInstructions = true;
            settings.IgnoreWhitespace = true;
            settings.NameTable = new NameTable();

            // set XmlResolver via reflection, if it exists. This is required for desktop CLR, as otherwise the XML reader may
            // attempt to hit untrusted external resources.
            var xmlResolverProperty = settings.GetType().GetProperty("XmlResolver", BindingFlags.Public | BindingFlags.Instance);
            xmlResolverProperty?.SetValue(settings, null);

            // Create our own namespace manager so that we can set the default namespace
            // We need this because the XML serializer requires correct namespaces,
            // but project systems may not provide it.
            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(settings.NameTable);
            namespaceManager.AddNamespace(string.Empty, XmlNamespace);
            XmlParserContext context = new XmlParserContext(settings.NameTable, namespaceManager, string.Empty, XmlSpace.None);

            StringReader stringReader = null;
            XmlReader reader = null;
            bool success = false;

            try
            {
                stringReader = new StringReader(content);
                reader = XmlReader.Create(stringReader, settings, context);

                // Read to the top level element
                while (reader.NodeType != XmlNodeType.Element)
                    reader.Read();

                if (reader.NamespaceURI != XmlNamespace)
                {
                    throw new XmlException(string.Format(CultureInfo.CurrentCulture, MICoreResources.Error_UnknownXmlElement, reader.Name));
                }

                success = true;
                return reader;
            }
            finally
            {
                if (!success)
                {
                    if (reader != null)
                    {
                        reader.Dispose();
                    }
                    else if (stringReader != null)
                    {
                        // NOTE: the reader will close the input, so we only want to do this
                        // if we failed to create the reader.
                        stringReader.Dispose();
                    }
                }
            }
        }

        private bool LoadFile(string path)
        {
            try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(AutoVisualizer));
                if (!File.Exists(path))
                {
                    _process.WriteOutput(String.Format(CultureInfo.CurrentCulture, ResourceStrings.FileNotFound, path));
                    return false;
                }
                XmlReaderSettings settings = new XmlReaderSettings();
                settings.IgnoreComments = true;
                settings.IgnoreProcessingInstructions = true;
                settings.IgnoreWhitespace = true;

                // set XmlResolver via reflection, if it exists. This is required for desktop CLR, as otherwise the XML reader may
                // attempt to hit untrusted external resources.
                var xmlResolverProperty = settings.GetType().GetProperty("XmlResolver", BindingFlags.Public | BindingFlags.Instance);
                xmlResolverProperty?.SetValue(settings, null);

                using (var stream = new System.IO.FileStream(path, FileMode.Open, FileAccess.Read))
                using (var reader = XmlReader.Create(stream, settings))
                {
                    AutoVisualizer autoVis = null;
                    autoVis = serializer.Deserialize(reader) as AutoVisualizer;
                    if (autoVis != null)
                    {
                        FileInfo f = new FileInfo(autoVis);
                        if (autoVis.Items == null)
                        {
                            return false;
                        }
                        foreach (var o in autoVis.Items)
                        {
                            if (o is VisualizerType)
                            {
                                VisualizerType v = (VisualizerType)o;
                                TypeName t = TypeName.Parse(v.Name);
                                if (t != null)
                                {
                                    lock (_typeVisualizers)
                                    {
                                        f.Visualizers.Add(new TypeInfo(t, v));
                                    }
                                }
                                // add an entry for each alternative name too
                                if (v.AlternativeType != null)
                                {
                                    foreach (var a in v.AlternativeType)
                                    {
                                        t = TypeName.Parse(a.Name);
                                        if (t != null)
                                        {
                                            lock (_typeVisualizers)
                                            {
                                                f.Visualizers.Add(new TypeInfo(t, v));
                                            }
                                        }
                                    }
                                }
                            }
                            else if (o is AliasType)
                            {
                                AliasType a = (AliasType)o;
                                TypeName t = TypeName.Parse(a.Name);
                                if (t != null)
                                {
                                    lock (_typeVisualizers)
                                    {
                                        f.Aliases.Add(new AliasInfo(t, a));
                                    }
                                }
                            }
                        }
                        _typeVisualizers.Add(f);
                    }
                    return autoVis != null;
                }
            }
            catch (Exception exception)
            {
                // don't allow natvis failures to stop debugging
                _process.WriteOutput(String.Format(CultureInfo.CurrentCulture, ResourceStrings.ErrorReadingFile, exception.Message, path));
                return false;
            }
        }

 public int v3()
 {
     string readerType = (string)this.Param;
     XmlReaderSettings rs = new XmlReaderSettings();
     using (XmlReader r = ReaderHelper.CreateReader(readerType, new StringReader("<a/>"), false, null, rs))
     {
         bool cc = r.Settings.CheckCharacters;
         bool closeinput = r.Settings.CloseInput;
         DtdProcessing dtd = r.Settings.DtdProcessing;
         bool ignorecomm = r.Settings.IgnoreComments;
         bool ignorepi = r.Settings.IgnoreProcessingInstructions;
         bool ignorewhtsp = r.Settings.IgnoreWhitespace;
         int lineNumberOffset = r.Settings.LineNumberOffset;
         int linePositionOffset = r.Settings.LinePositionOffset;
         long maxcharsindoc = r.Settings.MaxCharactersInDocument;
         XmlNameTable nameTable = r.Settings.NameTable;
         ConformanceLevel cl = r.Settings.ConformanceLevel;
         Type t = r.Settings.GetType();
         rs.Reset();
         CError.Compare(cc, rs.CheckCharacters, "cc");
         CError.Compare(closeinput, rs.CloseInput, "closeinput");
         CError.Compare(dtd, rs.DtdProcessing, "dtd");
         CError.Compare(ignorecomm, rs.IgnoreComments, "ignorecomm");
         CError.Compare(ignorepi, rs.IgnoreProcessingInstructions, "ignorepi");
         CError.Compare(ignorewhtsp, rs.IgnoreWhitespace, "ignorewhtsp");
         CError.Compare(lineNumberOffset, rs.LineNumberOffset, "lineNumberOffset");
         CError.Compare(linePositionOffset, rs.LinePositionOffset, "linePositionOffset");
         CError.Compare(maxcharsindoc, rs.MaxCharactersInDocument, "maxcharsindoc");
         CError.Compare(nameTable, rs.NameTable, "nameTable");
         CError.Compare(cl, rs.ConformanceLevel, "cl");
         CError.Compare(t, rs.GetType(), "t");
         return TEST_PASS;
     }
 }

 public int v4()
 {
     XmlReaderSettings rs = new XmlReaderSettings();
     XmlReaderSettings crs = rs.Clone();
     CError.Compare(rs.CheckCharacters, crs.CheckCharacters, "CheckCharacters");
     CError.Compare(rs.CloseInput, crs.CloseInput, "CloseInput");
     CError.Compare(rs.DtdProcessing, crs.DtdProcessing, "ProhibitDtd");
     CError.Compare(rs.IgnoreComments, crs.IgnoreComments, "IgnoreComments");
     CError.Compare(rs.IgnoreProcessingInstructions, crs.IgnoreProcessingInstructions, "IgnorePI");
     CError.Compare(rs.IgnoreWhitespace, crs.IgnoreWhitespace, "IgnoreWhitespace");
     CError.Compare(rs.LineNumberOffset, crs.LineNumberOffset, "LineNumberOffset");
     CError.Compare(rs.LinePositionOffset, crs.LinePositionOffset, "LinePositionOffset");
     CError.Compare(rs.MaxCharactersInDocument, crs.MaxCharactersInDocument, "maxcharsindoc");
     CError.Compare(rs.NameTable, crs.NameTable, "NameTable");
     CError.Compare(rs.ConformanceLevel, crs.ConformanceLevel, "ConformanceLevel");
     CError.Compare(rs.GetType(), crs.GetType(), "GetType");
     return TEST_PASS;
 }

        /// <summary>This helper function constructs XmlReader object
        /// using provided XML source code.</summary>
        /// <param name="xmlSource">Source XML data.</param>
        /// <returns>XmlReader object.</returns>
        public static XmlReader GetXMLReader(string xmlSource)
        {
            if (xmlSource.Contains("<!DOCTYPE html>")) {
                xmlSource = xmlSource.Replace("<!DOCTYPE html>", "<!DOCTYPE html PUBLIC " +
                    "\"-//W3C//DTD XHTML 1.0 Transitional//EN\" " +
                    "\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">");
            }
            if (!xmlSource.Contains("<html xmlns=")) {
                xmlSource = xmlSource.Replace("<html",
                    "<html xmlns=\"http://www.w3.org/1999/xhtml\"");
            }

            StringReader strReader = new StringReader(xmlSource);
            XmlReaderSettings settings = new XmlReaderSettings();
            settings.XmlResolver = new XmlUrlResolverWithCache();
            settings.CheckCharacters = false;
            settings.IgnoreComments = true;
            settings.IgnoreProcessingInstructions = true;
            settings.IgnoreWhitespace = true;

            // For .NET 4.0 and higher DtdProcessing property should be used instead of ProhibitDtd
            if (settings.GetType().GetProperty("DtdProcessing") != null) {
                Type t = typeof(XmlReaderSettings).GetProperty("DtdProcessing").PropertyType;
                settings.GetType().InvokeMember("DtdProcessing",
                    BindingFlags.DeclaredOnly | BindingFlags.Public |
                    BindingFlags.Instance | BindingFlags.SetProperty, null, settings,
                    new Object[] { Enum.Parse(t, "2") });    // 2 is a value of DtdProcessing.Parse
            }
            else if (settings.GetType().GetProperty("ProhibitDtd") != null) {
                settings.GetType().InvokeMember("ProhibitDtd",
                    BindingFlags.DeclaredOnly | BindingFlags.Public |
                    BindingFlags.Instance | BindingFlags.SetProperty,
                    null, settings, new Object[] { false });
            }

            return XmlReader.Create(strReader, settings);
        }