Exemplo n.º 1
0
 internal void Load(XmlDocument doc, XmlReader reader, bool preserveWhitespace)
 {
     _doc = doc;
     // perf: unwrap XmlTextReader if no one derived from it
     if (reader.GetType() == typeof(System.Xml.XmlTextReader))
     {
         _reader = ((XmlTextReader)reader).Impl;
     }
     else
     {
         _reader = reader;
     }
     _preserveWhitespace = preserveWhitespace;
     if (doc == null)
         throw new ArgumentException(SR.Xdom_Load_NoDocument);
     if (reader == null)
         throw new ArgumentException(SR.Xdom_Load_NoReader);
     doc.SetBaseURI(reader.BaseURI);
     if (reader.Settings != null
         && reader.Settings.ValidationType == ValidationType.Schema)
     {
         doc.Schemas = reader.Settings.Schemas;
     }
     if (_reader.ReadState != ReadState.Interactive)
     {
         if (!_reader.Read())
             return;
     }
     LoadDocSequence(doc);
 }
        public static long GetPosition(this XmlReader xmlReader, StreamReader underlyingStreamReader)
        {
            Contract.Requires <ArgumentNullException>(xmlReader != null);
            Contract.Requires <ArgumentNullException>(underlyingStreamReader != null);
            Contract.Requires <InvalidOperationException>(xmlReader.GetType().Name == "XmlTextReaderImpl");

            // get the 'base' position from the root stream
            long stream_position = underlyingStreamReader.BaseStream.Position;

            // get the underlying stream's buffer state and text encoding preamble
            var stream_buffer_length   = GetBufferLength(underlyingStreamReader);
            var stream_buffer_pos      = GetBufferPosition(underlyingStreamReader);
            var stream_preamble_length = GetPreambleLength(underlyingStreamReader);

            // get the xml reader's buffer state
            var xml_buffer_length = GetBufferLength(xmlReader);
            var xml_buffer_pos    = GetBufferPosition(xmlReader);

            // subtract the lengths of the buffers which the stream/xml readers cached
            // then add the 'cursor' positions the readers have in those buffers
            // plus the text encoding preamble length
            long pos = stream_position
                       - (stream_buffer_length == kStreamReader_DefaultBufferSize ? kStreamReader_DefaultBufferSize : 0)
                       - xml_buffer_length
                       + xml_buffer_pos + stream_buffer_pos + stream_preamble_length;

            return(pos);
        }
