Як зберегти / відновити серіалізуваний об'єкт у / з файлу?

94

У мене є список об’єктів, і мені його потрібно зберегти десь на моєму комп’ютері. Я читав кілька форумів і знаю, що об'єктом має бути Serializable. Але було б непогано, якби я міг отримати приклад. Наприклад, якщо я маю таке:

[Serializable]
public class SomeClass
{
     public string someProperty { get; set; }
}

SomeClass object1 = new SomeClass { someProperty = "someString" };

Але як я можу зберігати object1десь у своєму комп’ютері, а потім отримувати?

c#  serialization  stream 
— Тоно Нам
джерело
3
Ось підручник, який показує, як серіалізувати файл switchchonthecode.com/tutorials/…
— Брук,

Відповіді:

142

Ви можете використовувати наступне:

    /// <summary>
    /// Serializes an object.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="serializableObject"></param>
    /// <param name="fileName"></param>
    public void SerializeObject<T>(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
        }
    }


    /// <summary>
    /// Deserializes an xml file into an object list
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="fileName"></param>
    /// <returns></returns>
    public T DeSerializeObject<T>(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;
    }
— Алекс Мендес
джерело
1
Приємно! Хоча string attributeXml = string.Empty;in DeSerializeObjectніколи не використовується;)
— Джимбо,
3
Не потрібно викликати метод close на зчитувач у вашому використовуваному блоці. Dispose () є неявним і відбуватиметься, навіть якщо в блоці буде викликано виняток перед явним Close (). Дуже корисний блок коду.
— S. Brentson
2
Як зберегти список об'єктів, використовуючи цю функцію, я використав її, але вона зберігає лише останній об'єкт у моєму списку
— Decoder94
1
Цей метод не збереже внутрішні або приватні поля, ви можете використовувати це: github.com/mrbm2007/ObjectSaver
— mrbm
152

Я щойно написав допис у блозі про збереження даних об’єкта у бінарному файлі, XML або Json . Ви маєте рацію, що ви повинні прикрашати свої класи атрибутом [Серіалізувати], але лише якщо ви використовуєте двійкову серіалізацію. Можливо, ви віддасте перевагу використовувати серіалізацію XML або Json. Ось функції, що дозволяють це робити у різних форматах. Докладніше див. У моєму повідомленні в блозі.

Двійкові

/// <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

Потрібна збірка System.Xml, яка повинна бути включена у ваш проект.

/// <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();
    }
}

Джсон

Ви повинні включити посилання на збірку Newtonsoft.Json, яке можна отримати з пакета Json.NET 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();
    }
}

Приклад

// 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");
— смертельний пес
джерело
2
Мені подобається ваш двійковий код серіалізації. Але на WriteToBinaryFile, чому ви коли-небудь захочете додати файл? Здається, ви хотіли б створити новий файл у всіх випадках. Інакше була б ціла купа додаткової інформації про десериалізацію.
— громадський бездротовий зв'язок
1
@publicwireless Так, ти, мабуть, маєш рацію. Тоді я над цим не надто замислювався; Я просто хотів, щоб підписи 3-х функцій збігалися: P
— deadlydog
за допомогою методу append, серіалізуючи багато об’єктів в одному файлі, як їх десеріалізувати? як мені шукати в потоці?
— Джон Деметріу,
1
Будь-ласка, додайте коментар до бінарного серіалізатора, який повідомляє людям, що на отриманих даних буде проставлено сильне ім'я збірки та зміни до версій цього без додавання перенаправляючих прив'язок або запуску в середовищах, які не поважають зазначені прив'язки (наприклад, PowerShell). fail
— zaitsman
1
@JohnDemetriou Якщо ви зберігаєте кілька файлів у файлі, я б рекомендував обернути об'єкти у якусь форму контекстного об'єкта та серіалізувати цей об'єкт (нехай менеджер об'єктів проаналізує потрібні вам частини). Якщо ви намагаєтеся зберегти більше даних, ніж ви можете зберегти в пам’яті, можливо, ви захочете перейти до сховища об’єктів (бази даних об’єктів) замість файлу.
— Тезра
30

Вам потрібно буде серіалізувати щось: тобто вибрати двійковий файл або xml (для серіалізаторів за замовчуванням) або написати власний код серіалізації для серіалізації в якусь іншу текстову форму.

Після того, як ви вибрали це, ваша серіалізація (як правило) викликає потік, який пише в якийсь файл.

Отже, з вашим кодом, якщо я використовував серіалізацію 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);
}

Потім для десериалізації:

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

    var myObject = _xSer.Deserialize(fs);
}

ПРИМІТКА: Цей код не скомпільований, не кажучи вже про те, що може бути деякі помилки. Крім того, це передбачає повністю нестандартну серіалізацію / десеріалізацію. Якщо вам потрібна власна поведінка, вам доведеться виконати додаткову роботу.

— АлленГ
джерело
10

1. Відновити об’єкт із файлу

Від Тут ви можете десеріалізациі об'єкта з файлу в два шляхи.

Рішення-1: Прочитайте файл у рядок та десеріалізуйте JSON до типу

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

Рішення-2: Десеріалізуйте JSON безпосередньо з файлу

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

2. Зберегти об’єкт у файлі

від тут ви можете серіалізовать об'єкт в файл в два шляхи.

Рішення-1: Серіалізуйте JSON у рядок, а потім запишіть рядок у файл

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

Рішення-2: Серіалізуйте JSON безпосередньо у файл

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

3. Додаткові

Ви можете завантажити Newtonsoft.Json з NuGet, виконавши наступну команду

Install-Package Newtonsoft.Json
— Емдадул Савон
джерело
1

** 1. Перетворіть рядок json в base64string і напишіть або додайте його до двійкового файлу. 2. Прочитайте рядок base64 із двійкового файлу та десеріалізуйте за допомогою 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<T>(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<T>(reader);
        }
    }
}
— гість
джерело
0

Ви можете використовувати JsonConvert з бібліотеки Newtonsoft. Щоб серіалізувати об'єкт і записати у файл у форматі json:

File.WriteAllText(filePath, JsonConvert.SerializeObject(obj));

І щоб десеріалізувати його назад в об’єкт:

var obj = JsonConvert.DeserializeObject<ObjType>(File.ReadAllText(filePath));
— озанмут
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.