XML可序列化可序列化对象的通用列表（可序列化的类）

25-02-13 16

本文将分享XML可序列化可序列化对象的通用列表的详细内容，并且还将对可序列化的类进行详尽解释，此外，我们还将为大家带来关于android–通过意图传递可序列化对象、asp.net–调试：当类型IS标记

本文将分享XML可序列化可序列化对象的通用列表的详细内容，并且还将对可序列化的类进行详尽解释，此外，我们还将为大家带来关于android – 通过意图传递可序列化对象、asp.net – 调试：当类型IS标记为可序列化时,如何调试“类型未标记为可序列化”异常、C# xml和对象的序列化与反序列化、c# – 使用不同类的通用列表XML序列化的相关知识，希望对你有所帮助。

本文目录一览：

XML可序列化可序列化对象的通用列表（可序列化的类）
android – 通过意图传递可序列化对象
asp.net – 调试：当类型IS标记为可序列化时,如何调试“类型未标记为可序列化”异常
C# xml和对象的序列化与反序列化
c# – 使用不同类的通用列表XML序列化

XML可序列化可序列化对象的通用列表（可序列化的类）

我可以序列化可序列化对象的一般列表，而无需指定它们的类型。

类似于以下破损代码背后的意图：

List<ISerializable> serializableList = new List<ISerializable>();XmlSerializer xmlSerializer = new XmlSerializer(serializableList.GetType());serializableList.Add((ISerializable)PersonList);using (StreamWriter streamWriter = System.IO.File.CreateText(fileName)){    xmlSerializer.Serialize(streamWriter, serializableList);}

编辑：

对于那些想了解细节的人：当我尝试运行此代码时，它在XMLSerializer […]行上的错误如下：

无法序列化接口System.Runtime.Serialization.ISerializable。

