C# ASP.net转换列表<；T>；转换为XML

我已经读过，它看起来很简单，但我不知道为什么每次在XmlSerializer行上它都会崩溃，我想知道为什么，因为人们用类似的东西回答了将列表转换为xml的问题，但它似乎对我不起作用

代码如下：

类别：

[Serializable()]
    public class Pogos
    {
        public string Pogo { get; set; }
        public DateTime Date { get; set; }
    }

每日POGO列表：

 public static List<Pogos> DailyPogos = null;

公共静态列表DailyPogos=null；

将每日Pogo列表设置为.xml中的内容

 public static void SetDailyPogos()
    {
        string path = System.Web.Hosting.HostingEnvironment.MapPath("~/App_Data/DailyPogos.xml");

        if (File.Exists(path))
        {
            XmlSerializer serializer = new XmlSerializer(typeof(List<Pogos>));

            StreamReader reader = new StreamReader(path);
            DailyPogos = (List<Pogos>)serializer.Deserialize(reader);
            reader.Close();

            foreach (var pogo in DailyPogos)
            {
                if (pogo.Date.Date != DateTime.Now.Date)
                    DailyPogos.Remove(pogo);
            }
        }
        else
            DailyPogos = new List<Pogos>();
    }

publicstaticvoid SetDailyPogos（）
{
字符串路径=System.Web.Hosting.HostingEnvironment.MapPath（“~/App_Data/DailyPogos.xml”）；
if（File.Exists（path））
{
XmlSerializer serializer=新的XmlSerializer（typeof（List））；
StreamReader=新的StreamReader（路径）；
DailyPogos=（列表）序列化程序。反序列化（读取器）；
reader.Close（）；
foreach（DailyPogos中的var pogo）
{
if（pogo.Date.Date！=DateTime.Now.Date）
每日POGOS。移除（pogo）；
}
}
其他的
DailyPogos=新列表（）；
}

将每日POGO（不同）保存在.xml中

public static void SaveDailyPogos(List<string> pogos)
    {
        foreach (var pogo in pogos)
        {
            var matches = DailyPogos.Where(e => e.Pogo.Contains(pogo));
            foreach ( var match in matches)
            {
                DailyPogos.Remove(match);
            }
            var pog = new Pogos();
            pog.Pogo = pogo;
            pog.Date = DateTime.Now;
            DailyPogos.Add(pog);
        }

        string path = System.Web.Hosting.HostingEnvironment.MapPath("~/App_Data/DailyPogos.xml");

        //create the serialiser to create the xml
        XmlSerializer serialiser = new XmlSerializer(typeof(List<Pogos>));

        // Create the TextWriter for the serialiser to use
        TextWriter filestream = new StreamWriter(path);

        //write to the file
        serialiser.Serialize(filestream, DailyPogos);

        // Close the file
        filestream.Close();
    }

publicstaticvoidsavedailypogo（列出pogo）
{
foreach（pogos中的var pogo）
{
var matches=DailyPogos.Where（e=>e.Pogo.Contains（Pogo））；
foreach（匹配中的变量匹配）
{
DailyPogos.移除（匹配）；
}
var pog=新的Pogos（）；
pog.Pogo=Pogo；
pog.Date=DateTime.Now；
每日POGOS.Add（pog）；
}
字符串路径=System.Web.Hosting.HostingEnvironment.MapPath（“~/App_Data/DailyPogos.xml”）；
//创建serialiser以创建xml
XmlSerializer serialiser=新的XmlSerializer（typeof（List））；
//为serialiser创建要使用的TextWriter
TextWriter filestream=新的StreamWriter（路径）；
//写入文件
serialiser.Serialize（filestream，DailyPogos）；
//关闭文件
filestream.Close（）；
}

导致故障的线路（没有错误，只是崩溃）：

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

编辑：在这种情况下我很笨，首先，我可以通过添加一个try-catch来观察异常，我不知道为什么我没有。。我可能累了。

---

异常是说它失败是因为应用程序的保护级别，通过在程序类中添加“public”得到了修复。

我无法重现您声称看到的异常——假设

Pogo

类如您所说，那么

新的XmlSerializer（typeof（List））

将不会引发异常

您应该仔细检查这个类在实际应用程序中是否存在。如果不是，那么

newxmlserializer（typeof（List））

确实会抛出异常

也就是说，在创建

XmlSerializer

的调用附近有两个编码错误，即在使用

foreach

语句对

DailyPogos

集合进行枚举时修改该集合。这将引发异常，如中所述：

IEnumerator.MoveNext方法（）

例外情况： InvalidOperationException:创建枚举数后修改了集合

为了避免这些异常，可以使用。修改

SetDailyPogos（）

，如下所示：

XmlSerializer serializer = new XmlSerializer(typeof(List<Pogos>));
using (var reader = new StreamReader(path))
{
    DailyPogos = (List<Pogos>)serializer.Deserialize(reader);
}
var now = DateTime.Now;
DailyPogos.RemoveAll(p => p.Date.Date != now.Date);

---

由于从这些

foreach

语句引发的异常发生在构造

XmlSerializer

的调用附近，可能您误解了异常的来源？

如果我理解正确，您有一个要序列化然后从XML反序列化为的对象列表

试试这个

班级

[Serializable()]
public class Pogos
{
    public string Pogo { get; set; }
    public DateTime Date { get; set; }
}

使用

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

