C#byte[]序列化及xml序列化,支持序列化后再压缩.

最新推荐文章于 2024-08-15 15:55:16 发布
最新推荐文章于 2024-08-15 15:55:16 发布
阅读量5.7k 收藏 1
点赞数 1
分类专栏： windows C# 文章标签： xml byte null string encoding io
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ALLsharps/article/details/7357474
版权
C# 同时被 2 个专栏收录
19 篇文章 0 订阅
订阅专栏
windows
6 篇文章 1 订阅
订阅专栏 
/// <summary>
    /// 对象的序列化助手
    /// </summary>
    public static class SerializerHelper
    {
        /// <summary>
        /// 返回对象序列化为byte数组
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="t">对象</param>
        /// <returns></returns>
        public static byte[] GetByteSerialize<T>(T t)
        {
            return GetByteSerialize(t, true);
        }
        public static byte[] GetDataMemberSerialize<T>(T t)
            where T:IList
        {
            return GetDataMemberSerialize(t, true);
        }
        /// <summary>
        /// 把列表T序列化,格式:
        /// 4个字节 第一个元素 4个字节 第二个元素
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="encry"></param>
        /// <returns></returns>
        private static byte[] GetDataMemberSerialize<T>(T t, bool encry)
            where T:IList
        {
            Type type = typeof (T);
            Type dataType = type;
            

            if (type.GetInterface("IList")!=null)
            {
                dataType = type.GetGenericArguments()[0];
                int count = (int)type.GetProperty("Count").GetValue(t, null);
                
                MemoryStream ms = new MemoryStream();
                for(int i = 0;i < count;i++)
                {
                    MemoryStream m1 = new MemoryStream();
                    object io = type.GetMethod("get_Item").Invoke(t, new object[] { i });
                    var props = dataType.GetProperties().ToList();
                    props.ForEach(p =>
                    {
                        if (p.IsDefined(typeof(DataMemberAttribute), false))
                        {
                            byte[] name = Encoding.ASCII.GetBytes(p.Name);

                            m1.WriteByte(p.Name.GetByteSizeByte());
                            m1.Write(name,0,name.Length);
                            bool readed = false;

                            byte[] valLen = null;
                            byte[] val = null;
                            if(p.PropertyType ==typeof( string))
                            {
                                readed = true;
                                string strV = p.GetValue(io, null).ToString();
                                if (strV != null)
                                {
                                    valLen = strV.GetIntSizeByte();
                                    val = Encoding.UTF8.GetBytes(strV);
                                }
                            }

                            #region Guid
                            if (p.PropertyType == typeof(Guid))
                            {
                                readed = true;
                                Guid strV = new Guid(p.GetValue(io, null).ToString());

                                val = strV.ToByteArray();
                                valLen = new byte[] { (byte)val.Length };
                            }
                            if (p.PropertyType == typeof(Guid?))
                            {
                                readed = true;
                                Guid? strV = (Guid?)p.GetValue(io, null);
                                if (strV.HasValue)
                                {
                                    val = strV.Value.ToByteArray();
                                    valLen = new byte[] {(byte) val.Length};
                                }
                            }
                            #endregion

                            #region int
                            if (p.PropertyType ==typeof( int))
                            {
                                readed = true;
                                int strV = (int)(p.GetValue(io, null));

                                val = BitConverter.GetBytes(strV);
                                valLen = new byte[] { (byte)val.Length };
                            }
                            if (p.PropertyType ==typeof( int?))
                            {
                                readed = true;
                                int? strV = (int?)p.GetValue(io, null);
                                if (strV.HasValue)
                                {
                                    val = BitConverter.GetBytes(strV.Value);
                                    valLen = new byte[] { (byte)val.Length };
                                }
                            }
                            #endregion

                            #region byte
                            if (p.PropertyType ==typeof( byte))
                            {
                                readed = true;
                                byte strV = (byte)(p.GetValue(io, null));

                                val = BitConverter.GetBytes(strV);
                                valLen = new byte[] { (byte)val.Length };
                            }
                            if (p.PropertyType ==typeof( byte?))
                            {
                                readed = true;
                                byte? strV = (byte?)p.GetValue(io, null);
                                if (strV.HasValue)
                                {
                                    val = BitConverter.GetBytes(strV.Value);
                                    valLen = new byte[] { (byte)val.Length };
                                }
                            }
                            #endregion

                            #region DateTime
                            if (p.PropertyType == typeof(DateTime))
                            {
                                readed = true;
                                DateTime strV = (DateTime)(p.GetValue(io, null));
                                val = BitConverter.GetBytes(strV.ToBinary());
                                valLen = new byte[] { (byte)val.Length };
                            }
                            if (p.PropertyType ==typeof( DateTime?))
                            {
                                readed = true;
                                DateTime? strV = (DateTime?)p.GetValue(io, null);
                                if (strV.HasValue)
                                {
                                    val = BitConverter.GetBytes(strV.Value.ToBinary());
                                    valLen = new byte[] { (byte)val.Length };
                                }
                            }
                            #endregion

                            #region byte[]
                            if (p.PropertyType == typeof(byte[]))
                            {
                                readed = true;
                                byte[] strV = (byte[])(p.GetValue(io, null));

                                val = strV;
                                valLen = new byte[] { (byte)val.Length };
                            }
                            
                            #endregion

                            if(!readed)
                            {
                                throw new Exception(p.PropertyType.ToString() + "未设置");
                            }
                            if(val!=null&& valLen!=null)
                            {
                                m1.Write(valLen,0,valLen.Length);
                                m1.Write(val, 0, val.Length);
                            }
                        }
                    });
                    var end1 = m1.ToArray();
                    byte[] size = BitConverter.GetBytes(end1.Length);
                    ms.Write(size, 0, size.Length);
                    ms.Write(end1, 0, end1.Length);
                    
                }
                return ms.ToArray();
            }
            else
            {
                var props = type.GetProperties().ToList();
                props.ForEach(p =>
                {
                    if (p.IsDefined(typeof(DataMemberAttribute), false))
                    {
                        p.GetValue(t, null);
                    }
                });
            }
            return null;
        }

        /// <summary>
        /// 返回对象序列化为byte数组
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="t">对象</param>
        /// <param name="compress">是否压缩(默认压缩)</param>
        /// <returns></returns>
        public static byte[] GetByteSerialize<T>(T t,bool compress)
        {
            var memory = new MemoryStream();
            var formatter = new BinaryFormatter();
            formatter.Serialize(memory, t);
            memory.Position = 0;
            var read = new byte[memory.Length];
            memory.Read(read, 0, read.Length);
            memory.Close();
            if (compress)
            {
                read = CompressHelper.CompressBytes(read);
            }
            return read;
        }

        /// <summary>
        /// 返回对象的反序列化
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="pBytes">byte数组</param>
        /// <returns></returns>
        public static T GetByteDeserialize<T>(byte[] pBytes)
        {
            return GetByteDeserialize<T>(pBytes, true);
        }

        /// <summary>
        /// 返回对象的反序列化
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="pBytes">byte数组</param>
        /// <param name="decompress">是否先进行解压操作</param>
        /// <returns></returns>
        public static T GetByteDeserialize<T>(byte[] pBytes,bool decompress)
        {
            if (pBytes == null)
                return default(T);
            if(decompress)
            {
                pBytes = CompressHelper.DecompressBytes(pBytes);
            }
            var memory = new MemoryStream(pBytes) {Position = 0};
            var formatter = new BinaryFormatter();
            object newOjb = formatter.Deserialize(memory);
            memory.Close();
            return (T)newOjb;
        }

        /// <summary>
        /// 返回对T的XML序列化结果
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string GetXmlSerialize<T>(T t)
        {
            string re;
            var ser = new XmlSerializer(typeof(T));
            using (var ms = new MemoryStream())
            using (var sw = new StreamWriter(ms))
            using (var sr = new StreamReader(ms))
            {
                ser.Serialize(sw, t);
                ms.Position = 0;
                re = sr.ReadToEnd();
            }
            return re;
        }
        /// <summary>
        /// 对XML反序列化为对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="xmlString"></param>
        /// <returns></returns>
        public static T GetXmlDeserialize<T>(string xmlString) where T : class
        {
            return GetXmlDeserialize<T>(xmlString, Encoding.UTF8);
        }
        /// <summary>
        /// 对XML反序列化为对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="xmlString"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static T GetXmlDeserialize<T>(string xmlString, Encoding encoding) where T : class
        {
            using (var memoryStream = new MemoryStream(encoding.GetBytes(xmlString)))
            using (var streamReader = new StreamReader(memoryStream, encoding))
            using (var xmlTextReader = new XmlTextReader(streamReader))
            {
                var ser = new XmlSerializer(typeof(T));
                if (ser.CanDeserialize(xmlTextReader))
                {
                    return ser.Deserialize(xmlTextReader) as T;
                }
            }
            return null;
        }

        /// <summary>
        /// 根据对象的属性,生成另外一个对象,要求两个对象属性名称一样,类型一样
        /// </summary>
        /// <typeparam name="TInput"></typeparam>
        /// <typeparam name="TOut"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static TOut GetClone<TInput, TOut>(TInput t)
                where TOut : class,new()
        {
            TOut re = new TOut();
            Type toutType = typeof (TOut);
            Type tinputType = typeof(TInput);
            var toutProList = toutType.GetProperties();
            var tinputProList = tinputType.GetProperties();

            foreach (var inPro in tinputProList)
            {
                foreach (var outPro in toutProList)
                {
                    if(inPro.Name == outPro.Name &&
                        inPro.PropertyType == outPro.PropertyType
                        )
                    {
                        outPro.SetValue(re,inPro.GetValue(t,null),null);
                    }
                }
            }
            return re;
        }
        /// <summary>
        /// 把数据实体对象转成可以序列化的对象列表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <typeparam name="TOr"></typeparam>
        /// <param name="getAll"></param>
        /// <returns></returns>
        public static List<T> GetDataTableList<T, TOr>(Func<List<TOr>> getAll)
            where T : class,new()
        {
            List<T> et = new List<T>();
            var lists = getAll();
            lists.ForEach(w => et.Add(SerializerHelper.GetClone<TOr, T>(w)));
            return et;
        }
    }

