Comment sauvegarder/restaurer la sérialisation de l'objet vers/à partir d'un fichier?

J'ai juste écrit un blog sur l'enregistrement de données d'un objet Binaire, XML ou Json. Il est exact que vous devez décorer vos classes avec l'attribut [Serializable], mais seulement si vous êtes en utilisant la sérialisation Binaire. Vous préférerez peut-être utiliser des fichiers XML ou Json de sérialisation. Voici les fonctions de le faire dans les différents formats. Voir mon blog pour plus de détails.

Binaire

///<summary>
///Writes the given object instance to a binary file.
///<para>Object type (and all child types) must be decorated with the [Serializable] attribute.</para>
///<para>To prevent a variable from being serialized, decorate it with the [NonSerialized] attribute; cannot be applied to properties.</para>
///</summary>
///<typeparam name="T">The type of object being written to the binary file.</typeparam>
///<param name="filePath">The file path to write the object instance to.</param>
///<param name="objectToWrite">The object instance to write to the binary file.</param>
///<param name="append">If false the file will be overwritten if it already exists. If true the contents will be appended to the file.</param>
public static void WriteToBinaryFile<T>(string filePath, T objectToWrite, bool append = false)
{
using (Stream stream = File.Open(filePath, append ? FileMode.Append : FileMode.Create))
{
var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
binaryFormatter.Serialize(stream, objectToWrite);
}
}
///<summary>
///Reads an object instance from a binary file.
///</summary>
///<typeparam name="T">The type of object to read from the binary file.</typeparam>
///<param name="filePath">The file path to read the object instance from.</param>
///<returns>Returns a new instance of the object read from the binary file.</returns>
public static T ReadFromBinaryFile<T>(string filePath)
{
using (Stream stream = File.Open(filePath, FileMode.Open))
{
var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
return (T)binaryFormatter.Deserialize(stream);
}
}

XML

Nécessite l'System.Xml de l'assemblée pour être inclus dans votre projet.

///<summary>
///Writes the given object instance to an XML file.
///<para>Only Public properties and variables will be written to the file. These can be any type though, even other classes.</para>
///<para>If there are public properties/variables that you do not want written to the file, decorate them with the [XmlIgnore] attribute.</para>
///<para>Object type must have a parameterless constructor.</para>
///</summary>
///<typeparam name="T">The type of object being written to the file.</typeparam>
///<param name="filePath">The file path to write the object instance to.</param>
///<param name="objectToWrite">The object instance to write to the file.</param>
///<param name="append">If false the file will be overwritten if it already exists. If true the contents will be appended to the file.</param>
public static void WriteToXmlFile<T>(string filePath, T objectToWrite, bool append = false) where T : new()
{
TextWriter writer = null;
try
{
var serializer = new XmlSerializer(typeof(T));
writer = new StreamWriter(filePath, append);
serializer.Serialize(writer, objectToWrite);
}
finally
{
if (writer != null)
writer.Close();
}
}
///<summary>
///Reads an object instance from an XML file.
///<para>Object type must have a parameterless constructor.</para>
///</summary>
///<typeparam name="T">The type of object to read from the file.</typeparam>
///<param name="filePath">The file path to read the object instance from.</param>
///<returns>Returns a new instance of the object read from the XML file.</returns>
public static T ReadFromXmlFile<T>(string filePath) where T : new()
{
TextReader reader = null;
try
{
var serializer = new XmlSerializer(typeof(T));
reader = new StreamReader(filePath);
return (T)serializer.Deserialize(reader);
}
finally
{
if (reader != null)
reader.Close();
}
}

Json

Vous devez inclure une référence à Newtonsoft.Json de l'assemblée, qui peut être obtenu à partir de la Json.NET Package NuGet.

///<summary>
///Writes the given object instance to a Json file.
///<para>Object type must have a parameterless constructor.</para>
///<para>Only Public properties and variables will be written to the file. These can be any type though, even other classes.</para>
///<para>If there are public properties/variables that you do not want written to the file, decorate them with the [JsonIgnore] attribute.</para>
///</summary>
///<typeparam name="T">The type of object being written to the file.</typeparam>
///<param name="filePath">The file path to write the object instance to.</param>
///<param name="objectToWrite">The object instance to write to the file.</param>
///<param name="append">If false the file will be overwritten if it already exists. If true the contents will be appended to the file.</param>
public static void WriteToJsonFile<T>(string filePath, T objectToWrite, bool append = false) where T : new()
{
TextWriter writer = null;
try
{
var contentsToWriteToFile = JsonConvert.SerializeObject(objectToWrite);
writer = new StreamWriter(filePath, append);
writer.Write(contentsToWriteToFile);
}
finally
{
if (writer != null)
writer.Close();
}
}
///<summary>
///Reads an object instance from an Json file.
///<para>Object type must have a parameterless constructor.</para>
///</summary>
///<typeparam name="T">The type of object to read from the file.</typeparam>
///<param name="filePath">The file path to read the object instance from.</param>
///<returns>Returns a new instance of the object read from the Json file.</returns>
public static T ReadFromJsonFile<T>(string filePath) where T : new()
{
TextReader reader = null;
try
{
reader = new StreamReader(filePath);
var fileContents = reader.ReadToEnd();
return JsonConvert.DeserializeObject<T>(fileContents);
}
finally
{
if (reader != null)
reader.Close();
}
}

Exemple

//Write the contents of the variable someClass to a file.
WriteToBinaryFile<SomeClass>("C:\someClass.txt", object1);
//Read the file contents back into a variable.
SomeClass object1= ReadFromBinaryFile<SomeClass>("C:\someClass.txt");

1. Restaurer L'Objet À Partir D'Un Fichier

De Ici vous pouvez désérialiser un objet à partir d'un fichier dans les deux sens.

Solution 1: Lire un fichier dans une chaîne et désérialiser JSON à un type

string json = File.ReadAllText(@"c:\myObj.json");
MyObject myObj = JsonConvert.DeserializeObject<MyObject>(json);

Solution 2: Désérialiser JSON directement à partir d'un fichier

using (StreamReader file = File.OpenText(@"c:\myObj.json"))
{
JsonSerializer serializer = new JsonSerializer();
MyObject myObj2 = (MyObject)serializer.Deserialize(file, typeof(MyObject));
}

2. Enregistrer L'Objet De Fichier

de ici vous pouvez sérialiser un objet à déposer dans les deux sens.

Solution 1: Serialize JSON à une chaîne, puis écrire chaîne dans un fichier

string json = JsonConvert.SerializeObject(myObj);
File.WriteAllText(@"c:\myObj.json", json);

Solution 2: Serialize JSON directement à un fichier

using (StreamWriter file = File.CreateText(@"c:\myObj.json"))
{
JsonSerializer serializer = new JsonSerializer();
serializer.Serialize(file, myObj);
}

3. Extra

Vous pouvez télécharger Newtonsoft.Json de NuGet par la commande suivante

Install-Package Newtonsoft.Json