C#序列化和反序列化

一、XML的序列化

using System.Xml.Serialization;

https://www.cnblogs.com/KeithWang/archive/2012/02/22/2363443.html 

1.建立序列化测试对象 

[XmlRootAttribute("City", Namespace = "China", IsNullable = false)] // 当该类为Xml根节点时，以此为根节点名称
public class CityXml
{
    [XmlAttribute("CityId")]  // 表现为Xml节点属性
    public int ID { get; set; }

    [XmlAttribute("CityName")]  // 表现为Xml节点属性
    public string Name { get; set; }

    [XmlArrayAttribute("Persons")]  // 表现为Xml层次结构，其所属的每个该集合节点元素名为类名
    public PersonXml[] PersonXmls { get; set; }

    [XmlIgnoreAttribute]  // 忽略该元素的序列化
    public int Sex { get; set; }
}

[XmlRootAttribute("Person")]
public class PersonXml
{
    [XmlAttribute("IDCard")]
    public int ID { get; set; }

    [XmlElementAttribute("FullName")]  // 表现为水平结构的Xml节点
    public string Name { get; set; }

    [XmlElementAttribute("Telephone", IsNullable = false)]  // 表现为水平结构的Xml节点
    public string[] Phones { get; set; }
}

2.xml序列化和反序列化 

public class XmlSerialization<T>
{
    public void Serialize(string path, T t)
    {
        XmlSerializer serializer = new XmlSerializer(t.GetType());
        using (StreamWriter stream = new StreamWriter(path, false))
        {
            serializer.Serialize(stream, t);
        }
    }

    public T Deserialize(string path)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(T));
        using (StreamReader reader = new StreamReader(path))
        {
            return (T)serializer.Deserialize(reader);
        }
    }

    public void Serialize(string filePath, T sourceObj, Type type, string xmlRootName)
    {
        if (!string.IsNullOrWhiteSpace(filePath) && sourceObj != null)
        {
            type = type != null ? type : sourceObj.GetType();

            using (StreamWriter writer = new StreamWriter(filePath))
            {
                XmlSerializer xmlSerializer = string.IsNullOrWhiteSpace(xmlRootName) ?
                    new XmlSerializer(type) :
                    new XmlSerializer(type, new XmlRootAttribute(xmlRootName));
                xmlSerializer.Serialize(writer, sourceObj);
            }
        }
    }
}

 3.序列化测试

public static void Xml()
{
    PersonXml personXml1 = new PersonXml() { ID = 1, Name = "A" };
    personXml1.Phones = new string[] { "12345", "45678" };
    PersonXml personXml2 = new PersonXml() { ID = 2, Name = "B" };
    personXml2.Phones = new string[] { "130458", "159789" };
    PersonXml personXml3 = new PersonXml() { ID = 3, Name = "C" };
    personXml3.Phones = new string[] { "139874", "134587" };

    CityXml cityXml = new CityXml() { ID = 123, Name = "SZ", Sex = 0 };
    cityXml.PersonXmls = new PersonXml[] { personXml1, personXml2, personXml3 };

    XmlSerialization<CityXml> xmlSerialization = new XmlSerialization<CityXml>();
    xmlSerialization.Serialize("CityXml.xml", cityXml);
}

4.序列化后结果对比 

•  带特性的序列化

<?xml version="1.0" encoding="utf-8"?>
<City xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
      CityId="123" CityName="SZ" xmlns="China">
  <Persons>
    <PersonXml IDCard="1">
      <FullName>A</FullName>
      <Telephone>12345</Telephone>
      <Telephone>45678</Telephone>
    </PersonXml>
    <PersonXml IDCard="2">
      <FullName>B</FullName>
      <Telephone>130458</Telephone>
      <Telephone>159789</Telephone>
    </PersonXml>
    <PersonXml IDCard="3">
      <FullName>C</FullName>
      <Telephone>139874</Telephone>
      <Telephone>134587</Telephone>
    </PersonXml>
  </Persons>
</City>

• 不带特性的序列化 

<?xml version="1.0" encoding="utf-8"?>
<CityXml xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <ID>123</ID>
  <Name>SZ</Name>
  <PersonXmls>
    <PersonXml>
      <ID>1</ID>
      <Name>A</Name>
      <Phones>
        <string>12345</string>
        <string>45678</string>
      </Phones>
    </PersonXml>
    <PersonXml>
      <ID>2</ID>
      <Name>B</Name>
      <Phones>
        <string>130458</string>
        <string>159789</string>
      </Phones>
    </PersonXml>
    <PersonXml>
      <ID>3</ID>
      <Name>C</Name>
      <Phones>
        <string>139874</string>
        <string>134587</string>
      </Phones>
    </PersonXml>
  </PersonXmls>
  <Sex>0</Sex>
</CityXml>

二、Json的序列化 

using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Serialization;

https://www.cnblogs.com/zhaoshujie/p/11077843.html 

1.建立序列化测试对象 

//[JsonObject(MemberSerialization.OptOut)]  //默认值,类中所有公有成员会被序列化,如果不想被序列化,可以用特性JsonIgnore
//[JsonObject(MemberSerialization.OptIn)]   //默认情况下,所有的成员不会被序列化,类中的成员只有标有特性JsonProperty的才会被序列化
public class CityJson
{
    public int ID { get; set; }

    public string Name { get; set; }