代码

    static void Main(string[] args)
    {
        List<Pogos> dObjToSerialize = new List<Pogos>();

        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 1" });
        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 2" });
        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 3" });
        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 4" });

        Serialize(dObjToSerialize); // find you XML in a file called "xml.xml" in the build folder

        List<Pogos> dObjToDeserialize = Deserialize<List<Pogos>>();

    } // Put a break-point here and dObjToDeserialize will contain your objects from the "xml.xml"

    private static void Serialize<T>(T data)
    {

        // Use a file stream here.
        using (TextWriter WriteFileStream = new StreamWriter("xml.xml"))
        {
            // Construct a SoapFormatter and use it  
            // to serialize the data to the stream.
            XmlSerializer SerializerObj = new XmlSerializer(typeof(T));

            try
            {
                // Serialize EmployeeList to the file stream
                SerializerObj.Serialize(WriteFileStream, data);
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Failed to serialize. Reason: {0}", ex.Message));
            }
        }
    }

    private static T Deserialize<T>() where T : new()
    {
        //List<Employee> EmployeeList2 = new List<Employee>();
        // Create an instance of T
        T ReturnListOfT = CreateInstance<T>();


        // Create a new file stream for reading the XML file
        using (FileStream ReadFileStream = new FileStream("xml.xml", FileMode.Open, FileAccess.Read, FileShare.Read))
        {
            // Construct a XmlSerializer and use it  
            // to serialize the data from the stream.
            XmlSerializer SerializerObj = new XmlSerializer(typeof(T));
            try
            {
                // Deserialize the hashtable from the file
                ReturnListOfT = (T)SerializerObj.Deserialize(ReadFileStream);
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Failed to serialize. Reason: {0}", ex.Message));
            }

        }
        // return the Deserialized data.
        return ReturnListOfT;
    }

    // function to create instance of T
    public static T CreateInstance<T>() where T : new()
    {
        return (T)Activator.CreateInstance(typeof(T));
    }
}

static void Main（字符串[]args）
{
List dObjToSerialize=新列表（）；
Add（new Pogos（）{Date=DateTime.Now，Pogo=“Pogo 1”}）；
Add（new Pogos（）{Date=DateTime.Now，Pogo=“Pogo 2”}）；
Add（new Pogos（）{Date=DateTime.Now，Pogo=“Pogo 3”}）；
Add（new Pogos（）{Date=DateTime.Now，Pogo=“Pogo 4”}）；
序列化（dObjToSerialize）；//在build文件夹中名为“XML.XML”的文件中查找XML
List dObjToDeserialize=反序列化（）；
}//在此处放置断点，DobjToderialize将包含“xml.xml”中的对象
私有静态void序列化（T数据）
{
//在这里使用文件流。
使用（TextWriter WriteFileStream=new StreamWriter（“xml.xml”））
{
//构造一个SoapFormatter并使用它
//将数据序列化到流。
XmlSerializer SerializerObj=新的XmlSerializer（typeof（T））；
尝试
{
//将EmployeeList序列化到文件流
SerializerObj.Serialize（WriteFileStream，数据）；
}
捕获（例外情况除外）
{
WriteLine（string.Format（“序列化失败。原因：{0}”，ex.Message））；
}
}
}
私有静态T反序列化（），其中T:new（）
{
//List EmployeeList2=新列表（）；
//创建一个T的实例
T returnListSoft=CreateInstance（）；
//创建用于读取XML文件的新文件流
使用（FileStream ReadFileStream=newfilestream（“xml.xml”，FileMode.Open，FileAccess.Read，FileShare.Read））
{
//构造一个XmlSerializer并使用它
//从流中序列化数据。
XmlSerializer SerializerObj=新的XmlSerializer（typeof（T））；
尝试
{
//从文件中反序列化哈希表
returnListSoft=（T）SerializerObj.Deserialize（ReadFileStream）；
}
using System;
using System.Collections.Generic;
using System.IO;
using System.Xml.Serialization;

    static void Main(string[] args)
    {
        List<Pogos> dObjToSerialize = new List<Pogos>();

        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 1" });
        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 2" });
        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 3" });
        dObjToSerialize.Add(new Pogos() { Date = DateTime.Now, Pogo = "Pogo 4" });

        Serialize(dObjToSerialize); // find you XML in a file called "xml.xml" in the build folder

        List<Pogos> dObjToDeserialize = Deserialize<List<Pogos>>();

    } // Put a break-point here and dObjToDeserialize will contain your objects from the "xml.xml"

    private static void Serialize<T>(T data)
    {

        // Use a file stream here.
        using (TextWriter WriteFileStream = new StreamWriter("xml.xml"))
        {
            // Construct a SoapFormatter and use it  
            // to serialize the data to the stream.
            XmlSerializer SerializerObj = new XmlSerializer(typeof(T));

            try
            {
                // Serialize EmployeeList to the file stream
                SerializerObj.Serialize(WriteFileStream, data);
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Failed to serialize. Reason: {0}", ex.Message));
            }
        }
    }

    private static T Deserialize<T>() where T : new()
    {
        //List<Employee> EmployeeList2 = new List<Employee>();
        // Create an instance of T
        T ReturnListOfT = CreateInstance<T>();


        // Create a new file stream for reading the XML file
        using (FileStream ReadFileStream = new FileStream("xml.xml", FileMode.Open, FileAccess.Read, FileShare.Read))
        {
            // Construct a XmlSerializer and use it  
            // to serialize the data from the stream.
            XmlSerializer SerializerObj = new XmlSerializer(typeof(T));
            try
            {
                // Deserialize the hashtable from the file
                ReturnListOfT = (T)SerializerObj.Deserialize(ReadFileStream);
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Failed to serialize. Reason: {0}", ex.Message));
            }

        }
        // return the Deserialized data.
        return ReturnListOfT;
    }

    // function to create instance of T
    public static T CreateInstance<T>() where T : new()
    {
        return (T)Activator.CreateInstance(typeof(T));
    }
}