C# 如何从该xml反序列化集合？

****我在xml文件上序列化我的员工集合。当我尝试从该或另一个THES程序反序列化集合时，程序会引发异常： System.Xml.dll中类型为“System.InvalidOperationException”的未处理异常 有关更多信息：文档XML（2，2）存在错误。 XML文件：

`

奥格连科
19
.NET Sharepoint
哈尔科夫
贝洛斯
19
.NET Sharepoint
哈尔科夫
`

代码：

公共类员工
{
私有字符串名；
私有字符串LastName；
私人互联网；
私人弦乐部；
私有字符串地址；
私有字符串empoyeid；
#区域属性
公共字符串FirstNameP
{
获取{return FirstName；}
设置{FirstName=value；}
}
公共字符串LastNameP
{
获取{return LastName；}
设置{FirstName=value；}
}
公共国际
{
获取{返回年龄；}
设置{Age=value；}
}
公共字符串部门
{
获取{退货部门；}
设置{Department=value；}
}
公共字符串地址
{
获取{返回地址；}
设置{Address=value；}
}
#端区
}
[XmlRoot（“员工”）]
公共类MyWrapper
{
私有列表项=新列表（）；
[XmlElement（“员工”）]
公共列表项{get{return Items；}}
}
公共静态void Main（）
{
反序列化FromXML（）；
Console.WriteLine（）；
}
静态public-void-xml（MyWrapper列表）
{
XmlSerializer serializer=新的XmlSerializer（typeof（MyWrapper））；
使用（TextWriter TextWriter=newstreamWriter（@“Employees.xml”））
{
序列化器。序列化（textWriter，list）；
textWriter.Close（）；
}
}
静态公共void反序列化FromXML（）
{
Employee=null；
字符串path=“test.xml”；
XmlRootAttribute root=新的XmlRootAttribute（）；
root.ElementName=“Employee”；
XmlSerializer serializer=新的XmlSerializer（typeof（List））；
StreamReader=新的StreamReader（路径）；
//xml（2,2）文件异常
employees=（employeen）序列化程序。反序列化（reader）；
reader.Close（）；
}
}

---

请提供帮助

问题在于您正在序列化MyWrapper对象：

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

但试图反序列化员工列表：

XmlSerializer serializer = new XmlSerializer(typeof(List<Employee>));

XmlSerializer serializer=新的XmlSerializer（typeof（List））；

您需要对用于序列化的相同类型使用序列化程序

编辑：尝试反序列化xml示例后，它对我无效，因此我冒昧地更改了数据约定以正确反序列化文件：

   [XmlRoot("Employees")]
    public class MyWrapper
    {
        public List<Employee> Items { get; set; }
    }

    [XmlRoot("Employee")]
     public class Employee
    {
        public string FirstNameP
        {get;set;}
        public string LastNameP
        {get;set;}
        public int AgeP
        {get;set;}
        public string DepartmentP
        {get;set;}
        public string AddressP
        {get; set;}
    }

[XmlRoot（“员工”）]
公共类MyWrapper
{
公共列表项{get；set；}
}
[XmlRoot（“员工”）]
公营雇员
{
公共字符串FirstNameP
{get；set；}
公共字符串LastNameP
{get；set；}
公共国际
{get；set；}
公共字符串部门
{get；set；}
公共字符串地址
{get；set；}
}

问题在于您正在序列化MyWrapper对象：

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

但试图反序列化员工列表：

XmlSerializer serializer = new XmlSerializer(typeof(List<Employee>));

XmlSerializer serializer=新的XmlSerializer（typeof（List））；

您需要对用于序列化的相同类型使用序列化程序

编辑：尝试反序列化xml示例后，它对我无效，因此我冒昧地更改了数据约定以正确反序列化文件：

   [XmlRoot("Employees")]
    public class MyWrapper
    {
        public List<Employee> Items { get; set; }
    }

    [XmlRoot("Employee")]
     public class Employee
    {
        public string FirstNameP
        {get;set;}
        public string LastNameP
        {get;set;}
        public int AgeP
        {get;set;}
        public string DepartmentP
        {get;set;}
        public string AddressP
        {get; set;}
    }

[XmlRoot（“员工”）]
公共类MyWrapper
{
公共列表项{get；set；}
}
[XmlRoot（“员工”）]
公营雇员
{
公共字符串FirstNameP
{get；set；}
公共字符串LastNameP
{get；set；}
公共国际
{get；set；}
公共字符串部门
{get；set；}
公共字符串地址
{get；set；}
}

如果序列化

MyWrapper

，则必须反序列化

MyWrapper

，而不是列出。您总是必须在序列化时反序列化相同的类型

我将您从XML反序列化了一点：

