序列化及反序列化的辅助类SerializeUtil

最新推荐文章于 2023-08-24 16:37:49 发布
最新推荐文章于 2023-08-24 16:37:49 发布
阅读量587 收藏
点赞数
分类专栏： asp.net 文章标签： object string path soap xml assembly

   /** <summary>
    /// 序列化及反序列化的辅助类
    /// </summary>
    public sealed class SerializeUtil
    {
        private SerializeUtil()
        {
        }

        序列化操作函数#region 序列化操作函数

        /** <summary>
        /// 将对象序列化为二进制字节
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <returns></returns>
        public static byte[] SerializeToBinary(object obj)
        {
            byte[] bytes = new byte[2500];
            using (MemoryStream memoryStream = new MemoryStream())
            {
                BinaryFormatter bformatter = new BinaryFormatter();
                bformatter.Serialize(memoryStream, obj);
                memoryStream.Seek(0, 0);

                if (memoryStream.Length > bytes.Length)
                {
                    bytes = new byte[memoryStream.Length];
                }
                bytes = memoryStream.ToArray();
            }
            return bytes;
        }

        /** <summary>
        /// 将文件对象序列化到文件中
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <param name="path">文件路径</param>
        /// <param name="fileMode">文件打开模式</param>
        public static void SerializeToBinary(object obj, string path, FileMode fileMode)
        {
            using (FileStream fs = new FileStream(path, fileMode))
            {
                // Construct a BinaryFormatter and use it to serialize the data to the stream.
                BinaryFormatter formatter = new BinaryFormatter();
                formatter.Serialize(fs, obj);
            }
        }

        /** <summary>
        /// 将文件对象序列化到文件中
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <param name="path">文件路径</param>
        public static void SerializeToBinary(object obj, string path)
        {
            SerializeToBinary(obj, path, FileMode.Create);
        }


        /** <summary>
        /// 将对象序列化为Soap字符串
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <returns>Soap字符串</returns>
        public static string SerializeToSoap(object obj)
        {
            string soap = string.Empty;
            using (MemoryStream memoryStream = new MemoryStream())
            {
                SoapFormatter sformatter = new SoapFormatter();
                sformatter.Serialize(memoryStream, obj);
                memoryStream.Seek(0, 0);
                soap = Encoding.ASCII.GetString(memoryStream.ToArray());
            }

            return soap;
        }

        /** <summary>
        /// 将对象序列化为Soap字符串，并保存到文件中
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <param name="path">文件路径</param>
        /// <param name="fileMode">文件打开模式</param>
        public static void SerializeToSoap(object obj, string path, FileMode fileMode)
        {
            FileStream fs = new FileStream(path, fileMode);

            // Construct a BinaryFormatter and use it to serialize the data to the stream.
            SoapFormatter formatter = new SoapFormatter();
            try
            {
                formatter.Serialize(fs, obj);
            }
            catch (SerializationException e)
            {
                Console.WriteLine("Failed to serialize. Reason: " + e.Message);
                throw;
            }
            finally
            {
                fs.Close();
            }
        }

        /** <summary>
        /// 将对象序列化为Soap字符串，并保存到文件中
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <param name="path">文件路径</param>
        public static void SerializeToSoap(object obj, string path)
        {
            SerializeToSoap(obj, path, FileMode.Create);
        }


        /** <summary>
        /// 将对象序列化为XML字符串
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <returns>XML字符串</returns>
        public static string SerializeToXml(object obj)
        {
            string xml = "";
            using (MemoryStream memoryStream = new MemoryStream())
            {
                XmlSerializer serializer = new XmlSerializer(obj.GetType());
                serializer.Serialize(memoryStream, obj);
                memoryStream.Seek(0, 0);
                xml = Encoding.ASCII.GetString(memoryStream.ToArray());
            }

            return xml;
        }

        /** <summary>
        /// 将对象序列化为XML字符串并保存到文件
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <param name="path">保存的文件路径</param>
        /// <param name="fileMode">文件打开模式</param>
        public static void SerializeToXmlFile(object obj, string path, FileMode fileMode)
        {
            using (FileStream fileStream = new FileStream(path, fileMode))
            {
                // Construct a BinaryFormatter and use it to serialize the data to the stream.
                XmlSerializer serializer = new XmlSerializer(obj.GetType());
                serializer.Serialize(fileStream, obj);
            }
        }

        /** <summary>
        /// 将对象序列化为XML字符串并保存到文件
        /// </summary>
        /// <param name="obj">待序列化的对象</param>
        /// <param name="path">保存的文件路径</param>
        public static void SerializeToXmlFile(object obj, string path)
        {
            SerializeToXmlFile(obj, path, FileMode.Create);
        }

        #endregion

        反序列化操作函数#region 反序列化操作函数

        /** <summary>
        /// 从XML文件中反序列化为Object对象
        /// </summary>
        /// <param name="type">对象的类型</param>
        /// <param name="path">XML文件</param>
        /// <returns>反序列化后得到的对象</returns>
        public static object DeserializeFromXmlFile(Type type, string path)
        {
            object result = new object();
            using (FileStream fileStream = new FileStream(path, FileMode.Open))
            {
                XmlSerializer serializer = new XmlSerializer(type);
                result = serializer.Deserialize(fileStream);
            }

            return result;
        }

        /** <summary>
        /// 从XML文件中反序列化为对象
        /// </summary>
        /// <param name="type">对象的类型</param>
        /// <param name="xml">XML字符串</param>
        /// <returns>反序列化后得到的对象</returns>
        public static object DeserializeFromXml(Type type, string xml)
        {
            object result = new object();
            XmlSerializer serializer = new XmlSerializer(type);
            result = serializer.Deserialize(new StringReader(xml));

            return result;
        }

        /** <summary>
        /// 从Soap字符串中反序列化为对象
        /// </summary>
        /// <param name="type">对象的类型</param>
        /// <param name="soap">soap字符串</param>
        /// <returns>反序列化后得到的对象</returns>
        public static object DeserializeFromSoap(Type type, string soap)
        {
            object result = new object();
            using (MemoryStream memoryStream = new MemoryStream(new UTF8Encoding().GetBytes(soap)))
            {
                SoapFormatter serializer = new SoapFormatter();
                result = serializer.Deserialize(memoryStream);
            }

            return result;
        }

        /** <summary>
        /// 从二进制字节中反序列化为对象
        /// </summary>
        /// <param name="type">对象的类型</param>
        /// <param name="bytes">字节数组</param>
        /// <returns>反序列化后得到的对象</returns>
        public static object DeserializeFromBinary(Type type, byte[] bytes)
        {
            object result = new object();
            using (MemoryStream memoryStream = new MemoryStream(bytes))
            {
                BinaryFormatter serializer = new BinaryFormatter();
                result = serializer.Deserialize(memoryStream);
            }

            return result;
        }

        /** <summary>
        /// 从二进制文件中反序列化为对象
        /// </summary>
        /// <param name="type">对象的类型</param>
        /// <param name="path">二进制文件路径</param>
        /// <returns>反序列化后得到的对象</returns>
        public static object DeserializeFromBinary(Type type, string path)
        {
            object result = new object();
            using (FileStream fileStream = new FileStream(path, FileMode.Open))
            {
                BinaryFormatter serializer = new BinaryFormatter();
                result = serializer.Deserialize(fileStream);
            }

            return result;
        }

        #endregion

        /** <summary>
        /// 获取对象的转换为二进制的字节大小
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static long GetByteSize(object obj)
        {
            long result;
            BinaryFormatter bFormatter = new BinaryFormatter();
            using (MemoryStream stream = new MemoryStream())
            {
                bFormatter.Serialize(stream, obj);
                result = stream.Length;
            }
            return result;
        }

        /** <summary>
        /// 克隆一个对象
        /// </summary>
        /// <param name="obj">待克隆的对象</param>
        /// <returns>克隆的一个新的对象</returns>
        public static object Clone(object obj)
        {
            object cloned = null;
            BinaryFormatter bFormatter = new BinaryFormatter();
            using (MemoryStream memoryStream = new MemoryStream())
            {
                try
                {
                    bFormatter.Serialize(memoryStream, obj);
                    memoryStream.Seek(0, SeekOrigin.Begin);
                    cloned = bFormatter.Deserialize(memoryStream);
                }
                catch //(Exception e)
                {
                    ;
                }
            }

            return cloned;
        }

        /** <summary>
        /// 从文件中读取文本内容
        /// </summary>
        /// <param name="path">文件路径</param>
        /// <returns>文件的内容</returns>
        public static string ReadFile(string path)
        {
            string content = string.Empty;
            using (StreamReader reader = new StreamReader(path))
            {
                content = reader.ReadToEnd();
            }

            return content;
        }

        /** <summary>
        /// 读取嵌入资源的文本内容
        /// </summary>
        /// <param name="fileWholeName">包含命名空间的嵌入资源文件名路径</param>
        /// <returns>文件中的文本内容</returns>
        public static string ReadFileFromEmbedded(string fileWholeName)
        {
            string result = string.Empty;

            Assembly assembly = Assembly.GetEntryAssembly();
            using (TextReader reader = new StreamReader(assembly.GetManifestResourceStream(fileWholeName)))
            {
                result = reader.ReadToEnd();
            }

            return result;
        }
    }

序列化及反序列化的辅助类SerializeUtil测试代码


    public class TestSerializeUtil
    {
        public static string Execute()
        {
            string result = string.Empty;
            result += "使用SerializeUtil序列化及反序列化的辅助类：" + "/r/n";
           
            Person person = new Person();
            person.Name = "wuhuacong";
            person.Age = 20;
           
            byte[] bytes = SerializeUtil.SerializeToBinary(person);
            Person person2 = SerializeUtil.DeserializeFromBinary(typeof (Person), bytes) as Person;
            result += ReflectionUtil.GetProperties(person2) + "/r/n";
           
            string xml = SerializeUtil.SerializeToXml(person);
            Person person3 = SerializeUtil.DeserializeFromXml(typeof (Person), xml) as Person;
            result += "person3:/r/n" + ReflectionUtil.GetProperties(person3) + "/r/n";
           
            result += "SerializeUtil.GetByteSize(person3):" + SerializeUtil.GetByteSize(person3) + "/r/n";
           
            Person person4 = SerializeUtil.Clone(person3) as Person;
            result += "person4:/r/n" + ReflectionUtil.GetProperties(person4) + "/r/n";
           
            result += "Util.AreObjectsEqual(person3, person4):" + Util.AreObjectsEqual(person3, person4)+ "/r/n";
           
            SerializeUtil.SerializeToXmlFile(person3, Util.CurrentPath + "person3.xml", FileMode.Create);
            Person person5 = SerializeUtil.DeserializeFromXmlFile(typeof (Person), Util.CurrentPath + "person3.xml") as Person;
            result += "person5:/r/n" + ReflectionUtil.GetProperties(person5) + "/r/n/r/n";
           
            result += SerializeUtil.ReadFile(Util.CurrentPath + "person3.xml") + "/r/n/r/n";
            result += SerializeUtil.ReadFileFromEmbedded("TestUtilities.EmbedFile.xml") + "/r/n/r/n";

            return result;
        }
    }

fengyedqg
关注
专栏目录
SerializeUtil序列化工具类
weixin_53666393的博客
02-23 115
Java工具类，SerializeUtil序列化工具类
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
热门推荐
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
java serializeutils_SerializeUtil 序列化 java
weixin_29682291的博客
02-19 223
SerializeUtil ?序列化 ?java?class="java" name="code">import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.io.ObjectInputStream;import java.io...
SerializeUtil 序列化 java
weixin_33910137的博客
10-23 262
SerializeUtil 序列化 java import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import ja...
SerializeUtil
weixin_30394669的博客
05-09 72
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; /** * 序列化，反序列化工具类 * 用于转换byte[]和对象 * 用作在jed...
java序列化 SerializeUtil
dgqvhtlwq472235338的博客
10-12 108
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.Closeable; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutp...
Serializer序列化器和反序列化器的使用
qq_31610145的博客
07-13 1673
1 、序列化器的基本使用1） 先查询出一个图书对象from test.models import Infop1 = Info.objects.get()2） 构造序列化器对象from test.serializers import InfoSerializerserializer = InfoSerializer(p1)3）获取序列化数据通过data属性可以获取序列化后的数据serializer....
java serialize_Java序列化（Serialize）和反序列化（Deserialize）
weixin_34945060的博客
02-21 1665
对象的序列化一、目的：将对象转换成与平台无关的二进制流，从而可以保存到磁盘或者进行网络传输，其它程序获 得这个二进制流后可以将其还原成对象。序列化机制可以使对象可以脱离程序的运行而对立存在。————————————————————————————————————————二、是什么？序列化(Serialize)指将一个java对象写入IO流中，与此对应的是，对象的反序列化(Deserialize)则...
C++ JSON 序列化与反序列化
06-22
1. 复杂类型的处理：除了基本类型外，还可以序列化和反序列化自定义类、结构体以及容器（如vector、map等）。对于自定义类型，通常需要重载`operator和`operator>>`，或者使用nlohmann/json库中的`to_json`和`from_...
二叉树的序列化和反序列化——C++
净无邪博客
12-15 2579
总体解题思想为先用层次遍历存储包括空节点的每个节点，存储是每个节点都存储左右子节点，如果节点为空，则存储"#,"，否则存储节点的值val，同时用逗号','分割每个节点内容，存储完后进行序列化string。反序列化则先按逗号','分割每个字符串为数组字符串vector<string> valStrArr，该valStrArr存储每个节点的值，包括空节点；然后遍历valStrArr，反向构建原始二叉树。反向构建二叉树时由于存储是按层次遍历存入的，所以反向遍历时也需要按照层次遍历依次将非空节点压栈和弹出栈。由于层
Serialize类
08-06
SerializeUtil序列化类
【项目实战】Redis的序列化与反序列化
本本本添哥
04-18 1979
在Redis中，数据可以被序列化为二进制格式并存储在内存中，以提高读写性能。 Redis支持多种序列化格式，包括JSON、MessagePack和Protocol Buffers。 默认情况下，Redis使用自己的二进制序列化格式，但可以通过配置文件更改为其他格式。
【网络安全 | CTF】记一次PHP序列化反序列化解题详析
最新发布
等风来
08-24 3902
代码开门见山给出backdoor函数，而该函数在popko类的call方法中调用故需要运行call方法而call方法是在对象上下文中调用不可访问的方法时触发的故需要调用不可访问的方法 而恰巧destruct方法中并不存在a对象和a函数故需要运行destruct方法而destruct方法在对象被销毁时触发 如何实现对象被销毁呢？ 当序列化后的语句被反序列化之后，对象会被销毁，从而触发destruct方法 所以思路就是： 在pipimi类中构造一个对象，当pipimi中的destru
SerializeUtil 序列化
被隐藏的博客
01-05 497
public class SerializeUtil { /** * 序列化 * * @param object * @return */ public static byte[] serialize(Object object) { ObjectOutputStream oos = null; ByteArrayOutputStream baos = null;...
SerializeUtil 序列化工具
weixin_34195142的博客
05-31 196
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.Closeable; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.ArrayL...
java serializeutils_SerializeUtil 序列化，反序列化工具类
weixin_39719077的博客
03-06 185
packagecloud.app.prod.home.utils;importjava.io.ByteArrayInputStream;importjava.io.ByteArrayOutputStream;importjava.io.Closeable;importjava.io.ObjectInputStream;importjava.io.ObjectOutputStream;importj...
SerializeUtil工具类
xh32t03的专栏
09-13 929
import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import org.apache.ibatis.cache.CacheException; ...
SerializeUtil序列化工具类解析
大智的博客
09-23 5614
Java中ObjectInputStream 与 ObjectOutputStream这两个包装类可用于输入流中读取对象类数据和将对象类型的数据写入到底层输入流 。ObjectInputStream 与 ObjectOutputStream 类所读写的对象必须实现了 Serializable 接口。需要注意的是：对象中的 transient 和 static 类型的成员变量不会被读取和写入 。...
C#对象序列化与反序列化详解及示例
使用`System.Runtime.Serialization.Formatters.Binary.BinaryFormatter`类实现，其序列化后的结果是以二进制形式存储，可以包含一个类型的所有可序列化字段，无论它们是公共字段还是私有字段，但会包含类型信息，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值