C#-反序列化列表<；字符串>；

我可以很容易地序列化列表：

List<String> fieldsToNotCopy =new List<String> {"Iteration Path","Iteration ID"};
fieldsToNotCopy.SerializeObject("FieldsToNotMove.xml");

List fieldsToNotCopy=新列表{“迭代路径”，“迭代ID”}；
序列化对象（“FieldsToNotMove.xml”）；

现在我需要这样一种方法：

List<String> loadedList = new List<String();
loadedList.DeserializeObject("FieldsToNotMove.xml");

---

List-loadedList=new-List没有像SerializeObject这样的内置方法，但是编写一个方法并不十分困难

public void SerializeObject(this List<string> list, string fileName) {
  var serializer = new XmlSerializer(typeof(List<string>));
  using ( var stream = File.OpenWrite(fileName)) {
    serializer.Serialize(stream, list);
  }
}

public void序列化对象（此列表，字符串文件名）{
var serializer=newxmlserializer（typeof（List））；
使用（var stream=File.OpenWrite（文件名））{
序列化（流，列表）；
}
}

并反序列化

public void Deserialize(this List<string> list, string fileName) {
  var serializer = new XmlSerializer(typeof(List<string>));
  using ( var stream = File.OpenRead(fileName) ){
    var other = (List<string>)(serializer.Deserialize(stream));
    list.Clear();
    list.AddRange(other);
  }
}

public void反序列化（此列表，字符串文件名）{
var serializer=newxmlserializer（typeof（List））；
使用（var stream=File.OpenRead（文件名））{
var other=（List）（序列化程序.反序列化（流））；
list.Clear（）；
列表。添加范围（其他）；
}
}
这些是我的序列化/反序列化扩展方法，工作得很好

public static class SerializationExtensions
{
    public static XElement Serialize(this object source)
    {
        try
        {
            var serializer = XmlSerializerFactory.GetSerializerFor(source.GetType());
            var xdoc = new XDocument();
            using (var writer = xdoc.CreateWriter())
            {
                serializer.Serialize(writer, source, new XmlSerializerNamespaces(new[] { new XmlQualifiedName("", "") }));
            }

            return (xdoc.Document != null) ? xdoc.Document.Root : new XElement("Error", "Document Missing");
        }
        catch (Exception x)
        {
            return new XElement("Error", x.ToString());
        }
    }

    public static T Deserialize<T>(this XElement source) where T : class
    {
        try
        {
            var serializer = XmlSerializerFactory.GetSerializerFor(typeof(T));

            return (T)serializer.Deserialize(source.CreateReader());
        }
        catch //(Exception x)
        {
            return null;
        }
    }
}

public static class XmlSerializerFactory
{
    private static Dictionary<Type, XmlSerializer> serializers = new Dictionary<Type, XmlSerializer>();

    public static XmlSerializer GetSerializerFor(Type typeOfT)
    {
        if (!serializers.ContainsKey(typeOfT))
        {
            System.Diagnostics.Debug.WriteLine(string.Format("XmlSerializerFactory.GetSerializerFor(typeof({0}));", typeOfT));

            var newSerializer = new XmlSerializer(typeOfT);
            serializers.Add(typeOfT, newSerializer);
        }

        return serializers[typeOfT];
    }
}

公共静态类序列化扩展
{
公共静态XElement序列化（此对象源）
{
尝试
{
var serializer=XmlSerializerFactory.GetSerializerFor（source.GetType（））；
var xdoc=new XDocument（）；
使用（var writer=xdoc.CreateWriter（））
{
serializer.Serialize（writer，source，新的XMLSerializerNames（new[]{newXMLQualifiedName（“，”）}））；
}
返回（xdoc.Document！=null）？xdoc.Document.Root：新元素（“错误”，“缺少文档”）；
}
捕获（异常x）
{
返回新的XElement（“Error”，x.ToString（））；
}
}
公共静态T反序列化（此XElement源），其中T:class
{
尝试
{
var serializer=XmlSerializerFactory.GetSerializerFor（typeof（T））；
返回（T）序列化程序。反序列化（source.CreateReader（））；
}
catch/（异常x）
{
返回null；
}
}
}
公共静态类XmlSerializerFactory
{
私有静态字典序列化程序=新字典（）；
公共静态XmlSerializer GetSerializerFor（类型typeOfT）
{
if（！serializers.ContainsKey（typeOfT））
{
System.Diagnostics.Debug.WriteLine（string.Format（“XmlSerializerFactory.GetSerializerFor（typeof（{0}））；”，typeOfT））；
var newSerializer=新的XmlSerializer（typeOfT）；
添加（typeOfT，newSerializer）；
}
返回序列化程序[typeOfT]；
}
}