    [JsonProperty(PropertyName = "Persons")]  //自定义序列化的字段名称
    public PersonJson[] PersonJsons { get; set; }

    [JsonProperty]  //序列化时默认都是处理公共成员,让私有也得到处理
    private string Location { get; set; }

    [JsonIgnore]  // 忽略该元素的序列化
    public int Sex { get; set; }

    [JsonProperty(NullValueHandling = NullValueHandling.Ignore)]   //为null值时不会序列化
    public PersonJson PersonJson { get; set; }
}

public class PersonJson
{
    public int ID { get; set; }

    public string Name { get; set; }

    public string[] Phones { get; set; }

    [JsonConverter(typeof(ChinaDateTimeConverter))]  //默认:"2008-04-12T12:53Z"
    public DateTime Birthday { get; set; }

    [JsonConverter(typeof(StringEnumConverter))]  //默认:枚举对应的整型数值 加上:枚举对应的字符
    public NullValueHandling NullValueHandling { get; set; }
}

2.Json序列化和反序列化 

public class JsonSerialization<T>
{
    public void Serialize(string path, T t)
    {
        using (StreamWriter sw = File.CreateText(path))
        {
            string json = JsonConvert.SerializeObject(t, Formatting.Indented);
            sw.Write(json);
        }
    }

    public void SerializeSettings(string path, T t)
    {
        using (StreamWriter sw = File.CreateText(path))
        {
            JsonSerializerSettings jsetting = new JsonSerializerSettings();
            jsetting.NullValueHandling = NullValueHandling.Ignore;
            string json = JsonConvert.SerializeObject(t, Formatting.Indented, jsetting);
            sw.Write(json);
        }
    }

    public T Deserialize(string path)
    {
        using (StreamReader sr = new StreamReader(path, Encoding.Default))
        {
            return JsonConvert.DeserializeObject<T>(sr.ReadToEnd());
        }
    }
}

3.重写部分有效的转换器 

/// <summary>
/// 日期处理
/// </summary>
public class ChinaDateTimeConverter : DateTimeConverterBase
{
    private static IsoDateTimeConverter dtConverter = new IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd HH:mm:ss" };

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        return dtConverter.ReadJson(reader, objectType, existingValue, serializer);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        dtConverter.WriteJson(writer, value, serializer);
    }
}

/// <summary>
/// 动态决定属性是否序列化
/// </summary>
public class LimitPropsContractResolver : DefaultContractResolver
{
    string[] props = null;
    bool retain;
    /// <summary>
    /// 构造函数
    /// </summary>
    /// <param name="props">传入的属性数组</param>
    /// <param name="retain">true:表示props是需要保留的字段  false：表示props是要排除的字段</param>
    public LimitPropsContractResolver(string[] props, bool retain = true)
    {
        //指定要序列化属性的清单
        this.props = props;
        this.retain = retain;
    }

    protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        IList<JsonProperty> list = base.CreateProperties(type, memberSerialization);
        //只保留清单有列出的属性
        return list.Where(p =>
        {
            if (retain)
            {
                return props.Contains(p.PropertyName);
            }
            else
            {
                return !props.Contains(p.PropertyName);
            }
        }).ToList();
    }
}

4.序列化测试 

public static void Json()
{
    PersonJson personJson1 = new PersonJson() { ID = 1 };
    personJson1.Phones = new string[] { "12345", "45678" };
    PersonJson personJson2 = new PersonJson() { ID = 2, Name = "B" };
    personJson2.Phones = new string[] { "130458", "159789" };
    PersonJson personJson3 = new PersonJson() { ID = 3, Name = "C" };
    personJson3.Phones = new string[] { "139874", "134587" };

    CityJson cityXml = new CityJson() { ID = 123, Name = "SZ", Sex = 0 };
    cityXml.PersonJsons = new PersonJson[] { personJson1, personJson2, personJson3 };

    JsonSerialization<CityJson> jsonSerialization = new JsonSerialization<CityJson>();
    jsonSerialization.Serialize("City.json", cityXml);
}

5.序列化后的结果 

{
  "ID": 123,
  "Name": "SZ",
  "Persons": [
    {
      "ID": 1,
      "Name": null,
      "Phones": [
        "12345",
        "45678"
      ],
      "Birthday": "0001-01-01 00:00:00",
      "NullValueHandling": "Include"
    },
    {
      "ID": 2,
      "Name": "B",
      "Phones": [
        "130458",
        "159789"
      ],
      "Birthday": "0001-01-01 00:00:00",
      "NullValueHandling": "Include"
    },
    {
      "ID": 3,
      "Name": "C",
      "Phones": [
        "139874",
        "134587"
      ],
      "Birthday": "0001-01-01 00:00:00",
      "NullValueHandling": "Include"
    }
  ],
  "Location": null
}

三、bin文件的序列化 

using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

 //序列化后不能修改空间名  （可用于深复制）  所有对象都需标记为：[Serializable]

public class BinSerialization<T>
{
    public void Serialize(string path, T t)
    {
        using (FileStream fileStream = File.Create(path))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            formatter.Serialize(fileStream, t);
        }
    }

    public T Deserialize(string path)
    {
        using (FileStream fileStream = File.OpenRead(path))
        {
            BinaryFormatter formatter = new BinaryFormatter();
            object clonedObj = formatter.Deserialize(fileStream);
            return (T)clonedObj;
        }
    }
}