C# XmlTextReader.ReadEndElement方法代码示例

        public static AAInventoryItemBase Deserialize(string serialization)
        {
            AAInventoryItemBase item = new AAInventoryItemBase();

            StringReader sr = new StringReader(serialization);
            XmlTextReader xtr = new XmlTextReader(sr);

            xtr.ReadStartElement("InventoryItem");

            item.Name = xtr.ReadElementString("Name");
            item.ID = UUID.Parse(xtr.ReadElementString("ID"));
            item.InvType = Convert.ToInt32(xtr.ReadElementString("InvType"));
            item.CreatorId = xtr.ReadElementString("CreatorUUID");
            item.CreationDate = Convert.ToInt32(xtr.ReadElementString("CreationDate"));
            item.Owner = UUID.Parse(xtr.ReadElementString("Owner"));
            item.Description = xtr.ReadElementString("Description");
            item.AssetType = Convert.ToInt32(xtr.ReadElementString("AssetType"));
            item.AssetID = UUID.Parse(xtr.ReadElementString("AssetID"));
            item.SaleType = Convert.ToByte(xtr.ReadElementString("SaleType"));
            item.SalePrice = Convert.ToInt32(xtr.ReadElementString("SalePrice"));
            item.BasePermissions = Convert.ToUInt32(xtr.ReadElementString("BasePermissions"));
            item.CurrentPermissions = Convert.ToUInt32(xtr.ReadElementString("CurrentPermissions"));
            item.EveryOnePermissions = Convert.ToUInt32(xtr.ReadElementString("EveryOnePermissions"));
            item.NextPermissions = Convert.ToUInt32(xtr.ReadElementString("NextPermissions"));
            item.Flags = Convert.ToUInt32(xtr.ReadElementString("Flags"));
            item.GroupID = UUID.Parse(xtr.ReadElementString("GroupID"));
            item.GroupOwned = Convert.ToBoolean(xtr.ReadElementString("GroupOwned"));

            xtr.ReadEndElement();

            xtr.Close();
            sr.Close();

            return item;
        }

        public void LoadPIDSetting_FromXmlTextReader(ref XmlTextReader xml_reader)
        {
            this.cycle_time_in_seconds = Double.Parse(xml_reader.ReadElementString("cycle_time_in_seconds"));

            xml_reader.ReadStartElement("outer_zone");
            this.proportional_band_EachZone[0] = Double.Parse(xml_reader.ReadElementString("proportional_band"));
            this.offset_EachZone[0] = Double.Parse(xml_reader.ReadElementString("offset"));
            this.reset_EachZone[0] = Double.Parse(xml_reader.ReadElementString("reset"));
            this.rate_EachZone[0] = Double.Parse(xml_reader.ReadElementString("rate"));
            xml_reader.ReadEndElement();

            xml_reader.ReadStartElement("sample_zone");
            this.proportional_band_EachZone[1] = Double.Parse(xml_reader.ReadElementString("proportional_band"));
            this.offset_EachZone[1] = Double.Parse(xml_reader.ReadElementString("offset"));
            this.reset_EachZone[1] = Double.Parse(xml_reader.ReadElementString("reset"));
            this.rate_EachZone[1] = Double.Parse(xml_reader.ReadElementString("rate"));
            xml_reader.ReadEndElement();

            xml_reader.ReadStartElement("inner_zone");
            this.proportional_band_EachZone[2] = Double.Parse(xml_reader.ReadElementString("proportional_band"));
            this.offset_EachZone[2] = Double.Parse(xml_reader.ReadElementString("offset"));
            this.reset_EachZone[2] = Double.Parse(xml_reader.ReadElementString("reset"));
            this.rate_EachZone[2] = Double.Parse(xml_reader.ReadElementString("rate"));
            xml_reader.ReadEndElement();
        }

 public new void Load(XmlTextReader reader)
 {
     reader.ReadStartElement("Placeable");
     _canEnter = (reader.GetAttribute("canEnter", "").Trim() == "1");
     _doesWarp = (reader.GetAttribute("doesWarp", "").Trim() == "1");
     _name = reader.GetAttribute("name", "").Trim();
     base.Load(reader);
     reader.ReadEndElement();
 }

        public static CharacterInformation Read(XmlTextReader reader)
        {
            reader.ReadStartElement ("Class");
            string name = reader.ReadElementString ("Name");
            reader.ReadEndElement();

            return new CharacterInformation
            {
                Class = name
            };
        }

        public static DatabaseConfiguration Read(string file)
        {
            DatabaseConfiguration config = new DatabaseConfiguration ();

            StreamReader s = new StreamReader (file);
            using (s) {
                XmlTextReader tr = new XmlTextReader (s);
                tr.MoveToContent ();
                if (tr.IsEmptyElement)
                    return config;

                tr.ReadStartElement ("Configuration");
                tr.MoveToContent ();

                while (tr.NodeType != XmlNodeType.EndElement) {

                    if (tr.NodeType != XmlNodeType.Element || tr.IsEmptyElement) {
                        tr.Skip ();
                    }
                    else if (tr.LocalName == "DisabledAddins") {
                        // For back compatibility
                        tr.ReadStartElement ();
                        tr.MoveToContent ();
                        while (tr.NodeType != XmlNodeType.EndElement) {
                            if (tr.NodeType == XmlNodeType.Element && tr.LocalName == "Addin")
                                config.addinStatus [tr.ReadElementString ()] = null;
                            else
                                tr.Skip ();
                            tr.MoveToContent ();
                        }
                        tr.ReadEndElement ();
                    }
                    else if (tr.LocalName == "AddinStatus") {
                        tr.ReadStartElement ();
                        tr.MoveToContent ();
                        while (tr.NodeType != XmlNodeType.EndElement) {
                            if (tr.NodeType == XmlNodeType.Element && tr.LocalName == "Addin") {
                                string aid = tr.GetAttribute ("id");
                                string senabled = tr.GetAttribute ("enabled");
                                if (senabled.Length == 0 || senabled == "True")
                                    config.addinStatus [aid] = config;
                                else
                                    config.addinStatus [aid] = null;
                            }
                            tr.Skip ();
                            tr.MoveToContent ();
                        }
                        tr.ReadEndElement ();
                    }
                    tr.MoveToContent ();
                }
            }
            return config;
        }

        public void Deserialize(string str)
        {
            using (TextReader textReader = new StringReader(str))
            using (XmlReader xmlReader = new XmlTextReader(textReader))
            {
                xmlReader.ReadStartElement();

                xmlReader.ReadStartElement();
                this.Id = new Guid(xmlReader.ReadContentAsString());
                xmlReader.ReadEndElement();

                xmlReader.ReadStartElement();
                this.Value1 = xmlReader.ReadContentAsInt();
                xmlReader.ReadEndElement();

                xmlReader.ReadStartElement();
                this.Value2 = xmlReader.ReadContentAsDateTime();
                xmlReader.ReadEndElement();

                xmlReader.ReadStartElement();
                this.Value3 = xmlReader.ReadContentAsString();
                xmlReader.ReadEndElement();

                xmlReader.ReadStartElement();
                this.Value4 = xmlReader.ReadContentAsDecimal();
                xmlReader.ReadEndElement();

                xmlReader.ReadEndElement();
            }
        }

        public static NamingRules LoadRules(string xmlPath)
        {
            NamingRules namingRules = new NamingRules();
            namingRules.rules = new List<NamingRule>();

            using (XmlReader reader = new XmlTextReader(xmlPath))
            {
                reader.ReadStartElement("Rules");
                reader.ReadStartElement("GeneralSettings");
                
                reader.ReadStartElement("FilenameRegex");
                namingRules.filenameRegex = reader.ReadString();
                reader.ReadEndElement();
                
                reader.ReadStartElement("ContextDepth");
                namingRules.contextDepth = reader.ReadContentAsInt();
                if (namingRules.ContextDepth < 1 || namingRules.ContextDepth > 4)
                    throw new FormatException("Context Depth must be between 1 and 4");
                reader.ReadEndElement();
                
                reader.ReadStartElement("ContextSeparator");
                namingRules.contextSeparator = reader.ReadString();
                reader.ReadEndElement();
                
                reader.ReadEndElement();
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.EndElement)
                    {
                        System.Diagnostics.Debug.Assert(reader.Name == "Rules");
                        break;
                    }
                    //if (reader.IsStartElement())
                    //    System.Diagnostics.Debug.Assert(reader.Name == "Rule");
                    reader.ReadStartElement("Rule");
                    //reader.Read();

                    reader.ReadStartElement("SearchString");
                    string regex = reader.ReadString();
                    reader.ReadEndElement();
                    reader.ReadStartElement("Replacement");
                    string replacement = reader.ReadString();
                    reader.ReadEndElement();
                    reader.ReadEndElement();
                    namingRules.rules.Add(new NamingRule(regex, replacement));
                }
                reader.ReadEndElement();
            }
            return namingRules;
        }

 public static SensorData ReadSensorData(string soap) {
      SensorData sd;
      XmlTextReader xmread;
      sd = null;
      try {
           sd = new SensorData();
           using (System.IO.StringReader read = new System.IO.StringReader(soap)) {
                xmread = new XmlTextReader(read);
                xmread.ReadStartElement("SensorDataContainer");
                xmread.ReadStartElement("Sensor");
                xmread.ReadStartElement("HasMotion");
                sd.HasMotion = bool.Parse(xmread.ReadString());
                xmread.ReadEndElement();
                xmread.ReadStartElement("NodeId");
                sd.NodeId = int.Parse(xmread.ReadString());
                xmread.ReadEndElement();
                xmread.ReadStartElement("PowerLevel");
                sd.PowerLevel = int.Parse(xmread.ReadString());
                xmread.ReadEndElement();
                xmread.ReadStartElement("TimeStamp");
                sd.TimeStamp = DateTime.Parse(xmread.ReadString());
                xmread.ReadEndElement();
                xmread.ReadEndElement();
                xmread.ReadEndElement();
           }
      } catch (Exception) {
           throw;
      }
      return (sd);
 }

        /// <summary> 
        /// Decodes a function call from Flash. 
        /// </summary> 
        /// <param name="xml">The XML string representing the function call.</param> 
        /// <returns>An ExternalInterfaceCall object representing the function call.</returns> 
        public static ExternalInterfaceCall DecodeInvoke(string xml)
        {
            XmlTextReader reader = new XmlTextReader(xml, XmlNodeType.Document, null);

            reader.Read();

            string functionName = reader.GetAttribute("name");
            ExternalInterfaceCall result = new ExternalInterfaceCall(functionName);

            reader.ReadStartElement("invoke");
            reader.ReadStartElement("arguments");

            while (reader.NodeType != XmlNodeType.EndElement && reader.Name != "arguments")
            {
                result.AddArgument(ReadElement(reader));
            }

            reader.ReadEndElement();
            reader.ReadEndElement();

            return result;
        }

        //Copy code from SceneObjectSerializer.ProcessColor
        public static System.Drawing.Color DeSerializeColor(string colorString)
        {
            StringReader sr = new StringReader(colorString);
            XmlTextReader reader = new XmlTextReader(sr);

            System.Drawing.Color color = new System.Drawing.Color();

            reader.ReadStartElement("Color");
            if (reader.Name == "R")
            {
                float r = reader.ReadElementContentAsFloat("R", String.Empty);
                float g = reader.ReadElementContentAsFloat("G", String.Empty);
                float b = reader.ReadElementContentAsFloat("B", String.Empty);
                float a = reader.ReadElementContentAsFloat("A", String.Empty);
                color = System.Drawing.Color.FromArgb((int)a, (int)r, (int)g, (int)b);
                reader.ReadEndElement();
            }
            return color;
        }

        public static ArcanaPlayer ReadCharacter(XmlTextReader reader)
        {
            reader.ReadStartElement ("Character");

            int id = Convert.ToInt32 (reader.ReadElementString ("CharacterID"));
            string name = reader.ReadElementString ("Name");
            string pclass = reader.ReadElementString ("Class");
            int level = Convert.ToInt32 (reader.ReadElementString ("Level"));

            reader.ReadEndElement ();

            ArcanaPlayer p = classConstructors[pclass] ();
            {
                p.CharacterID = id;
                p.Name = name;
                p.Class = pclass;
                p.Level = level;
            }
            return p;
        }

 public static void Load()
 {
     using (FileStream strm = new FileStream(FileName, FileMode.Open))
     {
         Pairs.Clear();
         using (XmlReader reader = new XmlTextReader(strm))
         {
             reader.ReadStartElement("SimpleConfig");
             while (reader.Name == "parameter")
             {
                 string key = reader.GetAttribute("name");
                 string value = reader.GetAttribute("value");
                 Pairs[key] = value;
                 reader.Read();
             }
             reader.ReadEndElement();
             reader.Close();
         }
             
         strm.Close();
     }
 }

        public void Load()
        {
            ReadWriteTestStructure ();

            // Load class templates
            string classTemplateRoot = Path.Combine (Environment.CurrentDirectory, "Content//classes.xml");

            using (XmlTextReader treader = new XmlTextReader (classTemplateRoot))
            {
                treader.ReadStartElement ("Classes");

                while (treader.Read () && treader.NodeType != XmlNodeType.EndElement)
                {
                    CharacterInformation template = ClassTemplateSerializer.Read (treader);
                    template.Texture = Moxy.ContentManager.Load<Texture2D> ("Interface//cf_" + template.Class.ToLower());
                    Classes.Add (template);
                }

                treader.ReadEndElement();
            }

            // Load all characters
            foreach (string file in Directory.EnumerateFiles (Path.Combine(Environment.CurrentDirectory, "saves")))
            {
                using (XmlTextReader reader = new XmlTextReader (file))
                {
                    reader.MoveToElement();

                    while (reader.Read())
                    {
                        ArcanaPlayer player = CharacterSerializer.ReadCharacter (reader);
                        Characters.Add (new CharacterInformation (player));
                        characters.Add (player.CharacterID, player);
                    }
                }
            }
        }

 private static void ProcessColor(SceneObjectPart obj, XmlTextReader reader)
 {
     reader.ReadStartElement("Color");
     if (reader.Name == "R")
     {
         float r = reader.ReadElementContentAsFloat("R", String.Empty);
         float g = reader.ReadElementContentAsFloat("G", String.Empty);
         float b = reader.ReadElementContentAsFloat("B", String.Empty);
         float a = reader.ReadElementContentAsFloat("A", String.Empty);
         obj.Color = Color.FromArgb((int)a, (int)r, (int)g, (int)b);
         reader.ReadEndElement();
     }
 }

        /// <summary>
        /// Read a shape from xml input
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="name">The name of the xml element containing the shape</param>
        /// <param name="errors">a list containing the failing node names.  If no failures then null.</param>
        /// <returns>The shape parsed</returns>
        public static PrimitiveBaseShape ReadShape(XmlTextReader reader, string name, out List<string> errorNodeNames)
        {
            List<string> internalErrorNodeNames = null;

            PrimitiveBaseShape shape = new PrimitiveBaseShape();

            if (reader.IsEmptyElement)
            {
                reader.Read();
                errorNodeNames = null;
                return shape;
            }

            reader.ReadStartElement(name, String.Empty); // Shape

            ExternalRepresentationUtils.ExecuteReadProcessors(
                shape,
                m_ShapeXmlProcessors,
                reader,
                (o, nodeName, e)
                    =>
                    {
//                        m_log.DebugFormat(
//                            "[SceneObjectSerializer]: Exception while parsing Shape property {0}: {1}{2}",
//                            nodeName, e.Message, e.StackTrace);
                        if (internalErrorNodeNames == null)
                            internalErrorNodeNames = new List<string>();

                        internalErrorNodeNames.Add(nodeName);
                    }
            );

            reader.ReadEndElement(); // Shape

            errorNodeNames = internalErrorNodeNames;

            return shape;
        }