Сериализация и десериализация данных в C#

Содержание

1 Что такое сериализация и десериализация?
2 Использование двоичной сериализации

Что такое сериализация и десериализация?

Сериализация - это механизм преобразования объекта в поток байтов или текста. Deserialization берет ряд байтов или плоский файл и преобразует его в объект.

Почему требуется сериализация данных?

При создании приложений вам может потребоваться обмен данными с другими приложениями.
При отправке данных в веб-службу или через сетевой поток сначала необходимо преобразовать данные в плоскую или двоичную форму.
Когда вы получаете данные, вам необходимо преобразовать плоские или двоичные данные в объекты, с которыми вы хотите работать. Этот процесс называется сериализации и десериализации.

Сериализация сериализует только данные, хранящиеся в объекте. Методы не сериализованы.
Когда вы десериализуете объект, вам нужен доступ к первоначальному определению класса, или вы получите объект, который хранит данные только.
Вы можете создать пользовательский объект передачи данных (DTO), чтобы оптимизировать объем данных, которые вы должны сериализовать.

.NET Framework предоставляет пространства имен System.Runtime.Serialization и System.Xml.Serialization, которые помогут с сериализацией и десериализацией вашего объекта.

.NET Framework предоставляет три механизма сериализации, которые вы можете использовать по умолчанию:

XmlSerializer
DataContractSerializer
BinaryFormatter

Использование XmlSerializer

XmlSerializer был создан для поддержки обмена сообщениями протокола Simple Object Access Protocol (SOAP). SOAP - это протокол для обмена информацией с веб-службами. SOAP использует XML в качестве формата сообщений. XML не зависит от среды и читается как людьми, так и машинами.

Давайте посмотрим на приведенный ниже пример по сериализации объекта с помощью XmlSerializer.

[Serializable]
public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}
    XmlSerializer serializer = new XmlSerializer(typeof(Person));
    string xml;
    using (StringWriter stringWriter = new StringWriter())
    {
        Person p = new Person
        {
            FirstName = "Steve",
            LastName = "Smith",
            Age = 51
        };
        serializer.Serialize(stringWriter, p);
        xml = stringWriter.ToString();
    }
Console.WriteLine(xml);
using (StringReader stringReader = new StringReader(xml))
{
    Person p = (Person)serializer.Deserialize(stringReader);
    Console.WriteLine(“{0} {1} is {2} years old”, p.FirstName, p.LastName, p.Age);
}

В приведенном выше примере класс Person помечен Serializable. Все члены этого типа автоматически сериализуются, если они не откажутся.

Вывод:

// Displays
//<?xml version=”1.0” encoding=”utf-16”?>
//<Person xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
// xmlns:xsd=”http://www.w3.org/2001/XMLSchema”>
// <FirstName>Steve</FirstName>
// <LastName>Smith</LastName>
// <Age>51</Age>
//</Person>
//Steve Smith is 51 years old

В XmlSerializer вам необходимо пометить ваши типы с помощью атрибута [Serializable]. Это сообщает .NET Framework, что ваш тип должен быть сериализуемым. Если сериализация невозможна, вы получите исключение во время выполнения.

Вы можете настроить, как XmlSerializer сериализует ваш тип с помощью атрибутов.
Эти атрибуты определены в пространстве имен System.Xml.Serialization.
Важными атрибутами являются:
1. XmlIgnore
2. XmlAttribute
3. XmlElement
4. XmlArray
5. XmlArrayItem
По умолчанию каждый член сериализуется как элемент XmlElement

Использование атрибутов XML для настройки сериализации

[Serializable]
public class Person
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int Age { get; set; }
}
[Serializable]
public class Order
{
[XmlAttribute]
public int ID { get; set; }
[XmlIgnore]
public bool IsDirty { get; set; }
[XmlArray(“Lines”)]
[XmlArrayItem(“OrderLine”)]
public List<OrderLine> OrderLines { get; set; }
}
[Serializable]
public class VIPOrder : Order
    {
public string Description { get; set; }
}
[Serializable]
public class OrderLine
{
[XmlAttribute]
public int ID { get; set; }
[XmlAttribute]
public int Amount { get; set; }
[XmlElement(“OrderedProduct”)]
public Product Product { get; set; }
}
[Serializable]
public class Product
{
[XmlAttribute]
public int ID { get; set; }
public decimal Price { get; set; }
public string Description { get; set; }
}

Использование двоичной сериализации

XmlSerializer выводит текст, читаемый человеком. Вы можете открыть его в Notepad.But, используя двоичный формат, вы получите меньший результат.
Использование двоичной сериализации аналогично XmlSerializer.
Вам нужно отметить элемент с помощью параметра SerializableAttribute, а затем вы используете экземпляр двоичного сериализатора для сериализации объекта. Рамка .net обеспечивает System.Runtime.Serialization и System.Runtime.Serialization.Formatters.Binary пространства имен для поддержки двоичной сериализации.

