C# - Deserialize eine Liste <String>

Question

ich einfach eine Liste serialisiert werden kann:

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

Jetzt brauche ich eine Methode wie folgt aus:

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

Gibt es ein solches Verfahren? Oder muss ich einen XML-Reader erstellen und auf diese Weise laden?

---

EDIT: Stellt sich heraus, dass SerialzeObject nicht integriert ist. Ich hatte eines früher in meinem Projekt gemacht und es vergessen. Als ich es gefunden dachte ich, es wurde gebaut in Falls Sie neugierig sind dies die SerializeObject ist, die ich gemacht.

// Save an object out to the disk 
public static void SerializeObject<T>(this T toSerialize, String filename) 
{ 
    XmlSerializer xmlSerializer = new XmlSerializer(toSerialize.GetType()); 
    TextWriter textWriter = new StreamWriter(filename); 

    xmlSerializer.Serialize(textWriter, toSerialize); 
    textWriter.Close(); 
} 

Answer 1

Es gibt so builtin Verfahren wie SerializeObject nicht, aber es ist nicht sehr schwer zu Code entsprechend nach oben.

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); 
    } 
} 

Und Deserialize

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); 
    } 
} 

Answer 2

sind meine serialize/deserialize Erweiterungsmethoden sind die

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]; 
    } 
} 

Sie müssen nur einen Typ für die Liste definieren und verwenden Sie es stattdessen

ganz gut funktionieren

public class StringList : List<String> { } 

Oh, und Sie brauchen nicht die XmlSerializerFactory, es ist nur da, seit der Erstellung eines Serialisierers ist langsam, und wenn Sie die gleiche immer wieder verwenden, beschleunigt dies Ihre App.

Answer 3

Ich bin mir nicht sicher, ob dir das weiterhelfen wird, aber ich habe etwas, von dem ich glaube, dass es dir ähnlich ist.

//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; 
} 

Dies ermöglicht es mir alles wieder in eine Liste < meine Daten deserialise> aber ich würde raten, es in einem try setzen - catch-Block für die Sicherheit. In der Tat, wenn ich mir das jetzt anschaue, werde ich das auch in einen "using" -Block umschreiben.

Ich hoffe, das hilft.

EDIT:

Apologies, nur bemerkt, Sie versuchen es eine andere Art und Weise zu tun, aber ich werde meine Antwort dort sowieso verlassen.