C# XML序列化

如何序列化/反序列化以下内容

响应

<xml>
 <record type="user">
  <field name="userId" value="Id1"/>
  <field name="userName" value="Name1"/>
  <field name="userStreet" value="Street1"/>
  <field name="userCountry" value="Country1"/>
 </record>
 <record type="user">
  <field name="userId" value="Id2"/>
  <field name="userName" value="Name2"/>
  <field name="userStreet" value="Street2"/>
  <field name="userCountry" value="Country2"/>
 </record>
</xml>

---

我不知道从哪里开始，因为我还没有遇到过这样的响应结构。

试试这样的方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    class Program
    {
        const string FILENAME = @"C:\temp\test.xml";
        static void Main(string[] args)
        {
            Root root = new Root()
            {
                records = new List<Record>(){
                    new Record(){
                        type = "user",
                        fields = new List<Field>(){
                            new Field() { name= "userId",  value = "Id1"},
                            new Field() { name= "userName", value = "Name1"},
                            new Field() { name="userStreet", value = "Street1"},
                            new Field() { name="userCountry", value="Country1"}
                        }
                    },
                    new Record(){
                        type = "user",
                        fields = new List<Field>(){
                            new Field() { name = "userId", value="Id2"},
                            new Field() { name = "userName", value="Name2"},
                            new Field() { name= "userStreet", value="Street2"},
                            new Field() { name="userCountry", value="Country2"}
                        }
                    }
                }
            };


            XmlSerializer serializer = new XmlSerializer(typeof(Root));

            StreamWriter writer = new StreamWriter(FILENAME);
            XmlSerializerNamespaces _ns = new XmlSerializerNamespaces();
            _ns.Add("", "");
            serializer.Serialize(writer, root, _ns);
            writer.Flush();
            writer.Close();
            writer.Dispose();



            XmlSerializer xs = new XmlSerializer(typeof(Root));
            XmlTextReader reader = new XmlTextReader(FILENAME);
            Root  newRoot = (Root)xs.Deserialize(reader);

            List<User> users = new List<User>();
            foreach (Record record in newRoot.records.AsEnumerable())
            {
                User newUser = new User();
                users.Add(newUser);
                foreach (Field field in record.fields)
                {
                    switch (field.name)
                    {
                        case "userId" :
                            newUser.UserId = field.value;
                            break;
                        case "userName":
                            newUser.UserName  = field.value;
                            break;
                        case "userStreet":
                            newUser.UserStreet = field.value;
                            break;
                        case "userCountry":
                            newUser.UserCountry = field.value;
                            break;
                    }
                }
            }



        }
    }

    [XmlRoot("Root")]
    public class Root
    {
        [XmlElement("record")]
        public List<Record> records { get; set; } 
    }
    [XmlRoot("record")]
    public class Record
    {
        [XmlAttribute("type")]
        public string type { get; set; }
        [XmlElement("field")]
        public List<Field> fields { get; set; } 
    }

    [XmlRoot("field")]
    public class Field
    {
        [XmlAttribute("name")]
        public string name { get; set; }
        [XmlAttribute("value")]
        public string value { get; set; }
    }
    class User
    {
        public string UserId { get; set; }
        public string UserName { get; set; }
        public string UserStreet { get; set; }
        public string UserCountry { get; set; }
    }

}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.IO；
使用System.Xml；
使用System.Xml.Serialization；
命名空间控制台应用程序1
{
班级计划
{
常量字符串文件名=@“C:\temp\test.xml”；
静态void Main（字符串[]参数）
{
根根=新根（）
{
记录=新列表（）{
新纪录（）{
type=“用户”，
字段=新列表（）{
新字段（）{name=“userId”，value=“Id1”}，
新字段（）{name=“userName”，value=“Name1”}，
新字段（）{name=“userStreet”，value=“Street1”}，
新字段（）{name=“userCountry”，value=“Country1”}
}
},
新纪录（）{
type=“用户”，
字段=新列表（）{
新字段（）{name=“userId”，value=“Id2”}，
新字段（）{name=“userName”，value=“Name2”}，
新字段（）{name=“userStreet”，value=“Street2”}，
新字段（）{name=“userCountry”，value=“Country2”}
}
}
}
};
XmlSerializer serializer=新的XmlSerializer（typeof（Root））；
StreamWriter writer=新的StreamWriter（文件名）；
XmlSerializerNamespaces\u ns=新的XmlSerializerNamespaces（）；
_加上（“，”）；
serializer.Serialize（writer，root，\n）；
writer.Flush（）；
writer.Close（）；
writer.Dispose（）；
XmlSerializer xs=新的XmlSerializer（typeof（Root））；
XmlTextReader=新的XmlTextReader（文件名）；
Root newRoot=（Root）xs.反序列化（读卡器）；
列表用户=新列表（）；
foreach（newRoot.records.AsEnumerable（）中的记录记录）
{
User newUser=新用户（）；
users.Add（newUser）；
foreach（record.fields中的字段）
{
开关（字段名称）
{
案例“userId”：
newUser.UserId=field.value；
打破
案例“用户名”：
newUser.UserName=field.value；
打破
案例“userStreet”：
newUser.UserStreet=field.value；
打破
案例“用户国家”：
newUser.UserCountry=field.value；
打破
}
}
}
}
}
[XmlRoot（“根”）]
公共类根
{
[XmlElement（“记录”）]
公共列表记录{get；set；}
}
[XmlRoot（“记录”）]
公开课记录
{
[XmlAttribute（“类型”）]
公共字符串类型{get；set；}
[XmlElement（“字段”）]
公共列表字段{get；set；}
}
[XmlRoot（“字段”）]
公共类字段
{
[XmlAttribute（“名称”）]
公共字符串名称{get；set；}
[XmlAttribute（“值”）]
公共字符串值{get；set；}
}
类用户
{
公共字符串用户标识{get；set；}
公共字符串用户名{get；set；}
公共字符串UserStreet{get；set；}
公共字符串UserCountry{get；set；}
}
}

