XML-сериализация общего списка сериализуемых объектов

посмотреть представляем сериализацию XML:

Элементы, Которые Могут Быть Сериализованы

следующие пункты могут быть сериализованы с помощью XmlSerializer класс:

• публичные свойства чтения / записи и поля публичных классов
• классы, реализующие ICollection или IEnumerable
• XmlElement объекты
• XmlNode объекты
• DataSet объекты

в частности, ISerializable или [Serializable] атрибут не имеет значения.

теперь, когда вы сказали нам, в чем ваша проблема ("это не работает" - это не проблема), вы можете получить ответы на свою фактическую проблему, а не догадки.

когда вы сериализуете коллекцию типа, но на самом деле будет сериализовать коллекция экземпляров производных типов, вы должны позволить сериализатор знать, какие типы вы на самом деле будет сериализовать. Это также верно для коллекций object.

вам нужно использовать XmlSerializer (Тип,Тип[]) конструктор, чтобы дать список возможных типов.

нельзя сериализовать коллекцию объектов без указания ожидаемых типов. Вы должны передать список ожидаемых типов конструктору XmlSerializer (the

Я думаю, что лучше всего использовать методы с общими аргументами, например:

public static void SerializeToXml<T>(T obj, string fileName)
{
    using (var fileStream = new FileStream(fileName, FileMode.Create))
    { 
        var ser = new XmlSerializer(typeof(T)); 
        ser.Serialize(fileStream, obj);
    }
}

public static T DeserializeFromXml<T>(string xml)
{
    T result;
    var ser = new XmlSerializer(typeof(T));
    using (var tr = new StringReader(xml))
    {
        result = (T)ser.Deserialize(tr);
    }
    return result;
}

Я думаю, что подход Dreas в порядке. Альтернативой этому, однако, является наличие некоторых статических вспомогательных методов и реализация IXmlSerializable на каждом из ваших методов e.g метод расширения XmlWriter и XmlReader, чтобы прочитать его обратно.

public static void SaveXmlSerialiableElement<T>(this XmlWriter writer, String elementName, T element) where T : IXmlSerializable
{
   writer.WriteStartElement(elementName);
   writer.WriteAttributeString("TYPE", element.GetType().AssemblyQualifiedName);
   element.WriteXml(writer);
   writer.WriteEndElement();
}

public static T ReadXmlSerializableElement<T>(this XmlReader reader, String elementName) where T : IXmlSerializable
{
   reader.ReadToElement(elementName);

   Type elementType = Type.GetType(reader.GetAttribute("TYPE"));
   T element = (T)Activator.CreateInstance(elementType);
   element.ReadXml(reader);
   return element;
}

Если вы идете по маршруту использования класса XmlSerializer напрямую, создайте сборки сериализации перед рукой, если это возможно, так как вы можете получить большой удар по производительности при создании новых XmlSerializers регулярно.

для коллекции нужно что-то вроде этого:

public static void SaveXmlSerialiazbleCollection<T>(this XmlWriter writer, String collectionName, String elementName, IEnumerable<T> items) where T : IXmlSerializable
{
   writer.WriteStartElement(collectionName);
   foreach (T item in items)
   {
      writer.WriteStartElement(elementName);
      writer.WriteAttributeString("TYPE", item.GetType().AssemblyQualifiedName);
      item.WriteXml(writer);
      writer.WriteEndElement();
   }
   writer.WriteEndElement();
}

Ниже приведен класс Util в моем проекте:

namespace Utils
{
    public static class SerializeUtil
    {
        public static void SerializeToFormatter<F>(object obj, string path) where F : IFormatter, new()
        {
            if (obj == null)
            {
                throw new NullReferenceException("obj Cannot be Null.");
            }

            if (obj.GetType().IsSerializable == false)
            {
                //  throw new 
            }
            IFormatter f = new F();
            SerializeToFormatter(obj, path, f);
        }

        public static T DeserializeFromFormatter<T, F>(string path) where F : IFormatter, new()
        {
            T t;
            IFormatter f = new F();
            using (FileStream fs = File.OpenRead(path))
            {
                t = (T)f.Deserialize(fs);
            }
            return t;
        }

        public static void SerializeToXML<T>(string path, object obj)
        {
            XmlSerializer xs = new XmlSerializer(typeof(T));
            using (FileStream fs = File.Create(path))
            {
                xs.Serialize(fs, obj);
            }
        }

        public static T DeserializeFromXML<T>(string path)
        {
            XmlSerializer xs = new XmlSerializer(typeof(T));
            using (FileStream fs = File.OpenRead(path))
            {
                return (T)xs.Deserialize(fs);
            }
        }

        public static T DeserializeFromXml<T>(string xml)
        {
            T result;

            var ser = new XmlSerializer(typeof(T));
            using (var tr = new StringReader(xml))
            {
                result = (T)ser.Deserialize(tr);
            }
            return result;
        }


        private static void SerializeToFormatter(object obj, string path, IFormatter formatter)
        {
            using (FileStream fs = File.Create(path))
            {
                formatter.Serialize(fs, obj);
            }
        }
    }
}

самый простой способ сделать это, что я нашел.. Применить

параметр knowTypeList позвольте сериализовать с DataContractSerializer несколько известных типов:

private static void WriteObject(
        string fileName, IEnumerable<Vehichle> reflectedInstances, List<Type> knownTypeList)
    {
        using (FileStream writer = new FileStream(fileName, FileMode.Append))
        {
            foreach (var item in reflectedInstances)
            {
                var serializer = new DataContractSerializer(typeof(Vehichle), knownTypeList);
                serializer.WriteObject(writer, item);
            }
        }
    }

Если требование вывода XML может быть изменено, вы всегда можете использовать двоичную сериализацию, которая лучше подходит для работы с гетерогенными списками объектов. Вот пример:

private void SerializeList(List<Object> Targets, string TargetPath)
{
    IFormatter Formatter = new BinaryFormatter();

    using (FileStream OutputStream = System.IO.File.Create(TargetPath))
    {
        try
        {
            Formatter.Serialize(OutputStream, Targets);
        } catch (SerializationException ex) {
            //(Likely Failed to Mark Type as Serializable)
            //...
        }
}

использовать так:

[Serializable]
public class Animal
{
    public string Home { get; set; }
}

[Serializable]
public class Person
{
    public string Name { get; set; }
}


public void ExampleUsage() {

    List<Object> SerializeMeBaby = new List<Object> {
        new Animal { Home = "London, UK" },
        new Person { Name = "Skittles" }
    };

    string TargetPath = Path.Combine(
        Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
        "Test1.dat");

    SerializeList(SerializeMeBaby, TargetPath);
}