如果我改变了List<object>我会得到"There was an error generating the XMLdocument."。InnerException详细信息是"{"The typeSystem.Collections.Generic.List1[[Project1.Person, ConsoleFramework,Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] may not be used inthis context."}"

人员对象定义如下：

[XmlRoot("Person")]public class Person{    string _firstName = String.Empty;    string _lastName = String.Empty;    private Person()    {    }    public Person(string lastName, string firstName)    {        _lastName = lastName;        _firstName = firstName;    }    [XmlAttribute(DataType = "string", AttributeName = "LastName")]    public string LastName    {        get { return _lastName; }        set { _lastName = value; }    }    [XmlAttribute(DataType = "string", AttributeName = "FirstName")]    public string FirstName    {        get { return _firstName; }        set { _firstName = value; }    }}

PersonList只是一个List<Person>。

不过，这只是用于测试，因此并不认为细节太重要。关键是我有一个或多个不同的对象，所有这些对象都是可序列化的。我想将它们全部序列化为一个文件。我认为最简单的方法是将它们放在通用列表中，然后一次性序列化列表。但这是行不通的。

我也尝试过List<IXmlSerializable>，但是失败了

System.Xml.Serialization.IXmlSerializable cannot be serialized because itdoes not have a parameterless constructor.

抱歉，缺少详细信息，但是我是一位初学者，不知道需要什么详细信息。如果人们要求更多细节，而试图以某种方式让我理解需要的细节或概述可能指示的基本答案，那将很有帮助。

也要感谢到目前为止我得到的两个答案-如果不理解这些主意，我本可以花更多的时间阅读。人们在此站点上的帮助程度令人惊讶。

答案1

小编典典

我有一个带有动态绑定项的通用List <>的解决方案。

类PersonalList是根元素

[XmlRoot("PersonenListe")][XmlInclude(typeof(Person))] // include type class Personpublic class PersonalList{    [XmlArray("PersonenArray")]    [XmlArrayItem("PersonObjekt")]    public List<Person> Persons = new List<Person>();    [XmlElement("Listname")]    public string Listname { get; set; }    // Konstruktoren     public PersonalList() { }    public PersonalList(string name)    {        this.Listname = name;    }    public void AddPerson(Person person)    {        Persons.Add(person);    }}

类Person这是一个列表元素

[XmlType("Person")] // define Type[XmlInclude(typeof(SpecialPerson)), XmlInclude(typeof(SuperPerson))]          // include type class SpecialPerson and class SuperPersonpublic class Person{    [XmlAttribute("PersID", DataType = "string")]    public string ID { get; set; }    [XmlElement("Name")]    public string Name { get; set; }    [XmlElement("City")]    public string City { get; set; }    [XmlElement("Age")]    public int Age { get; set; }    // Konstruktoren     public Person() { }    public Person(string name, string city, int age, string id)    {        this.Name = name;        this.City = city;        this.Age = age;        this.ID = id;    }}

类SpecialPerson继承Person

[XmlType("SpecialPerson")] // define Typepublic class SpecialPerson : Person{    [XmlElement("SpecialInterests")]    public string Interests { get; set; }    public SpecialPerson() { }    public SpecialPerson(string name, string city, int age, string id, string interests)    {        this.Name = name;        this.City = city;        this.Age = age;        this.ID = id;        this.Interests = interests;    }}

类SuperPerson继承Person

[XmlType("SuperPerson")] // define Typepublic class SuperPerson : Person{    [XmlArray("Skills")]    [XmlArrayItem("Skill")]    public List<String> Skills { get; set; }    [XmlElement("Alias")]    public string Alias { get; set; }    public SuperPerson()     {        Skills = new List<String>();    }    public SuperPerson(string name, string city, int age, string id, string[] skills, string alias)    {        Skills = new List<String>();        this.Name = name;        this.City = city;        this.Age = age;        this.ID = id;        foreach (string item in skills)        {            this.Skills.Add(item);           }        this.Alias = alias;    }}

和主要的测试源

static void Main(string[] args){    PersonalList personen = new PersonalList();     personen.Listname = "Friends";    // normal person    Person normPerson = new Person();    normPerson.ID = "0";    normPerson.Name = "Max Man";    normPerson.City = "Capitol City";    normPerson.Age = 33;    // special person    SpecialPerson specPerson = new SpecialPerson();    specPerson.ID = "1";    specPerson.Name = "Albert Einstein";    specPerson.City = "Ulm";    specPerson.Age = 36;    specPerson.Interests = "Physics";    // super person    SuperPerson supPerson = new SuperPerson();    supPerson.ID = "2";    supPerson.Name = "Superman";    supPerson.Alias = "Clark Kent";    supPerson.City = "Metropolis";    supPerson.Age = int.MaxValue;    supPerson.Skills.Add("fly");    supPerson.Skills.Add("strong");    // Add Persons    personen.AddPerson(normPerson);    personen.AddPerson(specPerson);    personen.AddPerson(supPerson);    // Serialize     Type[] personTypes = { typeof(Person), typeof(SpecialPerson), typeof(SuperPerson) };    XmlSerializer serializer = new XmlSerializer(typeof(PersonalList), personTypes);     FileStream fs = new FileStream("Personenliste.xml", FileMode.Create);     serializer.Serialize(fs, personen);     fs.Close();     personen = null;    // Deserialize     fs = new FileStream("Personenliste.xml", FileMode.Open);     personen = (PersonalList)serializer.Deserialize(fs);     serializer.Serialize(Console.Out, personen);    Console.ReadLine();}

重要的是定义，并包括不同的类型。

android – 通过意图传递可序列化对象

这是我第一次尝试寻求解决我的问题的方法,所以尽量做个好人！通过简单的搜索,我找到了许多我在本网站处理的问题的解决方案,但这次我没有运气.我发现什么都不符合我的问题,所以我结束了一个新的问题.

我试图将一个对象从一个活动传递到另一个活动.我有一个抽象类和两个子类(其中一个也是抽象的)如下所示.我需要它们是抽象的.我删除了很多代码(抽象方法等)只是为了找到问题所在,我最终得到了这些非常简单的类,我仍然遇到了同样的问题.

public abstract class MyObject {

    private boolean New;
    private boolean Modified;

    public MyObject() {
        New = true;
    }

    public boolean isNew() {
        return New;
    }

    protected void setNew(boolean value) {
        New = value;
    }

    protected boolean isModified() {
        return Modified;
    }

    protected void setModified(boolean value) {
        Modified = value;
    }

}

public abstract class MyItemBase extends MyObject {

    private Long Id;
    private String Description;

    public MyItemBase() {
        super();
    }

    public Long getId() {
        return Id;
    }

    public void setId(Long id) {
        Id = id;
    }

    public String getDescription() {
        return Description;
    }

    public void setDescription(String description) {
        Description = description;
    }

}

public class MyItem extends MyItemBase implements Serializable {

    private static final long serialVersionUID = -2875901021692711701L;

    public MyItem() {
        super();
    }

}

我有两个活动,ActivityA带有一个按钮来调用ActivityB,如下所示.

public class ActivityA extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_a);

        Button btn = (Button) findViewById(R.id.button);
        btn.setonClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                Intent intent = new Intent(getApplicationContext(),
                        ActivityB.class);

                MyItem item = new MyItem();
                item.setId((long) 1);
                item.setDescription("test");

                intent.putExtra("MyItem", (Serializable) item);
                startActivityForResult(intent, 1);
            }

        });
    }

}