Exemplo n.º 3
0
        private static void DisableUndeclaredEntityCheck(XmlReader xmlReader)
        {
            PropertyInfo propertyInfo = xmlReader.GetType().GetProperty(
                "DisableUndeclaredEntityCheck", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            propertyInfo.SetValue(xmlReader, true);
        }
Exemplo n.º 4
0
        /// <summary>
        /// 读取配置文件中的 XML
        /// </summary>
        /// <param name="reader">在配置文件中进行读取操作的 <seealso cref="XmlReader"/></param>
        /// <param name="serializeCollectionKey">为 <c>true</c>,则只序列化集合的键属性;否则为 <c>false</c></param>
        protected override void DeserializeElement(XmlReader reader, bool serializeCollectionKey)
        {
            FieldInfo field = reader.GetType().GetField("_rawXml", TypeUtil.FieldBindingFlags);

            this.outerXml = (string)field.GetValue(reader);
            base.DeserializeElement(reader, serializeCollectionKey);
        }
Exemplo n.º 5
0
 /// <summary>
 /// This method initializes the XmlTextReader that will be used to
 /// deserialize the object.
 /// </summary>
 void initReader(XmlReader xmlReader)
 {
     if (typeof(XmlTextReader).IsAssignableFrom(xmlReader.GetType()))
     {
         XmlTextReader reader = xmlReader as XmlTextReader;
         reader.WhitespaceHandling = WhitespaceHandling.Significant;
         reader.Normalization      = true;
     }
 }
Exemplo n.º 6
0
        private static long GetXmlReaderBufferLength(XmlReader xr)
        {
            if (_xmlReaderBufferSizeProperty == null)
            {
                _xmlReaderBufferSizeProperty = xr.GetType()
                                                 .GetProperty("DtdParserProxy_ParsingBufferLength",
                                                              BindingFlags.Instance | BindingFlags.NonPublic);
            }

            return (int)_xmlReaderBufferSizeProperty.GetValue(xr);
        }
        private static int GetXmlReaderBufferPosition(XmlReader xr)
        {
            if (_xmlReaderBufferPositionProperty == null)
            {
                _xmlReaderBufferPositionProperty = xr.GetType()
                                                   .GetProperty("DtdParserProxy_CurrentPosition",
                                                                BindingFlags.Instance | BindingFlags.NonPublic);
            }

            return((int)_xmlReaderBufferPositionProperty.GetValue(xr));
        }
        private static long GetXmlReaderBufferLength(XmlReader xr)
        {
            if (_xmlReaderBufferSizeProperty == null)
            {
                _xmlReaderBufferSizeProperty = xr.GetType()
                                               .GetProperty("DtdParserProxy_ParsingBufferLength",
                                                            BindingFlags.Instance | BindingFlags.NonPublic);
            }

            return((int)_xmlReaderBufferSizeProperty.GetValue(xr));
        }
Exemplo n.º 9
0
 private static XmlReader PreventUndeclaredEntityException(XmlReader reader)
 {
     try {
         // Prevents Exception "Reference to undeclared entity 'question'"
         PropertyInfo propertyInfo = reader.GetType().GetProperty("DisableUndeclaredEntityCheck",
                                                                  BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
         propertyInfo.SetValue(reader, true, null);
     } catch (Exception exc) {
     }
     return(reader);
 }
Exemplo n.º 10
0
        private static int GetXmlReaderBufferPosition(XmlReader xr)
        {
            if (_xmlReaderBufferPositionProperty == null)
            {
                _xmlReaderBufferPositionProperty = xr.GetType()
                                                     .GetProperty("DtdParserProxy_CurrentPosition",
                                                                  BindingFlags.Instance | BindingFlags.NonPublic);
            }

            return (int)_xmlReaderBufferPositionProperty.GetValue(xr);
        }
Exemplo n.º 11
0
 public static void Run(XmlReader reader)
 {
     using (StreamWriter output = File.CreateText(Path.Combine(Program.TempPath, reader.GetType().Name + "-output.csv"))) {
         var properties = typeof(XmlReader).GetProperties(BindingFlags.Public | BindingFlags.Instance)
             .Where(p => p.GetIndexParameters().Length == 0 && !ignoredProperties.Contains(p.Name))
             .ToArray();
         output.WriteLine(CSV(properties.Select(p => p.Name)));
         do {
             output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
         } while (reader.Read());
         output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
     }
 }
Exemplo n.º 12
0
        public static IDictionary <string, string> GetNamespacesInScope(this XmlReader reader)
        {
            if (reader == null)
            {
                return(null);
            }
            var xmlResolver = reader as IXmlNamespaceResolver;

            if (xmlResolver != null)
            {
                return(xmlResolver.GetNamespacesInScope(XmlNamespaceScope.ExcludeXml));
            }
            var asmSysRuntimeSerialization = Assembly.Load("System.Runtime.Serialization, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
            var t          = asmSysRuntimeSerialization.GetType("System.Xml.XmlBaseReader");
            var readerType = reader.GetType();

            if (t.IsAssignableFrom(readerType))
            {
                var nsMgr      = ExposedObject.From(ExposedObject.From(reader).nsMgr);
                var namespaces = nsMgr.namespaces as object[];
                if (namespaces == null)
                {
                    return(null);
                }
                var dic = new Dictionary <string, string>();
                for (int i = nsMgr.nsCount - 1; i >= 0; i--)
                {
                    var ns = ExposedObject.From(namespaces[i]);
                    if (ns == null)
                    {
                        continue;
                    }
                    var prefix = ExposedObject.From(ns.Prefix);
                    if (prefix == null || prefix.IsEmpty || prefix.IsXml || prefix.IsXmlns)
                    {
                        continue;
                    }
                    var key = prefix.GetString() as string;
                    if (String.IsNullOrEmpty(key))
                    {
                        continue;
                    }
                    var    uri   = ExposedObject.From(ns.Uri);
                    string value = uri != null?uri.GetString() : null;

                    dic[key] = value ?? String.Empty;
                }
                return(dic);
            }
            return(null);
        }
Exemplo n.º 13
0
        internal XNodeReaderLineNumberService(XmlModelProvider xmlModelProvider, XmlReader xmlReader, Uri uri)
            : base(xmlModelProvider)
        {
            Debug.Assert(xmlReader != null, "xmlReader != null");
            Debug.Assert(uri != null, "uri != null");

            Debug.Assert(
                xmlReader.GetType().Name == "XNodeReader",
                "Unexpected type for XmlReader.  Expected reader to be System.Xml.Linq.XNodeReader");

            Debug.Assert(_sourceFieldInfo != null, "_sourceFieldInfo != null");
            Debug.Assert(_parentFieldInfo != null, "_parentFieldInfo != null");

            _xmlReader = xmlReader;
            _uri       = uri;
        }
Exemplo n.º 14
0
        private static XmlReader createSafeReader(Stream str)
        {
            XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();

            xmlReaderSettings.DtdProcessing = DtdProcessing.Ignore;
            XmlReader reader = XmlReader.Create(str, xmlReaderSettings);

            try {
                // Prevents Exception "Reference to undeclared entity 'question'"
                PropertyInfo propertyInfo = reader.GetType().GetProperty("DisableUndeclaredEntityCheck",
                                                                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                propertyInfo.SetValue(reader, true, null);
            } catch (Exception exc) {
            }
            return(reader);
        }
Exemplo n.º 15
0
        /// <exception cref="Javax.Xml.Parsers.ParserConfigurationException"/>
        /// <exception cref="System.IO.IOException"/>
        /// <exception cref="Org.Xml.Sax.SAXException"/>
        private void InitXfaForm(Stream inputStream)
        {
            XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();

            xmlReaderSettings.DtdProcessing = DtdProcessing.Ignore;
            XmlReader reader = XmlReader.Create(inputStream, xmlReaderSettings);

            try {
                // Prevents Exception "Reference to undeclared entity 'question'"
                PropertyInfo propertyInfo = reader.GetType().GetProperty("DisableUndeclaredEntityCheck",
                                                                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                propertyInfo.SetValue(reader, true, null);
            } catch (Exception exc) {
            }
            SetDomDocument(XDocument.Load(reader, LoadOptions.PreserveWhitespace));
            xfaPresent = true;
        }
        public static void AssertNode(
            string label,
            XmlReader xmlReader,
            XmlNodeType nodeType,
            int depth,
            bool isEmptyElement,
            string name,
            string prefix,
            string localName,
            string namespaceURI,
            string value,
            bool hasValue,
            int attributeCount,
            bool hasAttributes)
        {
            label = String.Concat(label, "(", xmlReader.GetType().Name, ")");
            Assert.AreEqual(nodeType, xmlReader.NodeType, label + ".NodeType");
            Assert.AreEqual(isEmptyElement, xmlReader.IsEmptyElement,
                            label + ".IsEmptyElement");

            Assert.AreEqual(name, xmlReader.Name, label + ".Name");

            Assert.AreEqual(prefix, xmlReader.Prefix, label + ".Prefix");

            Assert.AreEqual(localName, xmlReader.LocalName, label + ".LocalName");

            Assert.AreEqual(namespaceURI, xmlReader.NamespaceURI, label + ".NamespaceURI");

            Assert.AreEqual(depth, xmlReader.Depth, label + ".Depth");

            Assert.AreEqual(hasValue, xmlReader.HasValue, label + ".HasValue");

            Assert.AreEqual(value, xmlReader.Value, label + ".Value");

            Assert.AreEqual(hasAttributes, xmlReader.HasAttributes,
                            label + "HasAttributes");

            Assert.AreEqual(attributeCount, xmlReader.AttributeCount,
                            label + ".AttributeCount");
        }
Exemplo n.º 17
0
		public static void Run(XmlReader reader, bool includeAttributes, bool includeAttributeValues = true)
		{
			using (StreamWriter output = File.CreateText(Path.Combine(Program.TempPath, reader.GetType().Name + "-output.csv"))) {
				var properties = typeof(XmlReader).GetProperties(BindingFlags.Public | BindingFlags.Instance)
					.Where(p => p.GetIndexParameters().Length == 0 && !ignoredProperties.Contains(p.Name))
					.ToArray();
				output.WriteLine(CSV(properties.Select(p => p.Name)));
				do {
					output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
					if (includeAttributes && reader.HasAttributes) {
						for (int i = 0; i < reader.AttributeCount; i++) {
							reader.MoveToAttribute(i);
							output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
							if (includeAttributeValues) {
								reader.ReadAttributeValue();
								output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
							}
						}
					}
				} while (reader.Read());
				output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
			}
		}
Exemplo n.º 18
0
        /// <summary>Replaces the XFA data under datasets/data.</summary>
        /// <remarks>
        /// Replaces the XFA data under datasets/data. Accepts an
        /// <see cref="System.IO.Stream"/>
        /// to fill this object with XFA data.
        /// </remarks>
        /// <param name="is">
        /// the
        /// <see cref="System.IO.Stream"/>
        /// </param>
        /// <param name="readOnly">whether or not the resulting DOM document may be modified</param>
        /// <exception cref="System.IO.IOException">
        /// on IO error on the
        /// <see cref="Org.Xml.Sax.InputSource"/>
        /// </exception>
        public virtual void FillXfaForm(Stream @is, bool readOnly)
        {
            XmlReaderSettings settings = new XmlReaderSettings {
                NameTable = new NameTable()
            };
            XmlNamespaceManager xmlns = new XmlNamespaceManager(settings.NameTable);

            xmlns.AddNamespace("xfa", "http://www.xfa.org/schema/xci/1.0/");
            XmlReaderSettings readerSettings = new XmlReaderSettings();

            readerSettings.DtdProcessing = DtdProcessing.Ignore;
            XmlReader reader = XmlReader.Create(@is, readerSettings, new XmlParserContext(null, xmlns, "", XmlSpace.Default));

            try {
                // Prevents Exception "Reference to undeclared entity 'question'"
                PropertyInfo propertyInfo = reader.GetType().GetProperty("DisableUndeclaredEntityCheck",
                                                                         BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                propertyInfo.SetValue(reader, true, null);
            } catch (Exception exc) {
            }

            FillXfaForm(reader, readOnly);
        }
Exemplo n.º 19
0
        private IEnumerable <XmlReader> ReadNotes(string fileName)
        {
            XmlReaderSettings readerSettings = new XmlReaderSettings()
            {
                DtdProcessing    = DtdProcessing.Ignore,
                IgnoreWhitespace = true,
            };

            using (XmlReader reader = XmlReader.Create(fileName, readerSettings))
            {
                PropertyInfo propertyInfo = reader.GetType().GetProperty("DisableUndeclaredEntityCheck", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                propertyInfo.SetValue(reader, true);
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        while (reader.NodeType == XmlNodeType.Element && reader.Name == "note")
                        {
                            yield return(reader);
                        }
                    }
                }
            }
        }
Exemplo n.º 20
0
        private static XmlReader GetXmlReader(string file, StreamReader input, bool loadAsReadOnly, out Encoding encoding)
        {
            string uri = new UriBuilder(Uri.UriSchemeFile, string.Empty)
            {
                Path = file
            }.ToString();

            XmlReader reader = null;

            if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave16_10) && loadAsReadOnly && !_disableReadOnlyLoad)
            {
                // Create an XML reader with IgnoreComments and IgnoreWhitespace set if we know that we won't be asked
                // to write the DOM back to a file. This is a performance optimization.
                XmlReaderSettings settings = new XmlReaderSettings
                {
                    DtdProcessing    = DtdProcessing.Ignore,
                    IgnoreComments   = true,
                    IgnoreWhitespace = true,
                };
                reader = XmlReader.Create(input, settings, uri);

                // Try to set Normalization to false. We do this to remain compatible with earlier versions of MSBuild
                // where we constructed the reader with 'new XmlTextReader()' which has normalization enabled by default.
                PropertyInfo normalizationPropertyInfo = GetNormalizationPropertyInfo(reader.GetType());
                if (normalizationPropertyInfo != null)
                {
                    normalizationPropertyInfo.SetValue(reader, false);
                }
                else
                {
                    // Fall back to using XmlTextReader if the prop could not be bound.
                    Debug.Fail("Could not set Normalization to false on the result of XmlReader.Create");
                    _disableReadOnlyLoad = true;

                    reader.Dispose();
                    reader = null;
                }
            }

            if (reader == null)
            {
                reader = new XmlTextReader(uri, input)
                {
                    DtdProcessing = DtdProcessing.Ignore
                };
            }

            reader.Read();
            encoding = input.CurrentEncoding;

            return(reader);
        }
Exemplo n.º 21
0
		private void AssertNodeValues (
			string label,
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			bool hasValue,
			int attributeCount,
			bool hasAttributes)
		{
			label = String.Concat (label, "(", xmlReader.GetType ().Name, ")");
			Assert.AreEqual (nodeType, xmlReader.NodeType, label + ": NodeType");
			Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, label + ": IsEmptyElement");

			Assert.AreEqual (name, xmlReader.Name, label + ": name");

			Assert.AreEqual (prefix, xmlReader.Prefix, label + ": prefix");

			Assert.AreEqual (localName, xmlReader.LocalName, label + ": localName");

			Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, label + ": namespaceURI");

			Assert.AreEqual (depth, xmlReader.Depth, label + ": Depth");

			Assert.AreEqual (hasValue, xmlReader.HasValue, label + ": hasValue");

			Assert.AreEqual (value, xmlReader.Value, label + ": Value");

			Assert.AreEqual (hasAttributes, xmlReader.HasAttributes, label + ": hasAttributes");

			Assert.AreEqual (attributeCount, xmlReader.AttributeCount, label + ": attributeCount");
		}
		private void AssertNodeValues (
			string label,
			XmlReader xmlReader,
			XmlNodeType nodeType,
			int depth,
			bool isEmptyElement,
			string name,
			string prefix,
			string localName,
			string namespaceURI,
			string value,
			bool hasValue,
			int attributeCount,
			bool hasAttributes)
		{
			label = String.Concat (label, "(", xmlReader.GetType ().Name, ")");
			AssertEquals (label + ": NodeType", nodeType, xmlReader.NodeType);
			AssertEquals (label + ": IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);

			AssertEquals (label + ": name", name, xmlReader.Name);

			AssertEquals (label + ": prefix", prefix, xmlReader.Prefix);

			AssertEquals (label + ": localName", localName, xmlReader.LocalName);

			AssertEquals (label + ": namespaceURI", namespaceURI, xmlReader.NamespaceURI);

			AssertEquals (label + ": Depth", depth, xmlReader.Depth);

			AssertEquals (label + ": hasValue", hasValue, xmlReader.HasValue);

			AssertEquals (label + ": Value", value, xmlReader.Value);

			AssertEquals (label + ": hasAttributes", hasAttributes, xmlReader.HasAttributes);

			AssertEquals (label + ": attributeCount", attributeCount, xmlReader.AttributeCount);
		}
Exemplo n.º 23
0
 public static void Run(XmlReader reader, bool includeAttributes, bool includeAttributeValues = true)
 {
     using (StreamWriter output = File.CreateText(Path.Combine(Program.TempPath, reader.GetType().Name + "-output.csv"))) {
         var properties = typeof(XmlReader).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                          .Where(p => p.GetIndexParameters().Length == 0 && !ignoredProperties.Contains(p.Name))
                          .ToArray();
         output.WriteLine(CSV(properties.Select(p => p.Name)));
         do
         {
             output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
             if (includeAttributes && reader.HasAttributes)
             {
                 for (int i = 0; i < reader.AttributeCount; i++)
                 {
                     reader.MoveToAttribute(i);
                     output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
                     if (includeAttributeValues)
                     {
                         reader.ReadAttributeValue();
                         output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
                     }
                 }
             }
         } while (reader.Read());
         output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
     }
 }
Exemplo n.º 24
0
 public static void Run(XmlReader reader)
 {
     using (StreamWriter output = File.CreateText(Path.Combine(Program.TempPath, reader.GetType().Name + "-output.csv"))) {
         var properties = typeof(XmlReader).GetProperties(BindingFlags.Public | BindingFlags.Instance)
                          .Where(p => p.GetIndexParameters().Length == 0 && !ignoredProperties.Contains(p.Name))
                          .ToArray();
         output.WriteLine(CSV(properties.Select(p => p.Name)));
         do
         {
             output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
         } while (reader.Read());
         output.WriteLine(CSV(properties.Select(p => ToString(p.GetValue(reader, null)))));
     }
 }