Например:

[Serializable]
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
private bool isDirty = false;
}
Person p = new Person
{
Id = 1,
Name = “Steve Smith”
};
IFormatter formatter = new BinaryFormatter();
using (Stream stream = new FileStream(“data.bin”, FileMode.Create))
{
formatter.Serialize(stream, p);
}
using (Stream stream = new FileStream(“data.bin”, FileMode.Open))
{
Person dp = (Person)formatter.Deserialize(stream);
}

В Binary Serialization частные поля по умолчанию сериализуются. Во время десериализации конструкторы не выполняются.
вы можете запретить сериализацию полей с использованием атрибута [NonSerialized], такого как XmlSerialization.

Если XMLserializer не может найти определенное поле, он не будет генерировать исключение; он просто установит свойство по умолчанию.
Но в двоичной сериализации она генерирует исключение. Таким образом, вы можете использовать OptionFieldAttribute, чтобы убедиться, что двоичный сериализатор знает, что поле добавлено в более позднюю версию.

Вы можете влиять на процесс сериализации и десериализации, используя следующие четыре атрибута:
1. OnDeserializedAttribute
2. OnDeserializingAttribute
3. OnSerializedAttribute
4. OnSerializingAttribute.
Вы можете добавить эти атрибуты к методам внутри вашего класса, которые принимают StreamingContext в качестве параметра.

Давайте рассмотрим ниже код о том, как добавить эти атрибуты в метод:

[Serializable]
public class Person
{
public int Id { get; set; }
public string Name { get; set; }
[NonSerialized]
private bool isDirty = false;
Objective 4.4: Serialize and deserialize data CHAPTER 4 313
[OnSerializing()]
internal void OnSerializingMethod(StreamingContext context)
{
Console.WriteLine(“OnSerializing.”);
}
[OnSerialized()]
internal void OnSerializedMethod(StreamingContext context)
{
Console.WriteLine(“OnSerialized.”);
}
[OnDeserializing()]
internal void OnDeserializingMethod(StreamingContext context)
{
Console.WriteLine(“OnDeserializing.”);
}
[OnDeserialized()]
internal void OnDeserializedMethod(StreamingContext context)
{
Console.WriteLine(“OnSerialized.”);
}
}

Вывод:

OnSerializing..
OnSerialized..
OnDeserializing..
OnSerialized..

Сериализованный объект может предоставлять конфиденциальные данные, чувствительные к безопасности. Каждый, у кого есть разрешения на десериализацию файла, может получить доступ к вашим конфиденциальным данным. Если у вас класс чувствительный, вы должны реализовать интерфейс ISerializable.

Использование DataContractSerializer

DataContract Serialization в основном используется с WCF.

Серийный анализатор данных используется WCF для сериализации ваших объектов в XML или JSON.
Основное различие заключается в том, что вместо DataContractAttribute вы используете SerializableAttribute.
Другим важным отличием является то, что члены не сериализуются по умолчанию. Вы должны явно отмечать их атрибутом DataMember.

Давайте рассмотрим пример использования контракта Data & DataContract Serialization.

[DataContract]
public class PersonDataContract
{
[DataMember]
public int Id { get; set; }
[DataMember]
public string Name { get; set; }
private bool isDirty = false;
}

Использование DataContract

PersonDataContract p = new PersonDataContract
{
Id = 1,
Name = “Steve Smith”
};
using (Stream stream = new FileStream(“data.xml”, FileMode.Create))
{
DataContractSerializer ser = new DataContractSerializer(typeof(PersonDataContract));
ser.WriteObject(stream, p);
}
using (Stream stream = new FileStream(“data.xml”, FileMode.Open))
{
DataContractSerializer ser = new DataContractSerializer(typeof(PersonDataContract));
PersonDataContract result = (PersonDataContract)ser.ReadObject(stream);
}

Использование JSON

JSON очень полезен при отправке небольших объемов данных между веб-сервером и клиентом с использованием асинхронного JavaScript и XML (AJAX).

[DataContract]
public class Person
{
[DataMember]
public int Id { get; set; }
[DataMember]
public string Name { get; set; }
}
Person p = new Person
{
Id = 1,
Name = “Steve Smith”
};
using (MemoryStream stream = new MemoryStream())
{
DataContractJsonSerializer ser = new DataContractJsonSerializer(typeof(Person));
ser.WriteObject(stream, p);
stream.Position = 0;
StreamReader streamReader = new StreamReader(stream);
Console.WriteLine(streamReader.ReadToEnd()); // Displays {“Id”:1,”Name”:”Steve Smith”}
stream.Position = 0;
Person result = (Person)ser.ReadObject(stream);
}

Источник: http://www.csharpstar.com/serialize-and-deserialize-data-csharp/