Come salvare / ripristinare l’object serializzabile su / da file?

Ho una lista di oggetti e ho bisogno di salvarla da qualche parte nel mio computer. Ho letto alcuni forum e so che l’object deve essere Serializable . Ma sarebbe bello se potessi avere un esempio. Ad esempio se ho il seguente:

 [Serializable] public class SomeClass { public string someProperty { get; set; } } SomeClass object1 = new SomeClass { someProperty = "someString" }; 

Ma come posso archiviare object1 da qualche parte nel mio computer e successivamente recuperarlo?

È ansible utilizzare il seguente:

  ///  /// Serializes an object. ///  ///  ///  ///  public void SerializeObject(T serializableObject, string fileName) { if (serializableObject == null) { return; } try { XmlDocument xmlDocument = new XmlDocument(); XmlSerializer serializer = new XmlSerializer(serializableObject.GetType()); using (MemoryStream stream = new MemoryStream()) { serializer.Serialize(stream, serializableObject); stream.Position = 0; xmlDocument.Load(stream); xmlDocument.Save(fileName); } } catch (Exception ex) { //Log exception here } } ///  /// Deserializes an xml file into an object list ///  ///  ///  ///  public T DeSerializeObject(string fileName) { if (string.IsNullOrEmpty(fileName)) { return default(T); } T objectOut = default(T); try { XmlDocument xmlDocument = new XmlDocument(); xmlDocument.Load(fileName); string xmlString = xmlDocument.OuterXml; using (StringReader read = new StringReader(xmlString)) { Type outType = typeof(T); XmlSerializer serializer = new XmlSerializer(outType); using (XmlReader reader = new XmlTextReader(read)) { objectOut = (T)serializer.Deserialize(reader); } } } catch (Exception ex) { //Log exception here } return objectOut; } 

Ho appena scritto un post sul blog sul salvataggio dei dati di un object su Binary, XML o Json . Hai ragione nel ritenere che devi decorare le tue classi con l’attributo [Serializable], ma solo se stai usando la serializzazione binaria. Potresti preferire l’uso della serializzazione XML o Json. Ecco le funzioni per farlo nei vari formati. Vedi il mio post sul blog per ulteriori dettagli.

Binario

 ///  /// Writes the given object instance to a binary file. /// Object type (and all child types) must be decorated with the [Serializable] attribute. /// To prevent a variable from being serialized, decorate it with the [NonSerialized] attribute; cannot be applied to properties. ///  /// The type of object being written to the binary file. /// The file path to write the object instance to. /// The object instance to write to the binary file. /// If false the file will be overwritten if it already exists. If true the contents will be appended to the file. public static void WriteToBinaryFile(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); } } ///  /// Reads an object instance from a binary file. ///  /// The type of object to read from the binary file. /// The file path to read the object instance from. /// Returns a new instance of the object read from the binary file. public static T ReadFromBinaryFile(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

Richiede l’assembly System.Xml da includere nel progetto.

 ///  /// Writes the given object instance to an XML file. /// Only Public properties and variables will be written to the file. These can be any type though, even other classs. /// If there are public properties/variables that you do not want written to the file, decorate them with the [XmlIgnore] attribute. /// Object type must have a parameterless constructor. ///  /// The type of object being written to the file. /// The file path to write the object instance to. /// The object instance to write to the file. /// If false the file will be overwritten if it already exists. If true the contents will be appended to the file. public static void WriteToXmlFile(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(); } } ///  /// Reads an object instance from an XML file. /// Object type must have a parameterless constructor. ///  /// The type of object to read from the file. /// The file path to read the object instance from. /// Returns a new instance of the object read from the XML file. public static T ReadFromXmlFile(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

È necessario includere un riferimento all’assembly Newtonsoft.Json, che può essere ottenuto dal pacchetto NuGet di Json.NET .

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

Esempio

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

Avrai bisogno di serializzare su qualcosa: vale a dire, pick binary o xml (per i serializzatori predefiniti) o scrivere codice di serializzazione personalizzato per serializzare in qualche altro modulo di testo.

Una volta scelto, la serializzazione (normalmente) chiamerà un stream che sta scrivendo su un tipo di file.

Quindi, con il tuo codice, se stavo usando la serializzazione XML:

 var path = @"C:\Test\myserializationtest.xml"; using(FileStream fs = new FileStream(path, FileMode.Create)) { XmlSerializer xSer = new XmlSerializer(typeof(SomeClass)); xSer.Serialize(fs, serializableObject); } 

Quindi, per deserializzare:

 using(FileStream fs = new FileStream(path, FileMode.Open)) //double check that... { XmlSerializer _xSer = new XmlSerializer(typeof(SomeClass)); var myObject = _xSer.Deserialize(fs); } 

NOTA: questo codice non è stato compilato, per non parlare dell’esecuzione, potrebbero esserci alcuni errori. Inoltre, questo assume la serializzazione / deserializzazione completamente out-of-the-box. Se hai bisogno di un comportamento personalizzato, dovrai svolgere un lavoro aggiuntivo.

1. Ripristina object da file

Da qui è ansible deserializzare un object dal file in due modi.

Soluzione 1: leggere il file in una stringa e deserializzare JSON in un tipo

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

Soluzione 2: deserializzare JSON direttamente da un file

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

2. Salva object su file

da qui puoi serializzare un object in un file in due modi.

Soluzione 1: serializzare JSON in una stringa e quindi scrivere una stringa in un file

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

Soluzione 2: serializza JSON direttamente in un file

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

3. Extra

È ansible scaricare Newtonsoft.Json da NuGet seguendo il comando

 Install-Package Newtonsoft.Json 

** 1. Converti la stringa json in base64string e scrivi o aggiungila al file binario. 2. Leggere base64string dal file binario e deserializzare usando BsonReader. **

  public static class BinaryJson { public static string SerializeToBase64String(this object obj) { JsonSerializer jsonSerializer = new JsonSerializer(); MemoryStream objBsonMemoryStream = new MemoryStream(); using (BsonWriter bsonWriterObject = new BsonWriter(objBsonMemoryStream)) { jsonSerializer.Serialize(bsonWriterObject, obj); return Convert.ToBase64String(objBsonMemoryStream.ToArray()); } //return Encoding.ASCII.GetString(objBsonMemoryStream.ToArray()); } public static T DeserializeToObject(this string base64String) { byte[] data = Convert.FromBase64String(base64String); MemoryStream ms = new MemoryStream(data); using (BsonReader reader = new BsonReader(ms)) { JsonSerializer serializer = new JsonSerializer(); return serializer.Deserialize(reader); } } }