ALLsharps
关注
专栏目录
C# 将含有byte[]字段的类序列化与反序列化
jathney的博客
08-19 3921
类DemoClass里的string Title字段包含了图片文件的名称，byte[]内含有图片文件的内容。将该类DemoClass的实例demo序列化，转为byte[]，以便传入MySQL数据库中。 using System; using System.Collections.Generic; using System.IO; using System.Linq; using
C# 对象和byte数组的互相转化（序列化）
一入編程深似海!
04-19 8730
通常Socket数据传送过程中，我们把对象转化为byte数组，接手时再将数组转化为对应的对象，这一过程可以通过序列化完成 前提是传输的对象必须标记为可以序列化的，下面举个例子： Package为 我们要传送接收的对象消息 [Serializable] public class Package { /// <summary> ...
java byte[] 序列化 与 C# byte[] 序列化差异性
nn991926的博客
08-16 1421
最近项目遇到一个大坑（接口文档竟然说要传 byte[]，其实应该传 string，还好我要要了一个 .NET 代码，差点被坑！！！），需要上传一个 byte[] 数组给后台。 java byte[] 序列化之后还是 byte[], 然而 .NET 则变成了 Base64（NO_WRAP）字符串； 因此： java 这边需要手动将 byte[] 转成 Base64 字符串: Base64.en...
【C#基础概念】字节顺序（大端、小端）
最新发布
燕儿归的专栏
08-15 106
又称或），在领域中，指中或在数字通信链路中，组成的的排列顺序。例如假设上述变量x类型为int，位于地址0x100处，它的值为0x01234567，地址范围为字节，其内部排列顺序依赖于机器的类型。。。举列子：就像车直接倒进车库（小端），还是直接开入车库（大端）。
用C#把文件转换为XML
csdn864883的博客
06-26 142
using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Fo...
C#二进制流的序列化和反序列化操作
10-18 1298
C#项目中较多使用了序列化和反序列化，较为常用的序列化和反序列化操作有二进制流，JSON,XML等，现在介绍一下.net中二进制流的序列化和反序列化操作方法： 1.将对象序列化为二进制流： /// /// 将对象序列化为byte[] /// 使用IFormatter的Serialize序列化 /// /// 需要序列化的
c# 序列化
磨刀不误砍柴工
08-20 6427
定义: 序列化是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入临时或持久存储区。以后，可以通过从存储区中读取或反序列化对象的状态，从新创建该对象。 ...
C#序列化对象方法
qq_36695087的博客
12-08 563
需要引用的命名空间 using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters.Binary; using System.IO; 通过序列化方法将对象转化成字符串类型 public string SerializeObject(object obj) { IFormatter formatt...
C# 序列化对象及反序列化
qq_18932003的博客
01-16 147
压缩方法 #region 压缩 /// <summary> /// 压缩 /// </summary> /// <param name="bytes">未被压缩的字节数据</param> /// <returns></returns> ...
C#实现xml文件反序列化读入数据到object的方法
09-03
// 使用MemoryStream作为输入，反序列化XML字符串为指定类型的对象 return xmlSerializer.Deserialize(memoryStream); } ``` 在这个例子中，`DeSerializeFromXmlString`方法接收两个参数：要反序列化的类型(`...
浅谈C# 序列化与反序列化几种格式的转换
09-01
2. **XML序列化与反序列化** XML（eXtensible Markup Language）是一种用于标记数据的语言，常用于数据交换和存储。 - **序列化**： `ScriptSerializeToXML<T>`方法使用`XmlSerializer`将对象序列化为XML字符串...
C#中string与byte[]的转换帮助类-.NET教程,C#语言
01-01
主要实现了以下的函数  代码中出现的sidle是我的网名。  /**//*  * @author wuerping  * @version 1.0  * @date 2004/11/30  * @description:  */  using system;  using system.text;  namespace sidlehelper  {  /**//// <summary>  /// summary description for strhelper.  /// 命名缩写：  /// str: unicode string  /// arr: unicode array  /// 
Unity 中使用Protobuf进行序列化和反序列化的Demo
01-27
在Unity游戏引擎中，开发人员经常需要处理数据的序列化和反序列化，以便于存储、传输或网络通信。Protocol Buffers（Protobuf）是一种高效、跨平台的数据序列化协议，由Google开发。本Demo将展示如何在Unity中集成并...
C# Xml序列化
IMZhangZiF的博客
12-15 2232
C# Xml序列化前言正文 C# 实体类、DataTable、List<>序列化为Xml； 提示：以下是本篇文章正文内容，下面代码仅供学习参考 参考代码：
C#托管类型与非托管类型的字节数组序列化
qq_55895529的博客
11-23 909
C#托管类型与非托管类型的字节数组序列化
实习笔记C# 利用XML储存数据
猪猪的博客
02-06 1274
xml在应用程序中储存数据 (含加密方式解析)
.NET序列化与反序列化实战教程
- SoapFormatter：用于创建符合SOAP标准的XML序列化，常用于Web服务。 - XmlSerializer：生成XML格式的序列化数据，跨平台且可读性好，但不处理非公共字段和属性。 3. BinaryFormatter的使用 BinaryFormatter是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值