C#序列化

最新推荐文章于 2023-10-08 16:02:34 发布
最新推荐文章于 2023-10-08 16:02:34 发布
阅读量353 收藏
点赞数
分类专栏： C#个人库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43765520/article/details/111612163
版权

文章目录

C# 序列化

二进制

/// <summary>
/// 二进制序列化保存至
/// </summary>
/// <param name="data">需要序列化的数据</param>
/// <param name="pathName">序列化文件路径名字</param>
/// <typeparam name="T">序列化数据类型</typeparam>
public static void BinarySaveTo<T>(T data, string pathName)
{
    FileStream fileStream = new FileStream(pathName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
    BinaryFormatter binaryFormatter = new BinaryFormatter();
    binaryFormatter.Serialize(fileStream, data);
    fileStream.Close();
}

/// <summary>
/// 从路径读取二进制文件反序列化为对象
/// </summary>
/// <param name="pathName">需要反序列化的路径名字</param>
/// <typeparam name="T">反序列化数据类型</typeparam>
/// <returns>反序列化对象</returns>
public static T BinaryReadOf<T>(string pathName)
{
    FileStream fileStream = new FileStream(pathName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
    BinaryFormatter binaryFormatter = new BinaryFormatter();
    T data = (T) binaryFormatter.Deserialize(fileStream);
    fileStream.Close();
    return data;
}

/// <summary>
/// 二进制序列化
/// </summary>
/// <param name="data">需要序列化的数据</param>
/// <typeparam name="T">序列化类型</typeparam>
/// <returns>序列化数组</returns>
public static byte[] BinarySerialize<T>(T data)
{
    MemoryStream memoryStream = new MemoryStream();
    BinaryFormatter binaryFormatter = new BinaryFormatter();
    binaryFormatter.Serialize(memoryStream, data);
    byte[] serializeData = memoryStream.ToArray();
    memoryStream.Close();
    return serializeData;
}

/// <summary>
/// 二进制反序列化
/// </summary>
/// <param name="serializeData">需要反序列化的数据</param>
/// <typeparam name="T">反序列化类型</typeparam>
/// <returns>反序列化对象</returns>
public static T BinaryDeserialize<T>(byte[] serializeData)
{
    MemoryStream memoryStream = new MemoryStream(serializeData);
    BinaryFormatter binaryFormatter = new BinaryFormatter();
    T data = (T) binaryFormatter.Deserialize(memoryStream);
    memoryStream.Close();
    return data;
}

Xml

/// <summary>
/// Xml序列化保存至
/// </summary>
/// <param name="data">需要序列化的数据</param>
/// <param name="pathName">序列化文件路径名字</param>
/// <typeparam name="T">序列化数据类型</typeparam>
public static void XmlSaveTo<T>(T data, string pathName)
{
    FileStream fileStream = new FileStream(pathName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
    xmlSerializer.Serialize(fileStream, data);
    fileStream.Close();
}

/// <summary>
/// 从路径读取Xml文件反序列化为对象
/// </summary>
/// <param name="pathName">需要反序列化的路径名字</param>
/// <typeparam name="T">反序列化数据类型</typeparam>
/// <returns>反序列化对象</returns>
public static T XmlReadOf<T>(string pathName)
{
    FileStream fileStream = new FileStream(pathName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
    T data = (T)xmlSerializer.Deserialize(fileStream);
    fileStream.Close();
    return data;
}

/// <summary>
/// Xml序列化
/// </summary>
/// <param name="data">需要序列化的数据</param>
/// <typeparam name="T">序列化类型</typeparam>
/// <returns>序列化数组</returns>
public static byte[] XmlSerialize<T>(T data)
{
    MemoryStream memoryStream = new MemoryStream();
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
    xmlSerializer.Serialize(memoryStream, data);
    byte[] serializeData = memoryStream.ToArray();
    memoryStream.Close();
    return serializeData;
}

/// <summary>
/// Xml反序列化
/// </summary>
/// <param name="serializeData">需要反序列化的数据</param>
/// <typeparam name="T">反序列化类型</typeparam>
/// <returns>反序列化对象</returns>
public static T XmlDeserialize<T>(byte[] serializeData)
{
    MemoryStream memoryStream = new MemoryStream(serializeData);
    XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
    T data = (T)xmlSerializer.Deserialize(memoryStream);
    memoryStream.Close();
    return data;
}

Json

/// <summary>
/// Json序列化保存至
/// </summary>
/// <param name="data">需要序列化的数据</param>
/// <param name="pathName">序列化文件路径名字</param>
/// <typeparam name="T">序列化数据类型</typeparam>
public static void JsonSaveTo<T>(T data, string pathName)
{
    FileStream fileStream = new FileStream(pathName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
    DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
    dataContractJsonSerializer.WriteObject(fileStream, data);
    fileStream.Close();
}

/// <summary>
/// 从路径读取Json文件反序列化为对象
/// </summary>
/// <param name="pathName">需要反序列化的路径名字</param>
/// <typeparam name="T">反序列化数据类型</typeparam>
/// <returns>反序列化对象</returns>
public static T JsonReadOf<T>(string pathName)
{
    FileStream fileStream = new FileStream(pathName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
    DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
    T data = (T)dataContractJsonSerializer.ReadObject(fileStream);
    fileStream.Close();
    return data;
}

/// <summary>
/// Json序列化
/// </summary>
/// <param name="data">需要序列化的数据</param>
/// <typeparam name="T">序列化类型</typeparam>
/// <returns>序列化数组</returns>
public static byte[] JsonSerialize<T>(T data)
{
    MemoryStream memoryStream = new MemoryStream();
    DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
    dataContractJsonSerializer.WriteObject(memoryStream, data);
    byte[] serializeData = memoryStream.ToArray();
    memoryStream.Close();
    return serializeData;
}

/// <summary>
/// Json反序列化
/// </summary>
/// <param name="serializeData">需要反序列化的数据</param>
/// <typeparam name="T">反序列化类型</typeparam>
/// <returns>反序列化对象</returns>
public static T JsonDeserialize<T>(byte[] serializeData)
{
    MemoryStream memoryStream = new MemoryStream(serializeData);
    DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
    T data = (T)dataContractJsonSerializer.ReadObject(memoryStream);
    memoryStream.Close();
    return data;
}

测试案例

public static class ESerializer
{
    /// <summary>
    /// 二进制序列化保存至
    /// </summary>
    /// <param name="data">需要序列化的数据</param>
    /// <param name="pathName">序列化文件路径名字</param>
    /// <typeparam name="T">序列化数据类型</typeparam>
    public static void BinarySaveTo<T>(T data, string pathName)
    {
        FileStream fileStream =
            new FileStream(pathName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        binaryFormatter.Serialize(fileStream, data);
        fileStream.Close();
    }

    /// <summary>
    /// 从路径读取二进制文件反序列化为对象
    /// </summary>
    /// <param name="pathName">需要反序列化的路径名字</param>
    /// <typeparam name="T">反序列化数据类型</typeparam>
    /// <returns>反序列化对象</returns>
    public static T BinaryReadOf<T>(string pathName)
    {
        FileStream fileStream = new FileStream(pathName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        T data = (T) binaryFormatter.Deserialize(fileStream);
        fileStream.Close();
        return data;
    }

    /// <summary>
    /// 二进制序列化
    /// </summary>
    /// <param name="data">需要序列化的数据</param>
    /// <typeparam name="T">序列化类型</typeparam>
    /// <returns>序列化数组</returns>
    public static byte[] BinarySerialize<T>(T data)
    {
        MemoryStream memoryStream = new MemoryStream();
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        binaryFormatter.Serialize(memoryStream, data);
        byte[] serializeData = memoryStream.ToArray();
        memoryStream.Close();
        return serializeData;
    }

    /// <summary>
    /// 二进制反序列化
    /// </summary>
    /// <param name="serializeData">需要反序列化的数据</param>
    /// <typeparam name="T">反序列化类型</typeparam>
    /// <returns>反序列化对象</returns>
    public static T BinaryDeserialize<T>(byte[] serializeData)
    {
        MemoryStream memoryStream = new MemoryStream(serializeData);
        BinaryFormatter binaryFormatter = new BinaryFormatter();
        T data = (T) binaryFormatter.Deserialize(memoryStream);
        memoryStream.Close();
        return data;
    }

    /// <summary>
    /// Xml序列化保存至
    /// </summary>
    /// <param name="data">需要序列化的数据</param>
    /// <param name="pathName">序列化文件路径名字</param>
    /// <typeparam name="T">序列化数据类型</typeparam>
    public static void XmlSaveTo<T>(T data, string pathName)
    {
        FileStream fileStream =
            new FileStream(pathName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
        xmlSerializer.Serialize(fileStream, data);
        fileStream.Close();
    }

    /// <summary>
    /// 从路径读取Xml文件反序列化为对象
    /// </summary>
    /// <param name="pathName">需要反序列化的路径名字</param>
    /// <typeparam name="T">反序列化数据类型</typeparam>
    /// <returns>反序列化对象</returns>
    public static T XmlReadOf<T>(string pathName)
    {
        FileStream fileStream = new FileStream(pathName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
        T data = (T) xmlSerializer.Deserialize(fileStream);
        fileStream.Close();
        return data;
    }

    /// <summary>
    /// Xml序列化
    /// </summary>
    /// <param name="data">需要序列化的数据</param>
    /// <typeparam name="T">序列化类型</typeparam>
    /// <returns>序列化数组</returns>
    public static byte[] XmlSerialize<T>(T data)
    {
        MemoryStream memoryStream = new MemoryStream();
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
        xmlSerializer.Serialize(memoryStream, data);
        byte[] serializeData = memoryStream.ToArray();
        memoryStream.Close();
        return serializeData;
    }

    /// <summary>
    /// Xml反序列化
    /// </summary>
    /// <param name="serializeData">需要反序列化的数据</param>
    /// <typeparam name="T">反序列化类型</typeparam>
    /// <returns>反序列化对象</returns>
    public static T XmlDeserialize<T>(byte[] serializeData)
    {
        MemoryStream memoryStream = new MemoryStream(serializeData);
        XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
        T data = (T) xmlSerializer.Deserialize(memoryStream);
        memoryStream.Close();
        return data;
    }

    /// <summary>
    /// Json序列化保存至
    /// </summary>
    /// <param name="data">需要序列化的数据</param>
    /// <param name="pathName">序列化文件路径名字</param>
    /// <typeparam name="T">序列化数据类型</typeparam>
    public static void JsonSaveTo<T>(T data, string pathName)
    {
        FileStream fileStream =
            new FileStream(pathName, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite);
        DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
        dataContractJsonSerializer.WriteObject(fileStream, data);
        fileStream.Close();
    }

    /// <summary>
    /// 从路径读取Json文件反序列化为对象
    /// </summary>
    /// <param name="pathName">需要反序列化的路径名字</param>
    /// <typeparam name="T">反序列化数据类型</typeparam>
    /// <returns>反序列化对象</returns>
    public static T JsonReadOf<T>(string pathName)
    {
        FileStream fileStream = new FileStream(pathName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
        DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
        T data = (T) dataContractJsonSerializer.ReadObject(fileStream);
        fileStream.Close();
        return data;
    }

    /// <summary>
    /// Json序列化
    /// </summary>
    /// <param name="data">需要序列化的数据</param>
    /// <typeparam name="T">序列化类型</typeparam>
    /// <returns>序列化数组</returns>
    public static byte[] JsonSerialize<T>(T data)
    {
        MemoryStream memoryStream = new MemoryStream();
        DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
        dataContractJsonSerializer.WriteObject(memoryStream, data);
        byte[] serializeData = memoryStream.ToArray();
        memoryStream.Close();
        return serializeData;
    }

    /// <summary>
    /// Json反序列化
    /// </summary>
    /// <param name="serializeData">需要反序列化的数据</param>
    /// <typeparam name="T">反序列化类型</typeparam>
    /// <returns>反序列化对象</returns>
    public static T JsonDeserialize<T>(byte[] serializeData)
    {
        MemoryStream memoryStream = new MemoryStream(serializeData);
        DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
        T data = (T) dataContractJsonSerializer.ReadObject(memoryStream);
        memoryStream.Close();
        return data;
    }
}

[Serializable]
public class Test
{
    public Test()
    {
        A = 1;
        B = 1;
        C = 1;
    }

    public float A;
    public float B { get; set; }
    private float _c;
    public float C { get; set; }

    public override string ToString()
    {
        return string.Format("{0}, {1}, {2}", A, B, C);
    }
}

public class NewBehaviourScript : MonoBehaviour
    {
        void Start()
        {
            Test test = new Test();
            
            string pathName = "binary.byte";
            ESerializer.BinarySaveTo(test, pathName);
            test = ESerializer.BinaryReadOf<Test>(pathName);
            Debug.Log(test);
            File.Delete(pathName);

            pathName = "Xml.xml";
            ESerializer.XmlSaveTo(test, pathName);
            test = ESerializer.XmlReadOf<Test>(pathName);
            Debug.Log(test);
            File.Delete(pathName);
            
            pathName = "Json.json";
            ESerializer.JsonSaveTo(test, pathName);
            test = ESerializer.JsonReadOf<Test>(pathName);
            Debug.Log(test);
            File.Delete(pathName);

            byte[] binarySerializeData = ESerializer.BinarySerialize(test);
            test = ESerializer.BinaryDeserialize<Test>(binarySerializeData);
            Debug.Log(test);
            
            byte[] xmlSerializeData = ESerializer.XmlSerialize(test);
            test = ESerializer.XmlDeserialize<Test>(xmlSerializeData);
            Debug.Log(test);
            
            byte[] jsonSerializeData = ESerializer.JsonSerialize(test);
            test = ESerializer.JsonDeserialize<Test>(jsonSerializeData);
            Debug.Log(test);
        }
    }
万阁
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#序列化详解
阿斌(Ben)的博客
02-12 1398
参考帖子：http://www.cnblogs.com/ejiyuan/archive/2009/01/21/1379256.html 练习程序地址：http://pan.baidu.com/s/1nvBF1c1 小结： 序列化我觉得比较实用的地方就是： 1、把数组、列表、字典这些数据序列化后存进数据库，要用的时候再反序列化取出来，这些数据因为是动态的，通过字段一个个去保存的话太麻烦。
C#通过序列化的方式存读类、结构、数组等为二进制文件
柏林春天的专栏
07-17 7385
平常我们使用文件存储程序数据时，一般需要将数据转换为文本等存储，等到需要使用的时候再从文件读取，然后重新构建类或结构或数组等对象。这样的转换和重建即浪费了时间效率不够高又导致容易出错，其实最近由于研究二进制文件的存取，我找到了序列化存取的方法。 序列化存取可以做到类对象、结构、数组等内存实体整体保存为二进制的文件，而不需转换，读取的时候，通过反序列化直接从文件构建对象，而不需要重新通过转换而来的
C# 如何将数据序列化到本地 数组 对象 等等
Coder----Allen----Coder
06-07 3194
1、将需要保存的数据生成json 添加引用： C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5\System.Web.Extensions.dll 生成json： public string ToJSON(object obj) { J
C#序列化与反序列化
qq_43565708的博客
02-20 2763
序列化是将对象或对象图转换成字节流的过程。反序列化是将字节流转换回对象图的过程。
C#：序列化
子昊
06-16 642
序列化是指将对象转换成字节流，从而存储对象或将对象传输到内存、数据库或文件的过程。 它的主要用途是保存对象的状态，以便能够在需要时重新创建对象。 反向过程称为“反序列化”。下图展示了序列化的整个过程：将对象序列化为带有数据的流。 该流还可能包含有关对象类型的信息，例如其版本、区域性和程序集名称。 可以将此流中的对象存储在数据库、文件或内存中。通过序列化，开发人员可以保存对象的状态，并能在需要时重新创建对象，同时还能存储对象和交换数据。 通过序列化，开发人员可以执行如下操作：若要对二进制或 XML 进行序列化
深入理解C#序列化与反序列化的详解
01-01
在我们深入探讨C#序列化和反序列化之前我们先要明白什么是序列化，它又称串行化，是.NET运行时环境用来支持用户定义类型的流化的机制。序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的...
c#序列化和反序列化
05-24
什么叫序列化？ 我们都知道对象是暂时保存在内存中的，不能用U盘考走了，有时为了使用介质转移对象，并且把对象的状态保持下来，就需要把对象保存下来，这个过程就叫做序列化，通俗点，就是把人的魂（对象）收伏成一...
C#序列化成XML注意细节
09-05
C#序列化是一种将对象的状态转化为可存储或可传输的形式的过程。在C#中，有两种主要的序列化方式：二进制序列化和XML序列化。本文主要关注XML序列化时需要注意的一些细节。 首先，XML序列化是将类的对象转换为XML...
C# 序列化反序列化
05-25
在编程领域，序列化和反序列化是两个关键的概念，特别是在C#中。它们用于将对象的状态转换为可存储或可传输的形式，如文本或二进制数据，然后能够恢复成原来的对象。在这个特定的场景中，我们看到的是一个利用C#进行...
C# 序列化&反序列化
最新发布
weixin_43925768的博客
10-08 851
c# 序列化和反序列化的应用场景，序列化和反序列化的三种方式带例子
asp.net 数组与序列化
11-17
asp.net 数组与序列化! 很值得下载看看!资源免费,大家分享!!
C# 配置文件存储 各种序列化算法性能比较 程序1.1
06-15
本文比较多个方式进行配置文件的存储，对比各个不同算法的读写性能。 在应用软件启动的时候，需要读取配置文件，但是启动的性能很重要，所以需要有一个很快的读取配置文件的方法 这就是本文使用的程序，请使用 VisualStudio 编译运行
c# 自定义序列化两种方法
04-07
c# custom serialization 自定义序列化两种方法：1、继承ISerializable,IDeserializationCallback 2、XML方式。（转） 自用
C# 序列化
Blue
07-03 955
C# 序列化
C# Type 序列化问题
zhang116868的专栏
01-21 3693
<br />序列化时使用：type.AssemblyQualifiedName 将Type转换成字符串保存，<br /> <br /> <br />反序列化时使用如下方法:<br /> <br />Type.GetType(AN,T) actually translates to Assembly.Load(AN).GetType(T). This actually can be the cause of many confusions. Often programmers end up in a situ
【C#】C#中实现序列化
愿岁并谢，与长友兮
06-16 1523
概念啥的就不讲了，直接实现把。 序列化使用到了C#中的BinaryFormatter 类。 首先我有一个Fighting类，里面有一个FightingConfigure类的实例。并且还有一个FightingConfigure类。结构如下 public class Fighting { public FightingConfigure fightingConfigure;//战斗配置 } public class FightingConfigure { public int p.
C# 序列化、反序列化
热门推荐
极简的随笔
07-03 1万+
刚刚碰巧群里有人问这个问题，而之前的博客中并没有提及，打算弄一篇博客简单提及一下这个知识点。MSDN文档中提及了序列化、反序列化的概念，这里引用一下。序列化：将对象状态转换为可保持或传输的形式的过程。反序列化：是序列化的逆过程，就是将流转换为对象的过程。这两个过程一起保证数据易于传输和存储。详细的请参考：http://msdn.microsoft.com/zh-cn/library/7ay27kt
C#高性能二进制序列化
嘿嘿
08-31 2710
http://www.cnblogs.com/yswenli/p/9217495.html 用着多了就发现BinaryFormatter有很多地方不妥，下面就来数数这个序列化的“三宗罪”：         1.类名上面要加上[Serializable]，不加不给序列化；正常的用法应该是序列化一个对象，不需的地方加上NonSerialized才合理吧；         2.序列化byte[]结...
c#序列化
05-24
在 C# 中，对象序列化是将对象转换为可存储或传输的格式的过程。可以使用 C# 中的 System.Runtime.Serialization 命名空间中的类来实现对象序列化。下面是一个简单的示例，展示如何使用 C# 进行对象序列化： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值