您只需要为列表定义一个类型，然后使用它

public class StringList : List<String> { }

public类StringList:List{}

哦，你不需要XmlSerializerFactory，它就在那里，因为创建序列化程序很慢，如果你反复使用同一个程序，这会加快你的应用程序速度。
我不确定这是否会对你有所帮助，但我相信我有一些东西与你类似

//A list that holds my data
private List<Location> locationCollection = new List<Location>();


public bool Load()
{
            //For debug purposes
            Console.WriteLine("Loading Data");

            XmlSerializer serializer = new XmlSerializer(typeof(List<Location>));
            FileStream fs = new FileStream("CurrencyData.xml", FileMode.Open);

            locationCollection = (List<Location>)serializer.Deserialize(fs);

            fs.Close();

            Console.WriteLine("Data Loaded");
            return true;
}

//保存我的数据的列表
私有列表位置集合=新列表（）；
公共布尔负荷（）
{
//用于调试目的
Console.WriteLine（“加载数据”）；
XmlSerializer serializer=新的XmlSerializer（typeof（List））；
FileStream fs=newfilestream（“CurrencyData.xml”，FileMode.Open）；
locationCollection=（列表）序列化程序。反序列化（fs）；
fs.Close（）；
Console.WriteLine（“数据加载”）；
返回true；
}

这允许我将所有数据反序列化回一个列表中，但为了安全起见，我建议将其放入try-catch块中。事实上，现在只要看看这个，我也会在“使用”块中重写它

我希望这有帮助

编辑：

抱歉，我注意到您试图用另一种方式进行操作，但无论如何我都会将答案留在那里。
我在反序列化对象时出错。错误为“XML文档（0，0）中存在错误”。我修改了最初由@JaredPar编写的反序列化函数以解决此错误。它可能对某人有用：

public static void Deserialize(this List<string> list, string fileName)
{
    XmlRootAttribute xmlRoot = new XmlRootAttribute();
    xmlRoot.ElementName = "YourRootElementName";
    xmlRoot.IsNullable = true;

    var serializer = new XmlSerializer(typeof(List<string>), xmlRoot);
    using (var stream = File.OpenRead(fileName))
    {
        var other = (List<string>)(serializer.Deserialize(stream));
        list.Clear();
        list.AddRange(other);
    }
}

publicstaticvoid反序列化（此列表，字符串文件名）
{
XmlRootAttribute xmlRoot=新的XmlRootAttribute（）；
xmlRoot.ElementName=“YourRootElementName”；
xmlRoot.IsNullable=true；
var serializer=newxmlserializer（typeof（List），xmlRoot）；
使用（var stream=File.OpenRead（文件名））
{
var other=（List）（序列化程序.反序列化（流））；
list.Clear（）；
列表。添加范围（其他）；
}
}
我原以为SerialzeObject是内置的，但我早就写过了。：）感谢您提供的反序列化方法。尝试了此方法，但无法使其正常工作。（xtension方法没有出现在itellisense中。）@Vaccano，它在尝试使用之前编译过吗？你在一个静态类中有，对吗？我在一个静态类中有。（我没有编译，但我添加的其他静态方法不需要编译就可以工作，所以我确实认为需要编译）。不管怎样，贾雷德帕的回答都符合我的需要。不过，我还是投票给了你，因为你在答案上付出了努力。谢谢@瓦卡诺，别担心。我只是一直在用这些，所以我很震惊它们不起作用！
public static void Deserialize(this List<string> list, string fileName)
{
    XmlRootAttribute xmlRoot = new XmlRootAttribute();
    xmlRoot.ElementName = "YourRootElementName";
    xmlRoot.IsNullable = true;

    var serializer = new XmlSerializer(typeof(List<string>), xmlRoot);
    using (var stream = File.OpenRead(fileName))
    {
        var other = (List<string>)(serializer.Deserialize(stream));
        list.Clear();
        list.AddRange(other);
    }
}