如何在文件中保存/恢复可序列化对象？

| 我有一个对象列表，需要将其保存在计算机中的某个位置。我已经阅读了一些论坛，并且知道该对象必须为“ 0”。但是，如果我能举个例子，那就太好了。例如，如果我有以下内容： 
[Serializable]
public class SomeClass
{
     public string someProperty { get; set; }
}

SomeClass object1 = new SomeClass { someProperty = \"someString\" };
但是，如何在计算机中的某个位置存储“ 2”，以后再取回？     
2020-01-07 7 条评论
分享

没有找到相关结果

    已邀请:

    庞协腿宛炯

    您可以使用以下内容： 
        /// <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;
    }
        
    2020-01-07 0 0
    分享

    粳饶瓢部

    我刚刚写了一篇关于将对象的数据保存到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包中获得。 
    /// <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\");
        
    2020-01-07 0 0
    分享

    盛虱

    您将需要序列化为某种东西：也就是说，选择二进制或xml（对于默认序列化器），或者编写自定义序列化代码以序列化为其他文本形式。 选择了该序列后，您的序列化（通常）将调用正在写入某种文件的Stream。 因此，对于您的代码，如果我使用的是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);
}
    注意：此代码尚未编译，更不用说运行了，可能会出现一些错误。同样，这假定完全开箱即用的序列化/反序列化。如果您需要自定义行为，则需要做其他工作。     
    2020-01-07 0 0
    分享

    秃拳割

    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.额外 您可以通过以下命令从NuGet下载Newtonsoft.Json 
    Install-Package Newtonsoft.Json
        
    2020-01-07 0 0
    分享

    笛驮型迸

    ** 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);
        }
    }
}
        
    2020-01-07 0 0
    分享

    屠创氓读叔

    您可以从Newtonsoft库使用JsonConvert。 要序列化对象并以json格式写入文件： 
    File.WriteAllText(filePath, JsonConvert.SerializeObject(obj));
    并将其反序列化为对象： 
    var obj = JsonConvert.DeserializeObject<ObjType>(File.ReadAllText(filePath));
        
    2020-01-07 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    或代码 OrCode.com 备案号：粤ICP备15020848号-1
    Escape time: 0.034340143203735