static public void DeserializeFromXML ()
{
    // changed to be a list of employees
    List<Employee> employees = null;

    // added
    MyWrapper wrapper = null;

    string path = "test.xml";

    // changed type to MyWrapper
    XmlSerializer serializer = new XmlSerializer (typeof(MyWrapper));

    StreamReader reader = new StreamReader(path);

    // changed type to MyWrapper
    wrapper = (MyWrapper)serializer.Deserialize(reader);
    reader.Close();

    employees = wrapper.Items;
}

---

如果序列化

MyWrapper

，则必须反序列化

MyWrapper

，而不是列出。您总是必须在序列化时反序列化相同的类型

我将您从XML反序列化了一点：

static public void DeserializeFromXML ()
{
    // changed to be a list of employees
    List<Employee> employees = null;

    // added
    MyWrapper wrapper = null;

    string path = "test.xml";

    // changed type to MyWrapper
    XmlSerializer serializer = new XmlSerializer (typeof(MyWrapper));

    StreamReader reader = new StreamReader(path);

    // changed type to MyWrapper
    wrapper = (MyWrapper)serializer.Deserialize(reader);
    reader.Close();

    employees = wrapper.Items;
}

[XmlRoot（“员工”）]
[可序列化]
公共类MyWrapper
{
[XmlElement（“员工”）]
公共列表项{get；set；}
公共MyWrapper（）
{
项目=新列表（）；
}
}
公开选课
{
[XmlIgnore]
MyWrapper wrap=新的MyWrapper（）；
[XmlElement（“员工”）]
公共IEnumerable项{get；set；}
公共IEnumerable年龄选择（）
{
Items=wrap.Items.Where（x=>x.AgeP>25）；
退货项目；
}
}
公共静态void Main（）
{
var wrapper=new MyWrapper（）；
string[]firstNames={“Vlad”、“Alexey”、“dmitry”}；
字符串[]lastNames={“Ogirenko”、“Belous”、“Ivanov”}；
int[]年龄={19,26,33}；
字符串[]部门={.Net Sharepoint、.Net Sharepoint、.Net Sharepoint}；
字符串[]地址={“哈尔科夫”、“哈尔科夫”、“顿涅茨克”}；
[XmlRoot("Employees")]
    [Serializable]
    public class MyWrapper
    {
        [XmlElement("Employee")]
        public List<Employee> Items { get; set; }
        public MyWrapper()
        {
            Items = new List<Employee>();
        }

    }

    public class Selection
    {
        [XmlIgnore]
        MyWrapper wrap = new MyWrapper();

        [XmlElement("Employee")]
        public IEnumerable<Employee> Items { get; set; }
        public IEnumerable<Employee> AgeSelection()
        {
            Items = wrap.Items.Where(x => x.AgeP > 25);
            return Items;
        }
    }

    public static void Main()
    {
        var wrapper = new MyWrapper();

        string[] firstNames = { "Vlad", "Alexey", "Dmitriy" };
        string[] lastNames = { "Ogirenko", "Belous", "Ivanov" };
        int[] ages = { 19, 26, 33 };
        string[] departments = { ".Net Sharepoint", "Network", ".Net Sharepoint" };
        string[] address = { "Kharkov", "Kharkov", "Donetsk" };


        for (int i = 0; i < 3; i++)
        {
            Employee em = new Employee();
            em.FirstNameP = firstNames[i];
            em.LastNameP = lastNames[i];
            em.AgeP = ages[i];
            em.DepartmentP = departments[i];
            em.AddressP = address[i];
            wrapper.Items.Add(em);
            object o = typeof(Employee).GetField("EmpoyeeID", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(em);
        }

        SerializeToXML(wrapper, "test.xml");

        wrapper = DeserializeFromXML();
        foreach (var el in wrapper.Items)
        {
            ChangeEmployeeId(el, el.FirstNameP, el.LastNameP);
            Console.WriteLine("#"+(wrapper.Items.IndexOf(el)+1));
            Console.WriteLine("EmployeeID: "+GetId(el));
            Console.Write(el.Show()+"\n");
            Console.WriteLine("Address: "+GetAddress(el)+"\n");
        }

        Selection select = new Selection();

        SerializeToXML(select.AgeSelection(),"22.xml");
        Console.ReadLine();
    }

    static public void SerializeToXML(object list,string path)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(MyWrapper));

        using (var stream = new FileStream(path, FileMode.Create))
        {
            serializer.Serialize(stream, list);
            stream.Flush();
            stream.Close();
        }
    }

    static public MyWrapper DeserializeFromXML()
    {

        List<Employee> employees = null;
        MyWrapper wrapper = null;
        XmlSerializer serializer = new XmlSerializer(typeof(MyWrapper));

        string path = "test.xml";

        var stream = new FileStream(path, FileMode.Open);

        wrapper = (MyWrapper)serializer.Deserialize(stream);
        stream.Close();

        employees = wrapper.Items;

        return wrapper;
    }