试试这样的方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Xml;
using System.Xml.Serialization;

namespace ConsoleApplication1
{
    class Program
    {
        const string FILENAME = @"C:\temp\test.xml";
        static void Main(string[] args)
        {
            Root root = new Root()
            {
                records = new List<Record>(){
                    new Record(){
                        type = "user",
                        fields = new List<Field>(){
                            new Field() { name= "userId",  value = "Id1"},
                            new Field() { name= "userName", value = "Name1"},
                            new Field() { name="userStreet", value = "Street1"},
                            new Field() { name="userCountry", value="Country1"}
                        }
                    },
                    new Record(){
                        type = "user",
                        fields = new List<Field>(){
                            new Field() { name = "userId", value="Id2"},
                            new Field() { name = "userName", value="Name2"},
                            new Field() { name= "userStreet", value="Street2"},
                            new Field() { name="userCountry", value="Country2"}
                        }
                    }
                }
            };


            XmlSerializer serializer = new XmlSerializer(typeof(Root));

            StreamWriter writer = new StreamWriter(FILENAME);
            XmlSerializerNamespaces _ns = new XmlSerializerNamespaces();
            _ns.Add("", "");
            serializer.Serialize(writer, root, _ns);
            writer.Flush();
            writer.Close();
            writer.Dispose();



            XmlSerializer xs = new XmlSerializer(typeof(Root));
            XmlTextReader reader = new XmlTextReader(FILENAME);
            Root  newRoot = (Root)xs.Deserialize(reader);

            List<User> users = new List<User>();
            foreach (Record record in newRoot.records.AsEnumerable())
            {
                User newUser = new User();
                users.Add(newUser);
                foreach (Field field in record.fields)
                {
                    switch (field.name)
                    {
                        case "userId" :
                            newUser.UserId = field.value;
                            break;
                        case "userName":
                            newUser.UserName  = field.value;
                            break;
                        case "userStreet":
                            newUser.UserStreet = field.value;
                            break;
                        case "userCountry":
                            newUser.UserCountry = field.value;
                            break;
                    }
                }
            }



        }
    }

    [XmlRoot("Root")]
    public class Root
    {
        [XmlElement("record")]
        public List<Record> records { get; set; } 
    }
    [XmlRoot("record")]
    public class Record
    {
        [XmlAttribute("type")]
        public string type { get; set; }
        [XmlElement("field")]
        public List<Field> fields { get; set; } 
    }

    [XmlRoot("field")]
    public class Field
    {
        [XmlAttribute("name")]
        public string name { get; set; }
        [XmlAttribute("value")]
        public string value { get; set; }
    }
    class User
    {
        public string UserId { get; set; }
        public string UserName { get; set; }
        public string UserStreet { get; set; }
        public string UserCountry { get; set; }
    }

}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.IO；
使用System.Xml；
使用System.Xml.Serialization；
命名空间控制台应用程序1
{
班级计划
{
常量字符串文件名=@“C:\temp\test.xml”；
静态void Main（字符串[]参数）
{
根根=新根（）
{
记录=新列表（）{
新纪录（）{
type=“用户”，
字段=新列表（）{
新字段（）{name=“userId”，value=“Id1”}，
新字段（）{name=“userName”，value=“Name1”}，
新字段（）{name=“userStreet”，value=“Street1”}，
新字段（）{name=“userCountry”，value=“Country1”}
}
},
新纪录（）{
type=“用户”，
字段=新列表（）{
新字段（）{name=“userId”，value=“Id2”}，
新字段（）{name=“userName”，value=“Name2”}，
新字段（）{name=“userStreet”，value=“Street2”}，
新字段（）{name=“userCountry”，value=“Country2”}
}
}
}
};
XmlSerializer serializer=新的XmlSerializer（typeof（Root））；
StreamWriter writer=新的StreamWriter（文件名）；
XmlSerializerNamespaces\u ns=新的XmlSerializerNamespaces（）；
_加上（“，”）；
serializer.Serialize（writer，root，\n）；
writer.Flush（）；
writer.Close（）；
writer.Dispose（）；
XmlSerializer xs=新的XmlSerializer（typeof（Root））；
XmlTextReader=新的XmlTextReader（文件名）；
Root newRoot=（Root）xs.反序列化（读卡器）；
列表用户=新列表（）；
foreach（newRoot.records.AsEnumerable（）中的记录记录）
<xml>
 <User>
  <UserName>
    Name1
  </UserName>
 </User>
</xml>

public static User get_user(IEnumerable<XElement> fields)
    {
        User u = new User();
        foreach (var item in fields)
        {
            String attribute = item.Attribute("name").Value;
            String val = item.Attribute("value").Value;
            if (attribute == "userName")
            {
                u.UserName = val;
            }
            else if (attribute == "userStreet")
            {
                u.UserStreet = val;
            }
            //and so on...
        }
        return u;
    }

//using System.Xml.Linq;
XDocument document =XDocument.Parse(string_response); //I'm assuming response is in string
List<User> users = (from xnode in document.Element("xml").Elements("record")
                            select get_user(xnode.Elements("field"))
                   ).ToList();