Sérialisation C#

L'article suivant fournit un aperçu de la sérialisation C#. Le processus par lequel l'instance d'objet est convertie en flux de données est appelé sérialisation et l'état de l'instance d'objet est converti en flux de données car il peut être transporté sur différents réseaux conçus pour être conservés dans un emplacement de stockage. Cela constitue un avantage de la sérialisation pour transmettre le flux de données converti sur différents réseaux dans un format compatible sur plusieurs plates-formes et enregistre les données de flux converties sur un support de stockage dans un état d'objet persistant ou non persistant afin que la même copie puisse être créé plus tard.

Étapes de l'objet de sérialisation C#

Vous trouverez ci-dessous les étapes de l'objet de sérialisation C# :

• Un objet flux est créé.
• Un objet BinaryFormatter est créé.
• La méthode Serialize( ) est appelée.

Fonctionnement de la sérialisation C#

• Chaque fois que nous travaillons avec des applications, il est nécessaire de stocker les données sur un support persistant ou non persistant afin que les mêmes données puissent être récupérées ultérieurement. Ceci peut être réalisé en utilisant le concept de sérialisation.
• Le processus de conversion d'une instance de l'objet en un flux d'octets déplaçant l'état de l'objet dans la mémoire ou la base de données du fichier est appelé sérialisation.
• La sérialisation est essentielle pour transmettre l'objet à travers le réseau vers plusieurs plateformes dans un format compatible.
• Un clone d'un objet peut également être créé à l'aide de la sérialisation.
• L'espace de noms Runtime.Serialization doit être inclus dans le programme pour pouvoir utiliser la sérialisation en C#.
• L'attribut [ Seriallessly ] est utilisé pour rendre une classe Serialisable en C#.

Un exemple de classe pour démontrer la classe [Sérialisable] :

Code :

[Serializable]
public class Check
{
public int code;
public string name;
}

• De même, si nous voulons rendre des membres de la classe non sérialisables, nous pouvons utiliser l'attribut [ NonSerialized() ].

Considérez l'exemple de classe ci-dessous pour démontrer l'attribut [ NonSerialized() ] :

Code :

[Serializable]
public class Check
{
public int code;
public string name;
[NonSerialized()]
Public double price;
}

• Les types de sérialisation suivants sont pris en charge par C#.

Vous trouverez ci-dessous les types de sérialisation pris en charge par C# :

1. Sérialisation binaire

• La plus rapide de toutes les techniques de sérialisation est la sérialisation binaire.
• Un objet peut être sérialisé en un flux binaire à l'aide de la sérialisation binaire.
• L'identité de l'objet est préservée tandis que l'objet est sérialisé dans un flux de sortie à l'aide de la sérialisation binaire.
• Système. Durée d'exécution. Sérialisation. Formateurs. L'espace de noms binaire doit être inclus dans le programme pour pouvoir utiliser la sérialisation binaire.

2. Sérialisation SOAP

• Simple Object Access Protocol est l'abréviation de SOAP.
• Nous utilisons la sérialisation Simple Object Access Protocol si nous devons transférer des objets d'une application à une autre qui sont constitués d'architectures hétérogènes.
• La portabilité est le principal avantage de l'utilisation de la sérialisation du protocole d'accès aux objets simples.
• Un objet peut être sérialisé sous la forme de Simple Object Access Protocol à l'aide de la sérialisation Simple Object Access Protocol.
• Système. Durée d'exécution. Sérialisation. Formateurs. L'espace de noms Soap doit être inclus dans le programme pour utiliser la sérialisation Simple Object Access Protocol.

3. Sérialisation XML

• Les membres publics de l'instance d'une classe peuvent être sérialisés dans un flux XML à l'aide de la sérialisation XML.
• La vitesse de sérialisation XML est très lente par rapport à la vitesse de sérialisation binaire.
• La prise en charge multiplateforme est assurée grâce à la sérialisation XML.
• La sérialisation XML est basée sur le texte.
• La sérialisation XML est facilement lisible.
• La sérialisation XML est facilement modifiable.
• Une propriété peut être définie sur XmlAttribute pour sérialiser la propriété à l'aide de la sérialisation XML.

Considérez le code ci-dessous pour démontrer l'utilisation de XmlAttribute :

Code :

[XmlAttribute("Name")]
public string Name
{
get
{
return Name;
}
set
{
Name = val;
}
}

• Nous utilisons XmlSerializer pour sérialiser un objet à l'aide de la sérialisation XML.

Considérez le code ci-dessous pour démontrer l'utilisation de XmlSerializer :

Code :

XmlSerializer Serializer = new XmlSerializer(typeof(Prod));
using (TextWriter Writer = new StreamWriter(@"C:\Prod.xml"))
{
xmlSerializer.Serialize(Writer, prodObject);
}

4. Sérialisation personnalisée

• Afin de contrôler la sérialisation et la désérialisation d'un type d'instance, nous utilisons la sérialisation personnalisée.
• La sérialisation personnalisée peut être implémentée par l'implémentation de l'interface ISerialalisable.
• La méthode GetObjectData() est déclarée par l'interface ISerializing.

Considérez le code ci-dessous pour démontrer la sérialisation personnalisée en implémentant l'interface ISerialalisable :

Code :

[Serializable]
public class Prod : ISerializable
{
public void GetObjectData(SerializationInfo information, StreamingContext cont)
{
//Usual code
}
}

Exemple

Vous trouverez ci-dessous un exemple de sérialisation C# :

Programme C# pour démontrer le concept de sérialisation.

Code :

using System;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
//a namespace called demo is created
namespace Demo
{
//Serializable attribute is declared
[Serializable]
//a class check is defined which will be used for serialization
class Check
{
public int identity;
public String nam;
static void Main(string[] args)
{
//an object of the check class is created to serialize it to the file Example.txt
Check ob = new Check();
ob.identity = 10;
ob.nam = "Shobha";
//a file stream is created
IFormatter format = new BinaryFormatter();
Stream stream1 = new FileStream(@"E:\Example.txt",FileMode.Create,FileAccess.Write);
//serialization of the object of the class check is done
format.Serialize(stream1, ob);
stream1.Close();
//a file stream is created
stream1 = new FileStream(@"E:\Example.txt",FileMode.Open,FileAccess.Read);
//the object of the class check is deserialized
Check ob1 = (Check)format.Deserialize(stream1);
//the data is written to the console
Console.WriteLine(ob1.identity);
Console.WriteLine(ob1.nam);
Console.ReadKey();
}
}
}

Output:

In the above program, a namespace called demo is defined. Then a Serializable attribute is defined. A class check is defined to demonstrate the concept of serialization using this class. Two properties identity and nam are defined in the class to which the values 10 and Shobha are assigned respectively. Then an object of the check class is created to serialize it to the file Example.txt. Then a formatter class is defined to convert the object of the class check to a binary stream.

Then a file stream object is created to open the file Example.txt in write mode to write the values of the properties identity and nam into it. Then serialize method is used to transfer the binary data into the text file. Finally, We use deserialize method to deserialize the contents of the text file Example.txt and the data is written to the console as shown in the output snapshot above.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!