public class ActivityB extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_b);

        MyItem item = (MyItem) getIntent().getSerializableExtra("MyItem");
        ((TextView) findViewById(R.id.text)).setText(item.getDescription());
    }

}

因此,当我从第二个活动接收MyItem时,没有任何错误,属性Id和Description都为null.实际上它是一个新对象,因为New属性是真的.现在,如果我尝试将对象完全放入第一个Activity中的意图后,就像那样

intent.putExtra("MyItem", (Serializable) item);
MyItem newItem = (MyItem) intent.getSerializableExtra("MyItem");
startActivityForResult(intent, 1);

它工作正常. newItem具有正确值的所有属性.

有任何想法吗？

大家提前谢谢！

解决方法:

从the official Serializable doc开始：

Classes that do not implement this interface will not have any of their state serialized or deserialized. All subtypes of a serializable class are themselves serializable.

您的基类没有实现Serializable,因此其字段不会被序列化.

使MyItemBase(甚至是MyObject)可序列化,并且它的所有后代也将变为Serializable(没有显式实现接口).

asp.net – 调试：当类型IS标记为可序列化时,如何调试“类型未标记为可序列化”异常

我试着：

((Request.Params["crmid"] != null))

在网页中.但它不断抛出序列化异常：

Type ‘QC.Security.SL.SiteUser’ in
assembly ‘QC.Security,
Version=1.0.0.1,Culture=neutral,
PublicKeyToken=null’ is not marked as
serializable.

然而,类型(自定义IIdentity)标记为可序列化如下：

