C# XmlTextReader.Read方法代码示例

        public static IncomingTransportMessage Deserialize(string messageId, Stream inputStream)
        {
            var headers = new Dictionary<string, string>();
            var serializedMessageData = "";
            using (var reader = new XmlTextReader(inputStream))
            {
                reader.WhitespaceHandling = WhitespaceHandling.None;
                reader.Read(); // read <root>
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        var elementName = reader.Name;
                        reader.Read(); // read the child;
                        while (reader.NodeType == XmlNodeType.Element)
                        {
                            // likely an empty header element node
                            headers.Add(elementName, reader.Value);

                            elementName = reader.Name;
                            reader.Read(); // read the child;
                        }
                        if (string.Equals(elementName, "body", StringComparison.InvariantCultureIgnoreCase) && reader.NodeType == XmlNodeType.CDATA)
                        {
                            serializedMessageData = reader.Value;
                        }
                        else if (reader.NodeType == XmlNodeType.Text)
                        {
                            headers.Add(elementName, reader.Value);
                        }
                    }
                }
            }
            return new IncomingTransportMessage(messageId, headers, serializedMessageData);
        }

        public static string[] GetWeather(string zipCode)
        {
            XmlTextReader textReader = new XmlTextReader("http://weather.yahooapis.com/forecastrss?p=" + zipCode + "&u=f");
            string City = "", State = "", Code = "", URL = "", Temperature = "", Condition = "";
            string High = "", Low = "";

            textReader.MoveToContent();
            string temp = textReader.Name;
            do
            {
                textReader.Read();
                temp = textReader.Name;
            }
            while (temp != "channel");

            while (temp == "channel")
            {
                textReader.Read();

                if (textReader.Name == "yweather:location")
                {
                    City = textReader.GetAttribute("city");
                    State = textReader.GetAttribute("region");
                }
                else if (textReader.Name == "item")
                {
                    do
                    {
                        textReader.Read();
                        if (textReader.Name == "yweather:condition")
                        {
                            Condition = textReader.GetAttribute("text");
                            Temperature = textReader.GetAttribute("temp");
                            Code = textReader.GetAttribute("code");
                        }
                        else if (textReader.Name == "yweather:forecast")
                        {
                            if (Convert.ToInt32(textReader.GetAttribute("date").Substring(0, 2)) == System.DateTime.Now.Day)
                            {
                                High = textReader.GetAttribute("high");
                                Low = textReader.GetAttribute("low");
                            }
                        }
                    }
                    while (textReader.Name != "item");
                    temp = "";
                }
            }
            textReader.Close();
            URL = "http://us.i1.yimg.com/us.yimg.com/i/us/we/52/" + Code + ".gif";
            string[] value = new string[7];
            value[0] = City;
            value[1] = State;
            value[2] = Temperature;
            value[3] = Condition;
            value[4] = Code;
            value[5] = High;
            value[6] = Low;
            return value;
        }

        /// <summary>
        /// Constructs the Arcs using Xml
        /// </summary>
        /// <param name="vsXml">Xml data</param>
        public Arcs(string vsXml)
        {
            XmlTextReader reader = new XmlTextReader(new StringReader(vsXml));
            reader.Read();

            ArcType = (EnumArcType)Enum.Parse(typeof(EnumArcType), reader.GetAttribute("arctype"));

            moArcList = new List<Arc>();

            while (reader.Read())
            {
                switch (reader.Name)
                {
                    case "Arcs" :
                        if (reader.NodeType != XmlNodeType.EndElement)
                        {
                            if (moInnerArcs == null)
                            {
                                moInnerArcs = new List<Arcs>();
                            }
                            moInnerArcs.Add(new Arcs(reader.ReadOuterXml()));
                        }
                        break;
                    case "Arc" :
                        moArcList.Add(new Arc(reader.ReadOuterXml()));
                        break;
                }
            }
        }

        public static List<int> CheckStatusRowErrors(string errorInfo)
        {
            List<int> errorList = new List<int>();
            bool containsError = false;

            XmlTextReader xReader = new XmlTextReader(new System.IO.StringReader(errorInfo));
            while (xReader.Read())
            {
                if (xReader.Name == "errinfo" && xReader.NodeType == XmlNodeType.Element)
                {
                    xReader.Read();
                    if (xReader.Value != string.Empty)
                    {
                        containsError = true;
                    }
                }
                if (containsError && xReader.Name == "error" && xReader.NodeType == XmlNodeType.Element)
                {
                    while (xReader.Read())
                    {
                        if (xReader.Name == "id" && xReader.NodeType == XmlNodeType.Attribute)
                        {
                            errorList.Add(Convert.ToInt32(xReader.Value));
                        }
                    }
                }
            }
            return errorList;
        }

        ///// <summary>
        ///// Listener for data Binding
        ///// </summary>
        //private void ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
        //{
        //    uperBorder = (float)uper.Value;
        //}
        ///// <summary>
        ///// Sets the Slider of the Properties Views
        ///// </summary>
        //public void changeValue(double noise){
        //    uper.Value =noise;
        //    this.ValueChanged(this,null);
        //}
        ///// <summary>
        ///// Gets the Slider of the Properties Views
        ///// </summary>
        //public float getValue(){
        //    return uperBorder;
        //}
        /// <summary>
        /// Sets the Language Content and reads it from an XML File.
        /// </summary>
        public void local(String s)
        {
            try{
                String sFilename = Directory.GetCurrentDirectory() + "/" + s;
                XmlTextReader reader = new XmlTextReader(sFilename);
                reader.Read();
                reader.Read();
                String[] t = new String[1];
                String[] t2 = new String[1];

                    reader.Read();
                    reader.Read();
                    t[0] = reader.Name;
                    reader.MoveToNextAttribute();
                    t2[0] = reader.Value;
                    if (t2[0] == "")
                    {
                        throw new XmlException("datei nicht lang genug");
                    }

                label1.Content = t2[0];
               }
               catch (IndexOutOfRangeException) { }
               catch (FileNotFoundException) { }
               catch (XmlException) { }
        }

        public static void read(string strXMLPath)
        {
            XmlTextReader textReader = new XmlTextReader(strXMLPath);

            textReader.Read();

            // If the node has value

            while (textReader.Read())
            {

                textReader.MoveToElement(); // Move to 1st element
                if (textReader.NodeType.ToString() != "Whitespace" && textReader.NodeType.ToString() != "Element" && textReader.NodeType.ToString() != "EndElement")
                {
                    Console.WriteLine("════════════════════════════════");

             //   Console.WriteLine("Name:" + textReader.Name);
             //   Console.WriteLine("Base URI:" + textReader.BaseURI);
             //   Console.WriteLine("Local Name:" + textReader.LocalName);
             //   Console.WriteLine("Attribute Count:" + textReader.AttributeCount.ToString());
             //   Console.WriteLine("Depth:" + textReader.Depth.ToString());
             //   Console.WriteLine("Line Number:" + textReader.LineNumber.ToString());
             //   Console.WriteLine("Node Type:" + textReader.NodeType.ToString());

                    Console.WriteLine(textReader.Value.ToString());
             }

            }
            Console.Read();
        }

        /// <summary>
        ///   Parser recursiv de elemente XML.
        /// </summary>
        /// <param name="reader">Cititorul secvenţial care a deschis fişierul XML</param>
        /// <returns>Elementul XML parsat care conţine toate atributele şi subelementele sale</returns>
        private static XMLElement readCurrentElement(XmlTextReader reader)
        {
            if (!reader.IsStartElement()) {

                return null;
            }

            bool hasChildren = !reader.IsEmptyElement;

            XMLElement result = new XMLElement();

            for (int i = 0; i < reader.AttributeCount; ++i) {

                reader.MoveToAttribute(i);
                result.addAttribute(reader.Name, reader.Value);
            }

            if (hasChildren) {

                while (reader.Read() && reader.NodeType != XmlNodeType.EndElement) {

                    if (reader.IsStartElement()) {

                        result.addElement(reader.Name, readCurrentElement(reader));
                    }
                }
            }

            reader.Read();

            return result;
        }

        public bool exists(string server, string db)
        {
            bool rez = false;
            XmlTextReader reader = new XmlTextReader(dbConf);
            try
            {
                while (reader.Read())
                {
                    if (reader.Value == server)
                    {
                        reader.Read();
                        while (reader.Read() && reader.Name != srvTag)
                        {
                            if (reader.Value == db)
                            {
                                rez = true;
                            }
                        }
                    }
                }
                reader.Close();
            }
            catch (Exception e)
            {

            }

            return rez;
        }

        /// <summary>
        /// Generates the function list...
        /// </summary>
        /// <returns></returns>
        public static String GenerateFunctionList( bool bIsHeader )
        {
            // EXAMPLE of what we want to generate...
            // bSuccess *= printFunctionResult( My_HeapValidate( ), "HeapValidate" );

            String functionListResults = null;

            XmlTextReader xr = new XmlTextReader( functionXMLFile );

            while ( xr.Read( ) )
            {
                // Find out what type of node we are looking at. The XR reader will read one
                // XML element/value at a time (NOT one line at time)...
                if ( xr.NodeType == XmlNodeType.Element )
                {
                    if ( xr.Name == "FunctionName" )
                    {
                        if ( !xr.Read( ) )
                            break;

                        Console.WriteLine( "Writing Function: " + xr.Value );
                        if ( !bIsHeader )
                            functionListResults += "    bSuccess *= printFunctionResult( My_" + xr.Value + "( ), \"" + xr.Value + "\" );\r\n";
                        else
                            functionListResults += "    BOOL My_" + xr.Value + "( )" + ";\r\n";

                    }
                }
            }

            Exception e;
            xr.Close( );

            return functionListResults;
        }

        /// <summary> Reads the inner data from the Template XML format </summary>
        /// <param name="XMLReader"> Current template xml configuration reader </param>
        /// <remarks> This reads the possible values for the combo box from an <i>options</i> subelement.  The default value for the combo box is from a <i>code</i> subelement and the default value for the text box is from a <i>statement</i> subelement. </remarks>
        protected override void Inner_Read_Data(XmlTextReader XMLReader)
        {
            while (XMLReader.Read())
            {
                if ((XMLReader.NodeType == XmlNodeType.Element) && (XMLReader.Name.ToLower() == "options"))
                {
                    XMLReader.Read();
                    string options = XMLReader.Value.Trim();
                    possible_select_items.Clear();
                    if (options.Length > 0)
                    {
                        SortedList<string, string> sorted_codes = new SortedList<string, string>();
                        string[] options_parsed = options.Split(",".ToCharArray());
                        foreach (string thisOption in options_parsed.Where(thisOption => !sorted_codes.ContainsKey(thisOption.Trim())))
                        {
                            sorted_codes.Add(thisOption.Trim(), thisOption.Trim());
                        }

                        possible_select_items.AddRange(sorted_codes.Values);
                    }
                }

                if ((XMLReader.NodeType == XmlNodeType.Element) && (XMLReader.Name.ToLower() == "code"))
                {
                    XMLReader.Read();
                    default_codes.Add(XMLReader.Value.Trim());
                }

                if ((XMLReader.NodeType == XmlNodeType.Element) && (XMLReader.Name.ToLower() == "statement"))
                {
                    XMLReader.Read();
                    default_values.Add(XMLReader.Value.Trim());
                }
            }
        }

        public static Hashtable GetSettings()
        {
            Hashtable hash = new Hashtable();

            hash.Add("ip", DEFAULT_IP);
            hash.Add("port", DEFAULT_PORT);

            try
            {
                XmlTextReader xml = new XmlTextReader(CONFIG_FILE_NAME);
                while (xml.Read())
                {
                    switch (xml.NodeType)
                    {
                        case XmlNodeType.Element:
                            if (xml.Name.ToUpper() == "IP")
                                if (xml.Read() && xml.NodeType == XmlNodeType.Text)
                                    hash["ip"] = xml.Value;
                            if (xml.Name.ToUpper() == "PORT")
                                if (xml.Read() && xml.NodeType == XmlNodeType.Text)
                                    hash["port"] = xml.Value;
                            break;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Exception in Service: " + ex.Message);
                Console.WriteLine("Process started with default values.");
            }

            return hash;
        }

        public void getData(ref SortedDictionary<string,string> data, ref List<string> localizations)
        {
            XmlTextReader reader = new XmlTextReader (fileName);

            string currentLocal=GameConfig.Localization;
            string key;
            string value;

                reader.Read();

                while (reader.Read()) {

                    if (reader.Name.Equals(LOCALIZATION_NAME)) {
                        currentLocal = reader.GetAttribute(LOCALIZATION_ATTRIBUTE);

                        if (!localizations.Contains(currentLocal))
                            localizations.Add(currentLocal);

                    }

                    if(reader.Name.Equals(ITEM_NAME)){

                        key = reader.GetAttribute(ITEM_ATTRIBUTE);
                        value = reader.ReadElementString();

                        if (key!=null)
                            data.Add(currentLocal+key, value);

                    }
                }

            reader.Close();
            reader  = null;
        }

        private static Dictionary<string, string> GetResources(string content)
        {
            Dictionary<string, string> resources = new Dictionary<string, string>();

            StringReader _sr = new StringReader(content);
            XmlTextReader _xtr = new XmlTextReader(_sr);
            _xtr.XmlResolver = null;
            _xtr.WhitespaceHandling = WhitespaceHandling.None;
            _xtr.Read();

            if ((_xtr.NodeType == XmlNodeType.Element) && (_xtr.Name == "Language"))
            {
                while (_xtr.Read())
                {
                    if ((_xtr.NodeType == XmlNodeType.Element) && (_xtr.Name == "LocaleResource"))
                    {
                        string resourceName = _xtr["Name"];

                        _xtr.Read();
                        if ((_xtr.NodeType == XmlNodeType.Element) && (_xtr.Name == "Value"))
                        {
                            _xtr.Read();
                            if (_xtr.NodeType == XmlNodeType.Text)
                            {
                                string resourceValue = _xtr.Value;
                                resources.Add(resourceName, resourceValue);
                            }
                        }
                    }
                }
            }

            return resources;
        }

 static FileParser()
 {
     s_extensions.Add("");
     //s_extensions.Add(".lua");
     try
     {
         XmlTextReader reader = new XmlTextReader(AppDomain.CurrentDomain.BaseDirectory + "intelluaconfig.xml");
         while (reader.Read())
         {
             if (reader.NodeType == XmlNodeType.Element)
             {
                 if (reader.Name == "path")
                 {
                     reader.Read();
                     s_includePaths.Add(reader.Value);
                 }
                 else if (reader.Name == "ext")
                 {
                     reader.Read();
                     s_extensions.Add(reader.Value);
                 }
             }
         }
     }
     catch
     {
     }
 }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public static Decimal getItemPrice(String name)
        {
            XmlConfigurator.Configure(new FileInfo("config/log4net.properties"));
            Decimal result = new Decimal(-1);

            try
            {
                XmlTextReader reader = new XmlTextReader("config/prices.xml");

                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element && reader.Name == "entry" && reader.HasAttributes && reader.GetAttribute("key") == name)
                    {
                        dLog.Debug("Got " + reader.NodeType + " node | Name: " + reader.Name + " | HasAttributes: " + reader.HasAttributes);
                        // move one to read element value
                        reader.Read();
                        dLog.Debug("Node Value: " + reader.Value);
                        result = Decimal.Parse(reader.Value);
                        break;
                    }
                }
            }
            catch (Exception e)
            {
                dLog.Debug("Exception in getItemPrice: " + e.Message + "\n" + e.StackTrace);
                result = new Decimal(-1);
            }

            return result;
        }