CategorySerialize and deserialize data

DataContractSerializer

DataContractSerializer made its first appearance with release of WCF but can operate outside WCF.

DataContractSerializer can serialize types decorated with DataContract, MessageContract, Serializable attributes, types that implement IXmlSerialisable and all public types without Attributes.

During serialization Reference integrity is by default not preserved. You can preserve it by setting “IsReference = true” to DataContract attribute. Note that this approach my cause problems if DataContractSerializer is not serializer who will deserialize data.

[DataContract(IsReference = true)]

1	[DataContract(IsReference = true)]

You can also use OnSerializing, OnSerialized, OnDeserializing, OnDeserialized Attributes to fine-grain your serialization process.

This tutorial will explain how to serialize and deserialize types by decorating type with DataContract attribute.

First we use need to add reference to System.Runtime.Serialization. Secondly we decorate the type with DataContract Attribute, and inside type wee decorate fields and properties with DataMember Attribute. Then we instantiate DataContractSerializer instance and use its WriteObject and ReadObject methods to serialize/deserialize data.

Example of DataContractSerializer:

using System;
using System.Runtime.Serialization;
using System.IO;
using System.Xml.Linq;

namespace DataContractSerializerExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // Choose between types to serialize
            Employee employee = new Employee()
            {
                _employeeId = 1,
                employeeName = "JohnDoe",
                _employeeDepartment = new Department()
                {
                    _departmentId = 1,
                    _departmentName = "Sales"
                }
            };

            
            ClubActivity activity = new ClubActivity()
            {
                _employeeId = 1,
                employeeName = "JohnDoe",
                ActivityName = "Gym",
                _employeeDepartment = new Department()
                {
                    _departmentId = 1,
                    _departmentName = "Sales"
                }
            };

            // We will be reading data from the memory
            // so it is best to use Memory stream.
            MemoryStream memoryStream = new MemoryStream();

            //Lets start by Serializing data.
            // both ClubActivity and Employee classes are provided
            // as parameters so you can experiment 
            // in SerializeData Method
            Stream stream = SerializeData(employee, activity, memoryStream);
            
            DisplaySerializationResultInConsole(stream);
            //stream.Position = 0;

            //And now lets deserialize data
            Deserialize(stream);

            Console.ReadKey();
        }

        private static Stream SerializeData(Employee employee, ClubActivity activity, MemoryStream memoryStream)
        {
            // Note that we needed to supply Type information to constructor
            // Reason is that type and Assembly information are not serialized 
            DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(Employee));

            // WriteObject method is responsible for serialization itself
            dataContractSerializer.WriteObject(memoryStream, activity);

            // It is best to rewind stream to 0 position now
            // so consumer of of stream can consume it right away.
            memoryStream.Position = 0;

            //// Uncomment bottom line 
            //// to see the result of serialization
            //DisplaySerializationResultInConsole(memoryStream);

            // Stream is ready to be transmitted
            // So lets send it.
            return memoryStream;
        }

        private static void Deserialize(Stream stream)
        {
            // If you have serialized data by supplying 
            // Employee type to constructor, change 
            // type in next line

            // Lets start Deserialization process by instantiating DataContractSerializer
            DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(Employee));

            // ReadObject method is responsible for Deserialization
            object employeeObject = dataContractSerializer.ReadObject(stream);

            // As you can see Club activity object has been deserialized
            ClubActivity oldEmployee = employeeObject as ClubActivity;

            // Proof of Deserialization result:
            Console.WriteLine("Deserialization result: Employee id:{0}, Employee name: {1}, Department id: {2}, Department name: {3}, Club Activity: {4}", oldEmployee._employeeId, oldEmployee.employeeName, oldEmployee._employeeDepartment._departmentId, oldEmployee._employeeDepartment._departmentName, oldEmployee.ActivityName);

            // Uncomment this line 
            // if you have serialized Employee class
            //Console.WriteLine("Deserialization result: Employee id:{0}, Employee name: {1}, Department id: {2}, Department name: {3}", oldEmployee._employeeId, oldEmployee.employeeName, oldEmployee._employeeDepartment._departmentId, oldEmployee._employeeDepartment._departmentName);

        }

        private static void DisplaySerializationResultInConsole(Stream stream)
        {
            string streamResult= new StreamReader(stream).ReadToEnd();
            string readableXml = MoreReadableXml(streamResult);
            Console.WriteLine(readableXml);
            stream.Position = 0;
        }

        static string MoreReadableXml(string xml)
        {
            XDocument doc = XDocument.Parse(xml);
            return doc.ToString();
        }
    }

    [DataContract, KnownType(typeof(ClubActivity))]
    public class Employee 
    {
        [DataMember]
        public int _employeeId;

        [DataMember]
        public string employeeName { get; set; }

        [DataMember]
        public Department _employeeDepartment;
    }

    [DataContract]
    public class ClubActivity : Employee
    {
        [DataMember]
        public string ActivityName { get; set; }
    }

    [DataContract]
    public class Department
    {
        [DataMember]
        public int _departmentId;
        [DataMember]
        public string _departmentName;
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

using System;

using System.Runtime.Serialization;

using System.IO;

using System.Xml.Linq;

namespace DataContractSerializerExample

{

class Program

{

static void Main(string[] args)

{

// Choose between types to serialize

Employee employee = new Employee()

{

_employeeId = 1,

employeeName = "JohnDoe",

_employeeDepartment = new Department()

{

_departmentId = 1,

_departmentName = "Sales"

}

};

ClubActivity activity = new ClubActivity()

{

_employeeId = 1,

employeeName = "JohnDoe",

ActivityName = "Gym",

_employeeDepartment = new Department()

{

_departmentId = 1,

_departmentName = "Sales"

}

};

// We will be reading data from the memory

// so it is best to use Memory stream.

MemoryStream memoryStream = new MemoryStream();

//Lets start by Serializing data.

// both ClubActivity and Employee classes are provided

// as parameters so you can experiment

// in SerializeData Method

Stream stream = SerializeData(employee, activity, memoryStream);

DisplaySerializationResultInConsole(stream);

//stream.Position = 0;

//And now lets deserialize data

Deserialize(stream);

Console.ReadKey();

}

private static Stream SerializeData(Employee employee, ClubActivity activity, MemoryStream memoryStream)

{

// Note that we needed to supply Type information to constructor

// Reason is that type and Assembly information are not serialized

DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(Employee));

// WriteObject method is responsible for serialization itself

dataContractSerializer.WriteObject(memoryStream, activity);

// It is best to rewind stream to 0 position now

// so consumer of of stream can consume it right away.

memoryStream.Position = 0;

//// Uncomment bottom line

//// to see the result of serialization

//DisplaySerializationResultInConsole(memoryStream);

// Stream is ready to be transmitted

// So lets send it.

return memoryStream;

}

private static void Deserialize(Stream stream)

{

// If you have serialized data by supplying

// Employee type to constructor, change

// type in next line

// Lets start Deserialization process by instantiating DataContractSerializer

DataContractSerializer dataContractSerializer = new DataContractSerializer(typeof(Employee));

// ReadObject method is responsible for Deserialization

object employeeObject = dataContractSerializer.ReadObject(stream);

// As you can see Club activity object has been deserialized

ClubActivity oldEmployee = employeeObject as ClubActivity;

// Proof of Deserialization result:

Console.WriteLine("Deserialization result: Employee id:{0}, Employee name: {1}, Department id: {2}, Department name: {3}, Club Activity: {4}", oldEmployee._employeeId, oldEmployee.employeeName, oldEmployee._employeeDepartment._departmentId, oldEmployee._employeeDepartment._departmentName, oldEmployee.ActivityName);

// Uncomment this line

// if you have serialized Employee class

//Console.WriteLine("Deserialization result: Employee id:{0}, Employee name: {1}, Department id: {2}, Department name: {3}", oldEmployee._employeeId, oldEmployee.employeeName, oldEmployee._employeeDepartment._departmentId, oldEmployee._employeeDepartment._departmentName);

}

private static void DisplaySerializationResultInConsole(Stream stream)

{

string streamResult= new StreamReader(stream).ReadToEnd();

string readableXml = MoreReadableXml(streamResult);

Console.WriteLine(readableXml);

stream.Position = 0;

}

static string MoreReadableXml(string xml)

{

XDocument doc = XDocument.Parse(xml);

return doc.ToString();

}

[DataContract, KnownType(typeof(ClubActivity))]

public class Employee

{

[DataMember]

public int _employeeId;

[DataMember]

public string employeeName { get; set; }

[DataMember]

public Department _employeeDepartment;

}

[DataContract]

public class ClubActivity : Employee

{

[DataMember]

public string ActivityName { get; set; }

}

[DataContract]

public class Department

{

[DataMember]

public int _departmentId;

[DataMember]

public string _departmentName;

}

By using DataMember Attribute we can serialize automatic properties, because property itself will be serialized and not its backing field.

Because DataContractSerializer does not store type and assembly information we need to tell it which is the type we wish to serialize by specifying type in the DataContractSerializer constructor.

As no type or assembly information are preserved be sure to supply KnownType Attribute to your base class to be able to use inheritance properly.

Data Contract Serializer

You can download solution from this link.

To return to other serialization techniques return to this location.

Binary serialization

26/09/2016 / Darko / 0 Comments

Today’s topic is Binary serialization, if you wish to read more about serialization or other types of serialization please visit this link:

Binary serialization is type of serialization where type fidelity and reference integrity are preserved, meaning assembly information, private and public fields are being preserved as well as theirs memory locations. You would normally use binary serialization to preserve application state, store it to a backing store (storage medium) and use it later to run application on same computer or maybe multiple other computers.

Hearth of binary serialization is BinaryFormatter class and its Serialize and Deserialize methods. Serialize and Deserialize methods take two parameters stream and object graph and serialize or deserialize object accordingly. Result of serialization are unreadable to human eye but you can read some information:

BinaryFormatter serialization result

As you can see type and field information are preserved.

If you wish serialized data in more readable way you can use SoapFormatter. Note that SoapFormatter is obsolete so use it only for debugging and testing purposes.

SoapFormatter serialization result

To mark a type serializable use Serializable attribute to decorate type. Serializable attribute is not inherited so if you wish to serialize both base and derived class decorate both of them with serializable attribute. Other approach would be to implement ISerializable interface.

If you wish not to serialize filed add NonSerialized attribute.

You can serialize null types, but you can not serialize or deserialize null streams.

Properties are not serialized but their private fields are. Do not serialize auto implemented properties because you cannot guarantee that theirs private fields will have the same name on the other machines as they do on yours.

If we wish more control during Serialization/Deserialization processes we can use attributes from System.Runtime.Serialization and apply them to the methods.
Attributes we can use for methods during serialization:
OnSerializingAttribute – use this attribute to prepare data before deserializing . For example encrypt password field or change distance from miles to kilometers.
OnSerializedAttribute – restores type to a status it was before applying OnSerializingAttribute.

Attributes we can use for methods during serialization:
OnDeserializingAttribute – because serialization cannot use constructor, use this attribute for method that will simulate constructor, and maybe set fields to default values.
OnDeserializedAttribute – use this attribute to manually set value of the fields just after serialization process has finished.

Example for Binary serialization.

We will try to serialize data from Employee class:

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

namespace BinarySerialization
{
    class Program
    {
        static void Main(string[] args)
        {
            // Data we wish to serialize
            Employee employee = new Employee()
            {
                _employeeId = 1,
                _employeeName = "JohnDoe",
                _employeeDepartment = new Department()
                {
                    _departmentId = 1,
                    _departmentName = "Sales"
                }
            };

            // We will be reading data from the memory
            // so it is best to use Memory stream.
            MemoryStream memoryStream = new MemoryStream();

            //Lets start by Serializing data.
            Stream stream = SerializeData(employee, memoryStream);

            //Console.WriteLine(new StreamReader(memoryStream).ReadToEnd());
            DisplaySerializationResultInConsole(stream);
            //stream.Position = 0;

            //And now lets deserialize data
            Deserialize(stream);

            Console.ReadKey();
        }

        private static Stream SerializeData(Employee employee, MemoryStream memoryStream)
        {
            // To view result in more readable way change
            // BinaryFormatter type to SoapFormatter

            //// Lets  start by instatiating BinaryFormatter
            BinaryFormatter binaryFormatter = new BinaryFormatter();

            // And let BinaryFormatter.Serialize method do its job
            binaryFormatter.Serialize(memoryStream, employee);

            // It is best to rewind stream to 0 position now
            // so consumer of of stream can consume it right away.
            memoryStream.Position = 0;

            //// Uncomment bottom line 
            //// to see the result of serialization
            //DisplaySerializationResultInConsole(memoryStream);

            // Stream is ready to be transmitted
            // So lets send it.
            return memoryStream;
        }
        
        private static void Deserialize(Stream stream)
        {
            // If you have serialized data by using SoapFormatter
            // change type of binaryFormatter variable to SoapFormatter

            // Lets start Deserialization process by instantiating BinaryFormatter
            BinaryFormatter binaryFormatter = new BinaryFormatter();

            // BinaryFormatter.Deserialize return object type
            object employeeObject = binaryFormatter.Deserialize(stream);

            // As you can see Employee object has been deserialized
            Employee oldEmployee = employeeObject as Employee;

            // Proof of Deserialization result:
            Console.WriteLine("Deserialization result: Employee id:{0}, Employee name: {1}, Department id: {2}, Department name: {3}", oldEmployee._employeeId, oldEmployee._employeeName, oldEmployee._employeeDepartment._departmentId, oldEmployee._employeeDepartment._departmentName);

        }

        private static void DisplaySerializationResultInConsole(Stream stream)
        {
            Console.WriteLine(new StreamReader(stream).ReadToEnd());
            stream.Position = 0;
        }
    }

    [Serializable]
    public class Employee
    {
        public int _employeeId;
        public string _employeeName;
        public Department _employeeDepartment;
    }

    [Serializable]
    public class Department
    {
        public int _departmentId;
        public string _departmentName;
    }
}

100

101

102

103

104

105

106

using System;

using System.IO;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.Runtime.Serialization.Formatters.Soap;

namespace BinarySerialization

{

class Program

{

static void Main(string[] args)

{

// Data we wish to serialize

Employee employee = new Employee()

{

_employeeId = 1,

_employeeName = "JohnDoe",

_employeeDepartment = new Department()

{

_departmentId = 1,

_departmentName = "Sales"

}

};

// We will be reading data from the memory

// so it is best to use Memory stream.

MemoryStream memoryStream = new MemoryStream();

//Lets start by Serializing data.

Stream stream = SerializeData(employee, memoryStream);

//Console.WriteLine(new StreamReader(memoryStream).ReadToEnd());

DisplaySerializationResultInConsole(stream);

//stream.Position = 0;

//And now lets deserialize data

Deserialize(stream);

Console.ReadKey();

}

private static Stream SerializeData(Employee employee, MemoryStream memoryStream)

{

// To view result in more readable way change

// BinaryFormatter type to SoapFormatter

//// Lets start by instatiating BinaryFormatter

BinaryFormatter binaryFormatter = new BinaryFormatter();

// And let BinaryFormatter.Serialize method do its job

binaryFormatter.Serialize(memoryStream, employee);

// It is best to rewind stream to 0 position now

// so consumer of of stream can consume it right away.

memoryStream.Position = 0;

//// Uncomment bottom line

//// to see the result of serialization

//DisplaySerializationResultInConsole(memoryStream);

// Stream is ready to be transmitted

// So lets send it.

return memoryStream;

}

private static void Deserialize(Stream stream)

{

// If you have serialized data by using SoapFormatter

// change type of binaryFormatter variable to SoapFormatter

// Lets start Deserialization process by instantiating BinaryFormatter

BinaryFormatter binaryFormatter = new BinaryFormatter();

// BinaryFormatter.Deserialize return object type

object employeeObject = binaryFormatter.Deserialize(stream);

// As you can see Employee object has been deserialized

Employee oldEmployee = employeeObject as Employee;

// Proof of Deserialization result:

Console.WriteLine("Deserialization result: Employee id:{0}, Employee name: {1}, Department id: {2}, Department name: {3}", oldEmployee._employeeId, oldEmployee._employeeName, oldEmployee._employeeDepartment._departmentId, oldEmployee._employeeDepartment._departmentName);

}

private static void DisplaySerializationResultInConsole(Stream stream)

{

Console.WriteLine(new StreamReader(stream).ReadToEnd());

stream.Position = 0;

}

[Serializable]

public class Employee

{

public int _employeeId;

public string _employeeName;

public Department _employeeDepartment;

}

[Serializable]

public class Department

{

public int _departmentId;

public string _departmentName;

}

Download link for entire solution is here.

Serialization and Deserialization

22/09/2016 / Darko / 0 Comments

Serialization is the process of transforming an object or object graph
into a stream of bytes or text. Similarly, deserialization is the process of transforming bytes into an object or object graph.

Object graph: In computer science, in an object-oriented program, groups of objects form a network through their relationships with each other—either through a direct reference to another object or through a chain of intermediate references. These groups of objects are referred to as object graphs.

So, object graph can be a single List of string, entire class or even state of application.

Usage of serialization can wary, weather you want to communicate between two applications on one PC, save state of an Application on your local hard-drive or maybe in cloud… possibilities are endless.

What can I serialize?

You cannot serialize methods or delegates, but you can serialize fields and properties. That is why we can use DTO models (Data transferable models). DTO models are classes with properties that represent data that we want to represent. You have seen some examples so far, like Employee class.

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public int YearsEmployed { get; set; }
    public double Salary { get; set; }
    public Department Department {get; set;}
}

public class Employee

{

public int Id { get; set; }

public string Name { get; set; }

public int Age { get; set; }

public int YearsEmployed { get; set; }

public double Salary { get; set; }

public Department Department {get; set;}

}

To make this class more readable you could just add DTO suffix after Employee and everybody would know that this is an DTO class.

We will inspect how to serialize and deserialize data by using:

Binary serialization,
Custom serialization,
XML Serializer,
JSON Serializer,
Data Contract Serializer

Among these XML Serializer and JSON Serializer are the most common ones but as we progress between each one of them you will see that other serialization mechanisms have their usage.

Theme by Anders Noren — Up ↑

Language

Recent Posts

Archives

Categories

CategorySerialize and deserialize data

DataContractSerializer

Example of DataContractSerializer:

Binary serialization

Example for Binary serialization.

Serialization and Deserialization

What can I serialize?

Language

Recent Posts

Archives

Categories

CategorySerialize and deserialize data

DataContractSerializer

Example of DataContractSerializer:

Binary serialization

Example for Binary serialization.

﻿Serialization and Deserialization

What can I serialize?

Serialization and Deserialization