[Serializable()]
    public class SiteUser : IIdentity
    {
        private long _userId;
        public long UserId { get { return _userId; } set { _userId = value; } }
        private string _name;
        public string Name { get { return _name; } }
        private bool _isAuthenticated;
        public bool IsAuthenticated { get { return _isAuthenticated; } }
        private string _authenticationType;
        public string AuthenticationType { get { return _authenticationType; } }

我不知道如何调试这个,因为我无法进入序列化器代码,以找出它为什么会摔倒.调用堆栈在到达[外部代码]之前只有一帧深度.并且错误消息是无用的,因为类型明确标记为可序列化.试验和错误调整也产生了一个类型未解决的成员异常.

它工作正常.但现在“突然间”它并不通常意味着Visual Studio中的一些愚蠢的错误,但重启并没有帮助“这个”时间.所以现在我不知道这是一个愚蠢的VS错误还是一个完全不相关的错误,我得到了序列化异常或者我做错了什么.

事实上,我不再相信VS了,因为过去几个月我一直在进行的疯狂追逐数量,这是通过重新启动VS 2008或其他一些荒谬的解决办法来“修复”的.

解决方法

哦,所以我已经解决了这个问题.这是另一个VS /卡西尼问题.根据 this url和 this url,解决方法是使SiteUser继承MarshalByRefObject.

这是必要的,因为：

The issue is that cassini will break
into separate AppDomains at will,
which doesn’t happen in IIS (even
though they say it CAN). Because of
this,when Atlas is trying to convert
to the JSON to something on the
server,it does something and switches
and the .User custom principal doesn’t
deserialize because the assembly is
not in the GAC and not registered with
the other AppDomain.

“开发人员开发人员咳嗽”

C# xml和对象的序列化与反序列化

为什么要做序列化和反序列化？

.Net程序执行时，对象都驻留在内存中；内存中的对象如果需要传递给其他系统使用；或者在关机时需要保存下来以便下次再次启动程序使用就需要序列化和反序列化。

一段最简单的Xml序列化代码

C# 代码复制

class Program{    static void Main(string[] args)    {        int i = 10;        //声明Xml序列化对象实例serializer        XmlSerializer serializer = new XmlSerializer(typeof(int));        //执行序列化并将序列化结果输出到控制台        serializer.Serialize(Console.Out, i);        Console.Read();    }}

上面代码对int i进行了序列化，并将序列化的结果输出到了控制台，输出结果如下

<?xml version="1.0" encoding="gb2312"?>
<int>10</int>

将上述序列化的xml进行反序列化，如下代码

C# 代码复制

static void Main(string[] args){    using (StringReader rdr = new StringReader(@"<?xml version=""1.0"" encoding=""gb2312""?><int>10</int>"))    {        //声明序列化对象实例serializer         XmlSerializer serializer = new XmlSerializer(typeof(int));        //反序列化，并将反序列化结果值赋给变量i        int i = (int)serializer.Deserialize(rdr);        //输出反序列化结果        Console.WriteLine("i = " + i);        Console.Read();    }}

以上代码用最简单的方式说明了xml序列化和反序列化的过程，.Net系统类库为我们做了大量的工作，序列化和反序列化都非常简单。但是在现实中业务需求往往比较复杂，不可能只简单的序列化一个int变量，显示中我们需要对复杂类型进行可控制的序列化。

System.Xml.Serialization类为我们提供了自己对象串行化（Serialize）和反串行化（Deserialize）的xml的方法，该类可以序列化的内容：

　　　　公共类的公共读写字段或者属性
　　　　XmlElement对象
　　　　XmlNode对象
　　　　Dataset对象
　　　　实现了Icollection 或IEnumerable的类

下面介绍 XML序列化和反序列化封装类

C# 代码复制

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.IO;using System.Data;using System.Xml;using System.Xml.Serialization; /// <summary>/// Xml序列化与反序列化/// </summary>public class XmlUtil{    #region 反序列化    /// <summary>    /// 反序列化    /// </summary>    /// <param name="type">类型</param>    /// <param name="xml">XML字符串</param>    /// <returns></returns>    public static object Deserialize(Type type, string xml)    {        try        {            using (StringReader sr = new StringReader(xml))            {                XmlSerializer xmldes = new XmlSerializer(type);                return xmldes.Deserialize(sr);            }        }        catch (Exception e)        {             return null;        }    }    /// <summary>    /// 反序列化    /// </summary>    /// <param name="type"></param>    /// <param name="xml"></param>    /// <returns></returns>    public static object Deserialize(Type type, Stream stream)    {        XmlSerializer xmldes = new XmlSerializer(type);        return xmldes.Deserialize(stream);    }    #endregion     序列化}

该封装类的测试代码

1. 实体对象转换到Xml

C# 代码复制

public class Student{    public string Name { set; get; }    public int Age { set; get; }} Student stu1 = new Student() { Name = "okbase", Age = 10 };string xml = XmlUtil.Serializer(typeof(Student), stu1);Console.Write(xml);

2. Xml转换到实体对象

Student stu2 = XmlUtil.Deserialize(typeof(Student), xml) as Student;
Console.Write(string.Format("名字:{0},年龄:{1}", stu2.Name, stu2.Age));

3、DataTable转换到Xml

C# 代码复制

// 生成DataTable对象用于测试DataTable dt1 = new DataTable("mytable");   // 必须指明DataTable名称 dt1.Columns.Add("Dosage", typeof(int));dt1.Columns.Add("Drug", typeof(string));dt1.Columns.Add("Patient", typeof(string));dt1.Columns.Add("Date", typeof(DateTime)); // 添加行dt1.Rows.Add(25, "Indocin", "David", DateTime.Now);dt1.Rows.Add(50, "Enebrel", "Sam", DateTime.Now);dt1.Rows.Add(10, "Hydralazine", "Christoff", DateTime.Now);dt1.Rows.Add(21, "Combivent", "Janet", DateTime.Now);dt1.Rows.Add(100, "Dilantin", "Melanie", DateTime.Now); // 序列化xml = XmlUtil.Serializer(typeof(DataTable), dt1);Console.Write(xml);

4. Xml转换到DataTable

C# 代码复制

// 反序列化DataTable dt2 = XmlUtil.Deserialize(typeof(DataTable), xml) as DataTable; // 输出测试结果foreach (DataRow dr in dt2.Rows){    foreach (DataColumn col in dt2.Columns)    {        Console.Write(dr[col].ToString() + " ");    }     Console.Write("\\r\\n");}

5. List转换到Xml

C# 代码复制

// 生成List对象用于测试List<Student> list1 = new List<Student>(3); list1.Add(new Student() { Name = "okbase", Age = 10 });list1.Add(new Student() { Name = "csdn", Age = 15 });// 序列化xml = XmlUtil.Serializer(typeof(List<Student>), list1);Console.Write(xml);

6. Xml转换到List

C# 代码复制

List<Student> list2 = XmlUtil.Deserialize(typeof(List<Student>), xml) as List<Student>;foreach (Student stu in list2){    Console.WriteLine(stu.Name + "," + stu.Age.ToString());}

c# – 使用不同类的通用列表XML序列化

我有以下代码：

BaseContent.cs

public class BaseContent
{
   // Some auto properties
}

News.cs

public class News : BaseContent
{
   // Some more auto properties
}

Events.cs

public class Event : BaseContent
{
   // Some more auto properites
}

GenericResponse.cs

public class GenericResponse<T> 
{
  [XmlArray("Content")]
  [XmlArrayItem("NewsObject",typeof(News)]
  [XmlArrayItem("EventObject",typeof(Event)]
  public List<T> ContentItems { get; set; }
}

NewsResponse.cs

public class NewsResponse : GenericResponse<News> {}

EventResponse.cs

public class EventResponse : GenericResponse<Event> {}

你可以看到,我有一个基类BaseContent和从它派生的两个类.接下来我有一个通用响应类,因为xml文件的结构总是相同的,但是在某些属性中它们有所不同.

我以为我可以用[XmlArrayItem]指定用于特定类的名称.但是现在我得到错误：

system.invalidOperationException: Unable to generate a temporary class (result=1).
error CS0012: The type ‘System.Object’ is defined in an assembly that is not referenced. You must add a reference to assembly ‘System.Runtime,Version=4.0.0.0,Culture=neutral,PublicKeyToken=b03f5f7f11d50a3a’.

我无法添加此引用,因为我正在使用Windows 8应用程序.

如果我注释掉其中一个[XmlArrayItem],它的工作效果很好.

任何人都有一个想法来解决这个问题？

更新
我不能使用DataContractSerializer,因为我必须使用XmlAttributes

解决方法

编辑：随意下载 demo project

您没有提供对象的所有属性,所以允许我添加一些 – 就像一个例子：

public class BaseContent
{
    [XmlAttribute("Name")]
    public string Name { get; set; }
}

[XmlType(TypeName = "EventObject")]
public class Event : BaseContent
{
    [XmlAttribute("EventId")]
    public int EventId { get; set; }
}

[XmlType(TypeName = "NewsObject")]
public class News : BaseContent
{
    [XmlAttribute("NewsId")]
    public int NewsId { get; set; }
}

GenericResponse.cs可以这样定义 – 不需要为数组项指定typeof：

public class GenericResponse<T>
{
    [XmlArray("Content")]
    public List<T> ContentItems { get; set; }

    public GenericResponse()
    {
        this.ContentItems = new List<T>();
    }
}

然后你有响应类：

public class EventResponse : GenericResponse<Event>
{
}

public class NewsResponse : GenericResponse<News>
{
}

示例1：序列化EventResponse对象

var response = new EventResponse
{
    ContentItems = new List<Event> 
    {
        new Event {
            EventId = 1,Name = "Event 1"
        },new Event {
            EventId = 2,Name = "Event 2"
        }
    }
};

string xml = XmlSerializer<EventResponse>.Serialize(response);

输出XML：

<?xml version="1.0" encoding="utf-8"?>
<EventResponse xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <Content>
        <EventObject Name="Event 1" EventId="1" />
        <EventObject Name="Event 2" EventId="2" />
    </Content>
</EventResponse>

如果您尝试与NewsResponse相同,它将正常工作. BTW我使用我的generic XmlSerializer,点击链接了解更多.

XmlSerializer.cs：

/// <summary>
/// XML serializer helper class. Serializes and deserializes objects from/to XML
/// </summary>
/// <typeparam name="T">The type of the object to serialize/deserialize.
/// Must have a parameterless constructor and implement <see cref="Serializable"/></typeparam>
public class XmlSerializer<T> where T: class,new()
{
    /// <summary>
    /// Deserializes a XML string into an object
    /// Default encoding: <c>UTF8</c>
    /// </summary>
    /// <param name="xml">The XML string to deserialize</param>
    /// <returns>An object of type <c>T</c></returns>
    public static T Deserialize(string xml)
    {
        return Deserialize(xml,Encoding.UTF8,null);
    }

    /// <summary>
    /// Deserializes a XML string into an object
    /// Default encoding: <c>UTF8</c>
    /// </summary>
    /// <param name="xml">The XML string to deserialize</param>
    /// <param name="encoding">The encoding</param>
    /// <returns>An object of type <c>T</c></returns>
    public static T Deserialize(string xml,Encoding encoding)
    {
        return Deserialize(xml,encoding,null);
    }

    /// <summary>
    /// Deserializes a XML string into an object
    /// </summary>
    /// <param name="xml">The XML string to deserialize</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlReaderSettings"/></param>
    /// <returns>An object of type <c>T</c></returns>
    public static T Deserialize(string xml,XmlReaderSettings settings)
    {
        return Deserialize(xml,settings);
    }

    /// <summary>
    /// Deserializes a XML string into an object
    /// </summary>
    /// <param name="xml">The XML string to deserialize</param>
    /// <param name="encoding">The encoding</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlReaderSettings"/></param>
    /// <returns>An object of type <c>T</c></returns>
    public static T Deserialize(string xml,Encoding encoding,XmlReaderSettings settings)
    {
        if (string.IsNullOrEmpty(xml))
            throw new ArgumentException("XML cannot be null or empty","xml");

        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));

        using (MemoryStream memoryStream = new MemoryStream(encoding.GetBytes(xml)))
        {
            using (XmlReader xmlReader = XmlReader.Create(memoryStream,settings))
            {
                return (T) xmlSerializer.Deserialize(xmlReader);
            }
        }
    }

    /// <summary>
    /// Deserializes a XML file.
    /// </summary>
    /// <param name="filename">The filename of the XML file to deserialize</param>
    /// <returns>An object of type <c>T</c></returns>
    public static T DeserializefromFile(string filename)
    {
        return DeserializefromFile(filename,new XmlReaderSettings());
    }

    /// <summary>
    /// Deserializes a XML file.
    /// </summary>
    /// <param name="filename">The filename of the XML file to deserialize</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlReaderSettings"/></param>
    /// <returns>An object of type <c>T</c></returns>
    public static T DeserializefromFile(string filename,XmlReaderSettings settings)
    {
        if (string.IsNullOrEmpty(filename))
            throw new ArgumentException("filename","XML filename cannot be null or empty");

        if (! File.Exists(filename))
            throw new FileNotFoundException("Cannot find XML file to deserialize",filename);

        // Create the stream writer with the specified encoding
        using (XmlReader reader = XmlReader.Create(filename,settings))
        {
            System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
            return (T) xmlSerializer.Deserialize(reader);
        }
    }

    /// <summary>
    /// Serialize an object
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <returns>A XML string that represents the object to be serialized</returns>
    public static string Serialize(T source)
    {
        // indented XML by default
        return Serialize(source,null,GetIndentedSettings());
    }

    /// <summary>
    /// Serialize an object
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <param name="namespaces">Namespaces to include in serialization</param>
    /// <returns>A XML string that represents the object to be serialized</returns>
    public static string Serialize(T source,XmlSerializerNamespaces namespaces)
    {
        // indented XML by default
        return Serialize(source,namespaces,GetIndentedSettings());
    }

    /// <summary>
    /// Serialize an object
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlWriterSettings"/></param>
    /// <returns>A XML string that represents the object to be serialized</returns>
    public static string Serialize(T source,XmlWriterSettings settings)
    {
        return Serialize(source,settings);
    }

    /// <summary>
    /// Serialize an object
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <param name="namespaces">Namespaces to include in serialization</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlWriterSettings"/></param>
    /// <returns>A XML string that represents the object to be serialized</returns>
    public static string Serialize(T source,XmlSerializerNamespaces namespaces,XmlWriterSettings settings)
    {
        if (source == null)
            throw new ArgumentNullException("source","Object to serialize cannot be null");

        string xml = null;
        XmlSerializer serializer = new XmlSerializer(source.GetType());

        using (MemoryStream memoryStream = new MemoryStream())
        {
            using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream,settings))
            {
                System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(typeof(T));
                x.Serialize(xmlWriter,source,namespaces);

                memoryStream.Position = 0; // rewind the stream before reading back.
                using (StreamReader sr = new StreamReader(memoryStream))
                {
                    xml = sr.ReadToEnd();
                } 
            }
        }

        return xml;
    }

    /// <summary>
    /// Serialize an object to a XML file
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <param name="filename">The file to generate</param>
    public static void SerializetoFile(T source,string filename)
    {
        // indented XML by default
        SerializetoFile(source,filename,GetIndentedSettings());
    }

    /// <summary>
    /// Serialize an object to a XML file
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <param name="filename">The file to generate</param>
    /// <param name="namespaces">Namespaces to include in serialization</param>
    public static void SerializetoFile(T source,string filename,XmlSerializerNamespaces namespaces)
    {
        // indented XML by default
        SerializetoFile(source,GetIndentedSettings());
    }

    /// <summary>
    /// Serialize an object to a XML file
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <param name="filename">The file to generate</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlWriterSettings"/></param>
    public static void SerializetoFile(T source,XmlWriterSettings settings)
    {
         SerializetoFile(source,settings);
    }

    /// <summary>
    /// Serialize an object to a XML file
    /// </summary>
    /// <param name="source">The object to serialize</param>
    /// <param name="filename">The file to generate</param>
    /// <param name="namespaces">Namespaces to include in serialization</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlWriterSettings"/></param>
    public static void SerializetoFile(T source,"Object to serialize cannot be null");

        XmlSerializer serializer = new XmlSerializer(source.GetType());

        using (XmlWriter xmlWriter = XmlWriter.Create(filename,settings))
        {
            System.Xml.Serialization.XmlSerializer x = new System.Xml.Serialization.XmlSerializer(typeof(T));
            x.Serialize(xmlWriter,namespaces);
        }
    }

    #region Private methods


    private static XmlWriterSettings GetIndentedSettings()
    {
        XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
        xmlWriterSettings.Indent = true;
        xmlWriterSettings.IndentChars = "\t";

        return xmlWriterSettings;
    }

    #endregion
}

今天的关于XML可序列化可序列化对象的通用列表和可序列化的类的分享已经结束，谢谢您的关注，如果想了解更多关于android – 通过意图传递可序列化对象、asp.net – 调试：当类型IS标记为可序列化时,如何调试“类型未标记为可序列化”异常、C# xml和对象的序列化与反序列化、c# – 使用不同类的通用列表XML序列化的相关知识，请在本站进行查询。

本文标签：