c# - كيفية حفظ / استعادة الكائن القابل للتسلسل إلى / من الملف؟




serialization stream (5)

** 1. قم بتحويل سلسلة json إلى base64string واكتبها أو إلحاقها بالملف الثنائي. 2. قراءة base64string من ملف ثنائي وإلغاء تسلسل باستخدام 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);
        }
    }
}

لدي قائمة من الكائنات وأحتاج إلى حفظ ذلك في مكان ما في جهاز الكمبيوتر الخاص بي. لقد قرأت بعض المنتديات وأعرف أن الكائن يجب أن يكون Serializable . لكن سيكون من الرائع أن أحصل على مثال. على سبيل المثال ، إذا كان لدي ما يلي:

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

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

ولكن كيف يمكنني تخزين object1 في مكان ما في جهاز الكمبيوتر الخاص بي واستردادها في وقت لاحق؟


1. استعادة كائن من ملف

من Here يمكنك إلغاء تسلسل كائن من الملف في اتجاهين.

الحل 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. حفظ كائن إلى ملف

من here يمكنك تسلسل كائن إلى ملف في اتجاهين.

الحل -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

لقد كتبت للتو مشاركة مدونة حول حفظ بيانات الكائن إلى Binary أو XML أو Json . أنت على صواب أنك يجب أن تقوم بتزيين الطبقات الخاصة بك باستخدام السمة [Serializable] ، ولكن فقط إذا كنت تستخدم التسلسل الثنائي. قد تفضل استخدام التسلسل 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 Package .

/// <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");

ستحتاج إلى إجراء تسلسل إلى شيء ما: أي ، اختيار ثنائي ، أو 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);
}

ملاحظة: لم يتم تجميع هذا الكود ، ناهيك عن تشغيله ، قد يكون هناك بعض الأخطاء. أيضا ، هذا يفترض التسلسل / إلغاء التسلسل خارج مربع تماما. إذا كنت بحاجة إلى سلوك مخصص ، فستحتاج إلى القيام بعمل إضافي.


جرب هذا

You_command 1>output.log  2>&1

استخدامك لـ &> x.file يعمل في bash4. اسف على ذلك : (

هنا تأتي بعض النصائح الإضافية.

0 ، 1 ، 2 ... 9 هي واصفات الملفات في bash.

0 تعني stdin ، 1 تعني stdout ، 2 تعني stderror . 3 ~ 9 هو احتياطي لأي استخدام مؤقت آخر.

يمكن إعادة توجيه أي واصف للملف إلى واصف أو ملف آخر باستخدام المشغل > أو >> (إلحاقي).

الاستخدام: < file_descriptor >> < filename | & file_descriptor >

يرجى الرجوع إلى http://www.tldp.org/LDP/abs/html/io-redirection.html







c# serialization stream