Ist es möglich, XML in Liste <T> zu deserialisieren?

Gegeben das folgende XML:

<?xml version="1.0"?>
<user_list>
   <user>
      <id>1</id>
      <name>Joe</name>
   </user>
   <user>
      <id>2</id>
      <name>John</name>
   </user>
</user_list>

Und die folgende Klasse:

public class User {
   [XmlElement("id")]
   public Int32 Id { get; set; }

   [XmlElement("name")]
   public String Name { get; set; }
}

Ist es möglich, XmlSerializerdie XML in eine zu deserialisieren List<User>? Wenn ja, welche Art von zusätzlichen Attributen muss ich verwenden oder welche zusätzlichen Parameter muss ich zum Erstellen der XmlSerializerInstanz verwenden?

Ein Array ( User[]) wäre akzeptabel, wenn es etwas weniger vorzuziehen wäre.

Sie können die Liste trivial kapseln :

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

[XmlRoot("user_list")]
public class UserList
{
    public UserList() {Items = new List<User>();}
    [XmlElement("user")]
    public List<User> Items {get;set;}
}
public class User
{
    [XmlElement("id")]
    public Int32 Id { get; set; }

    [XmlElement("name")]
    public String Name { get; set; }
}

static class Program
{
    static void Main()
    {
        XmlSerializer ser= new XmlSerializer(typeof(UserList));
        UserList list = new UserList();
        list.Items.Add(new User { Id = 1, Name = "abc"});
        list.Items.Add(new User { Id = 2, Name = "def"});
        list.Items.Add(new User { Id = 3, Name = "ghi"});
        ser.Serialize(Console.Out, list);
    }
}

Wenn Sie die UserKlasse mit dem dekorieren, das XmlTypeder erforderlichen Großschreibung entspricht:

[XmlType("user")]
public class User
{
   ...
}

Dann kann der XmlRootAttributeon the XmlSerializerctor die gewünschte Wurzel bereitstellen und das direkte Einlesen in List <> ermöglichen:

    // e.g. my test to create a file
    using (var writer = new FileStream("users.xml", FileMode.Create))
    {
        XmlSerializer ser = new XmlSerializer(typeof(List<User>),  
            new XmlRootAttribute("user_list"));
        List<User> list = new List<User>();
        list.Add(new User { Id = 1, Name = "Joe" });
        list.Add(new User { Id = 2, Name = "John" });
        list.Add(new User { Id = 3, Name = "June" });
        ser.Serialize(writer, list);
    }

...

    // read file
    List<User> users;
    using (var reader = new StreamReader("users.xml"))
    {
        XmlSerializer deserializer = new XmlSerializer(typeof(List<User>),  
            new XmlRootAttribute("user_list"));
        users = (List<User>)deserializer.Deserialize(reader);
    }

Gutschrift: basierend auf der Antwort von YK1 .

Ja, eine Liste wird serialisiert und deserialisiert <>. Stellen Sie einfach sicher, dass Sie im Zweifelsfall das Attribut [XmlArray] verwenden.

[Serializable]
public class A
{
    [XmlArray]
    public List<string> strings;
}

Dies funktioniert sowohl mit Serialize () als auch mit Deserialize ().

Ich glaube, ich habe einen besseren Weg gefunden. Sie müssen keine Attribute in Ihre Klassen einfügen. Ich habe zwei Methoden für die Serialisierung und Deserialisierung erstellt, bei denen die generische Liste als Parameter verwendet wird.

Schau mal (es funktioniert bei mir):

private void SerializeParams<T>(XDocument doc, List<T> paramList)
    {
        System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(paramList.GetType());

        System.Xml.XmlWriter writer = doc.CreateWriter();

        serializer.Serialize(writer, paramList);

        writer.Close();           
    }

private List<T> DeserializeParams<T>(XDocument doc)
    {
        System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(List<T>));

        System.Xml.XmlReader reader = doc.CreateReader();

        List<T> result = (List<T>)serializer.Deserialize(reader);
        reader.Close();

        return result;
    }

So können Sie jede gewünschte Liste serialisieren! Sie müssen den Listentyp nicht jedes Mal angeben.

        List<AssemblyBO> list = new List<AssemblyBO>();
        list.Add(new AssemblyBO());
        list.Add(new AssemblyBO() { DisplayName = "Try", Identifier = "243242" });
        XDocument doc = new XDocument();
        SerializeParams<T>(doc, list);
        List<AssemblyBO> newList = DeserializeParams<AssemblyBO>(doc);

Ja, es wird in List <> deserialisiert. Sie müssen es nicht in einem Array aufbewahren und in eine Liste einschließen / einkapseln.

public class UserHolder
{
    private List<User> users = null;

    public UserHolder()
    {
    }

    [XmlElement("user")]
    public List<User> Users
    {
        get { return users; }
        set { users = value; }
    }
}

Deserialisierungscode,

XmlSerializer xs = new XmlSerializer(typeof(UserHolder));
UserHolder uh = (UserHolder)xs.Deserialize(new StringReader(str));

Ich bin mir nicht sicher über List <T>, aber Arrays sind auf jeden Fall machbar. Und ein bisschen Magie macht es wirklich einfach, wieder zu einer Liste zu gelangen.

public class UserHolder {
   [XmlElement("list")]
   public User[] Users { get; set; }

   [XmlIgnore]
   public List<User> UserList { get { return new List<User>(Users); } }
}

Wie wäre es mit

XmlSerializer xs = new XmlSerializer(typeof(user[]));
using (Stream ins = File.Open(@"c:\some.xml", FileMode.Open))
foreach (user o in (user[])xs.Deserialize(ins))
   userList.Add(o);    

Nicht besonders schick, aber es sollte funktionieren.