lyfz_repos/其他源码/HPSocketCS/Extended/DataSetSerializerDeserialize.cs

using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;

namespace HPSocketCS.Extended
{
	/// <summary>
	///  DataSet对象序列化并压缩和解压缩及反序列化
	/// </summary>
	public class DataSetSerializerDeserialize
	{
		public DataSetSerializerDeserialize()
		{

		}
		#region 2017-02-22 重新整理
		/// <summary>  
		/// 不压缩直接序列化object到byte[]
		/// </summary>  
		/// <param name="ds"></param>  
		public static byte[] ObjectSerializerRetBytes(object obj)
		{
			if (obj != null)
			{
				IFormatter formatter = new BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象  

				using (MemoryStream ms = new MemoryStream())//创建内存流对象  
				{
					formatter.Serialize(ms, obj);//把DataSet对象序列化到内存流  

					byte[] buffer = ms.ToArray();//把内存流对象写入字节数组  

					ms.Close();//关闭内存流对象  

					ms.Dispose();//释放资源  
					return buffer;
				}
			}
			else
			{
				return null;
			}
		}
		/// <summary>  
		/// 反序列化未压缩的object  
		/// </summary>  
		/// <param name="data"></param>  
		/// <returns></returns>  
		public static object ObjectDeserialize(byte[] data)
		{
			if (data != null)
			{
				using (MemoryStream gzipms = new MemoryStream())//创建内存流对象  
				{
					gzipms.Write(data, 0, data.Length);
					gzipms.Position = 0;
					BinaryFormatter sfFormatter = new BinaryFormatter();//定义BinaryFormatter以反序列化DataSet对象  

					try
					{
						if (gzipms.Length > 0)
						{
							return sfFormatter.Deserialize(gzipms);//反序列化  
						}
						else
						{
							return null;
						}
					}
					catch (SerializationException e)
					{
						Debug.WriteLine(e.Message);
						throw;
					}
					finally
					{
						gzipms.Close();//关闭内存流  
						gzipms.Dispose();//释放资源  
					}
				}
			}
			else
			{
				return null;
			}
		}

		/// <summary>  
		/// 序列化object对象并压缩到byte[]
		/// </summary>  
		/// <param name="ds"></param>  
		public static byte[] ObjectSerializerCompressionRetBytes(object obj)
		{
			IFormatter formatter = new BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象  

			using (MemoryStream ms = new MemoryStream(), gzipms = new MemoryStream())//创建内存流对象  
			{
				formatter.Serialize(ms, obj);//把DataSet对象序列化到内存流  

				byte[] buffer = ms.ToArray();//把内存流对象写入字节数组  

				ms.Close();//关闭内存流对象  

				ms.Dispose();//释放资源  

				// MemoryStream gzipms = new MemoryStream();//创建内存流对象  
				using (GZipStream gzipStream = new GZipStream(gzipms, CompressionMode.Compress, true))//创建压缩对象  
				{
					gzipStream.Write(buffer, 0, buffer.Length);//把压缩后的数据写入文件  
					gzipStream.Close();//关闭压缩流,这里要注意：一定要关闭，要不然解压缩的时候会出现小于4K的文件读取不到数据，大于4K的文件读取不完整              
					gzipStream.Dispose();//释放对象 
				}
				gzipms.Position = 0;
				byte[] retbuffer = gzipms.ToArray();
				gzipms.Close();
				gzipms.Dispose();
				return retbuffer;
			}
		}

		/// <summary>  
		/// 反序列化压缩的Object  
		/// </summary>  
		/// <param name="_filePath"></param>  
		/// <returns></returns>  
		public static object ObjectDeserializeDecompress(byte[] data)
		{
			using (MemoryStream gzipms = new MemoryStream(), decompressms = new MemoryStream())//创建内存流对象  
			{
				gzipms.Write(data, 0, data.Length);
				gzipms.Position = 0;
				using (GZipStream gzipStream = new GZipStream(gzipms, CompressionMode.Decompress))//创建解压对象  
				{
					byte[] buffer = new byte[4096];
					int offset = 0;//定义读取位置  
								   // MemoryStream decompressms = new MemoryStream();//定义解压的内存流  
					try
					{
						while ((offset = gzipStream.Read(buffer, 0, buffer.Length)) != 0)
						{
							decompressms.Write(buffer, 0, offset);//解压后的数据写入内存流  
						}

					}
					catch (Exception e)
					{
						throw e;
					}
					finally
					{
						gzipms.Close();
						gzipms.Dispose();
						gzipStream.Close();//关闭解压缩流  
						gzipStream.Dispose();//释放资源  
					}
				}
				decompressms.Position = 0;
				decompressms.Seek(0, SeekOrigin.Begin);
				BinaryFormatter sfFormatter = new BinaryFormatter();//定义BinaryFormatter以反序列化DataSet对象  
				try
				{
					return sfFormatter.Deserialize(decompressms);//反序列化  
				}
				catch
				{
					throw;
				}
				finally
				{
					decompressms.Close();//关闭内存流  
					decompressms.Dispose();//释放资源  
				}

			}
		}
		#endregion


		/// <summary>  
		/// 序列化DataSet对象并压缩  
		/// </summary>  
		/// <param name="ds"></param>  
		public static void DataSetSerializerCompression(DataSet ds)
		{
			IFormatter formatter = new BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象  

			MemoryStream ms = new MemoryStream();//创建内存流对象  

			formatter.Serialize(ms, ds);//把DataSet对象序列化到内存流  

			byte[] buffer = ms.ToArray();//把内存流对象写入字节数组  

			ms.Close();//关闭内存流对象  

			ms.Dispose();//释放资源  

			FileStream fs = File.Create("datasetCompression.dat");//创建文件  

			GZipStream gzipStream = new GZipStream(fs, CompressionMode.Compress, true);//创建压缩对象  

			gzipStream.Write(buffer, 0, buffer.Length);//把压缩后的数据写入文件  
			gzipStream.Close();//关闭压缩流,这里要注意：一定要关闭，要不然解压缩的时候会出现小于4K的文件读取不到数据，大于4K的文件读取不完整              

			gzipStream.Dispose();//释放对象  

			fs.Close();//关闭流  

			fs.Dispose();//释放对象  
		}

		/// <summary>  
		/// 把byte[]压缩并返回压缩后的byte[]
		/// </summary>  
		/// <param name="dataArray"></param>  
		public static byte[] DataCompressionRetBytes(byte[] dataArray)
		{
			try
			{
				MemoryStream gzipms = new MemoryStream();//创建内存流对象  
				GZipStream gzipStream = new GZipStream(gzipms, CompressionMode.Compress, true);//创建压缩对象  

				gzipStream.Write(dataArray, 0, dataArray.Length);//把压缩后的数据写入文件  
				gzipStream.Close();//关闭压缩流,这里要注意：一定要关闭，要不然解压缩的时候会出现小于4K的文件读取不到数据，大于4K的文件读取不完整       
				Array.Clear(dataArray, 0, dataArray.Length);
				dataArray = null;
				byte[] retDataArray = gzipms.ToArray();
				gzipStream.Dispose();//释放对象  
				gzipms.Position = 0;
				return gzipms.ToArray();
			}
			catch
			{
				return new byte[0];
			}
		}
		/// <summary>  
		/// 解压缩并返回解压缩后的byte[]
		/// </summary>  
		/// <param name="dataArray"></param>  
		/// <returns></returns>  
		public static byte[] DataDecompressRetBytes(byte[] dataArray)
		{
			try
			{
				MemoryStream gzipms = new MemoryStream();//创建内存流对象  
				gzipms.Write(dataArray, 0, dataArray.Length);
				gzipms.Position = 0;
				GZipStream gzipStream = new GZipStream(gzipms, CompressionMode.Decompress);//创建解压对象  
				Array.Clear(dataArray, 0, dataArray.Length);
				dataArray = null;
				byte[] buffer = new byte[4096];
				int offset = 0;//定义读取位置  
				MemoryStream decompressms = new MemoryStream();//定义解压的内存流  

				while ((offset = gzipStream.Read(buffer, 0, buffer.Length)) != 0)
				{
					decompressms.Write(buffer, 0, offset);//解压后的数据写入内存流  
				}
				gzipms.Close();
				gzipms.Dispose();
				decompressms.Position = 0;

				byte[] retDataArray = decompressms.ToArray();
				decompressms.Close();//关闭内存流  
				decompressms.Dispose();//释放资源  
				gzipStream.Close();//关闭解压缩流  
				gzipStream.Dispose();//释放资源  
				return retDataArray;
			}
			catch
			{
				return new byte[0];
			}
		}
		/// <summary>  
		/// 序列化DataSet对象并压缩到byte[]
		/// </summary>  
		/// <param name="ds"></param>  
		public static byte[] DataSetSerializerCompressionRetBytes(DataSet ds)
		{
			IFormatter formatter = new BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象  

			MemoryStream ms = new MemoryStream();//创建内存流对象  

			formatter.Serialize(ms, ds);//把DataSet对象序列化到内存流  

			byte[] buffer = ms.ToArray();//把内存流对象写入字节数组  
			ds.Clear();
			ds.Dispose();
			ds = null;
			ms.Close();//关闭内存流对象  

			ms.Dispose();//释放资源  

			MemoryStream gzipms = new MemoryStream();//创建内存流对象  
			GZipStream gzipStream = new GZipStream(gzipms, CompressionMode.Compress, true);//创建压缩对象  

			gzipStream.Write(buffer, 0, buffer.Length);//把压缩后的数据写入文件  
			gzipStream.Close();//关闭压缩流,这里要注意：一定要关闭，要不然解压缩的时候会出现小于4K的文件读取不到数据，大于4K的文件读取不完整              

			gzipStream.Dispose();//释放对象  
			gzipms.Position = 0;
			byte[] retbuffer = gzipms.ToArray();
			gzipms.Close();
			gzipms.Dispose();
			return retbuffer;
		}
		/// <summary>  
		/// 不压缩直接序列化DataSet到byte[]
		/// </summary>  
		/// <param name="ds"></param>  
		public static byte[] DataSetSerializerRetBytes(DataSet ds)
		{
			IFormatter formatter = new BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象  

			MemoryStream ms = new MemoryStream();//创建内存流对象  

			formatter.Serialize(ms, ds);//把DataSet对象序列化到内存流  

			byte[] buffer = ms.ToArray();//把内存流对象写入字节数组  

			ms.Close();//关闭内存流对象  

			ms.Dispose();//释放资源  
			ds.Clear();
			ds.Dispose();
			ds = null;
			return buffer;
		}
		/// <summary>  
		/// 不压缩直接序列化DataSet  
		/// </summary>  
		/// <param name="ds"></param>  
		public static void DataSetSerializer(DataSet ds)
		{
			IFormatter formatter = new BinaryFormatter();//定义BinaryFormatter以序列化DataSet对象  

			FileStream fs = File.Create("dataset.dat");//创建文件  

			formatter.Serialize(fs, ds);//把DataSet对象序列化到文件  

			fs.Close();//关闭流  

			fs.Dispose();//释放对象  
		}

		/// <summary>  
		/// 反序列化压缩的DataSet  
		/// </summary>  
		/// <param name="_filePath"></param>  
		/// <returns></returns>  
		public static DataSet DataSetDeserializeDecompress(byte[] data)
		{
			MemoryStream gzipms = new MemoryStream();//创建内存流对象  
			gzipms.Write(data, 0, data.Length);
			gzipms.Position = 0;
			GZipStream gzipStream = new GZipStream(gzipms, CompressionMode.Decompress);//创建解压对象  

			byte[] buffer = new byte[4096];
			int offset = 0;//定义读取位置  
			MemoryStream decompressms = new MemoryStream();//定义解压的内存流  
			try
			{
				while ((offset = gzipStream.Read(buffer, 0, buffer.Length)) != 0)
				{
					decompressms.Write(buffer, 0, offset);//解压后的数据写入内存流  
				}

			}
			catch (Exception e)
			{
				throw e;
			}
			finally
			{
				gzipms.Close();
				gzipms.Dispose();
			}
			decompressms.Position = 0;
			decompressms.Seek(0, SeekOrigin.Begin);
			BinaryFormatter sfFormatter = new BinaryFormatter();//定义BinaryFormatter以反序列化DataSet对象  
			DataSet ds;

			try
			{
				ds = (DataSet)sfFormatter.Deserialize(decompressms);//反序列化  
			}
			catch
			{
				throw;
			}
			finally
			{
				decompressms.Close();//关闭内存流  
				decompressms.Dispose();//释放资源  
			}
			gzipStream.Close();//关闭解压缩流  
			gzipStream.Dispose();//释放资源  
			return ds;
		}
		/// <summary>  
		/// 反序列化压缩的DataSet  
		/// </summary>  
		/// <param name="_filePath"></param>  
		/// <returns></returns>  
		public static DataSet DataSetDeserializeDecompress(string _filePath)
		{
			FileStream fs = File.OpenRead(_filePath);//打开文件  

			fs.Position = 0;//设置文件流的位置  

			GZipStream gzipStream = new GZipStream(fs, CompressionMode.Decompress);//创建解压对象  

			byte[] buffer = new byte[4096];//定义数据缓冲  

			int offset = 0;//定义读取位置  

			MemoryStream ms = new MemoryStream();//定义内存流  

			while ((offset = gzipStream.Read(buffer, 0, buffer.Length)) != 0)
			{
				ms.Write(buffer, 0, offset);//解压后的数据写入内存流  
			}


			BinaryFormatter sfFormatter = new BinaryFormatter();//定义BinaryFormatter以反序列化DataSet对象  

			ms.Position = 0;//设置内存流的位置  

			DataSet ds;

			try
			{
				ds = (DataSet)sfFormatter.Deserialize(ms);//反序列化  
			}
			catch
			{
				throw;
			}
			finally
			{
				ms.Close();//关闭内存流  
				ms.Dispose();//释放资源  
			}
			fs.Close();//关闭文件流  
			fs.Dispose();//释放资源  
			gzipStream.Close();//关闭解压缩流  
			gzipStream.Dispose();//释放资源  
			return ds;
		}
		/// <summary>  
		/// 反序列化未压缩的DataSet  
		/// </summary>  
		/// <param name="_filePath"></param>  
		/// <returns></returns>  
		public static DataSet DataSetDeserialize(byte[] data)
		{
			MemoryStream gzipms = new MemoryStream();//创建内存流对象  
			gzipms.Write(data, 0, data.Length);
			gzipms.Position = 0;
			BinaryFormatter sfFormatter = new BinaryFormatter();//定义BinaryFormatter以反序列化DataSet对象  
			DataSet ds;

			try
			{
				ds = (DataSet)sfFormatter.Deserialize(gzipms);//反序列化  
			}
			catch
			{
				throw;
			}
			finally
			{
				gzipms.Close();//关闭内存流  
				gzipms.Dispose();//释放资源  
			}
			return ds;
		}
		/// <summary>  
		/// 反序列化未压缩的DataSet  
		/// </summary>  
		/// <param name="_filePath"></param>  
		/// <returns></returns>  
		public static DataSet DataSetDeserialize(string _filePath)
		{
			FileStream fs = File.OpenRead(_filePath);//打开文件  

			fs.Position = 0;//设置文件流的位置  

			BinaryFormatter sfFormatter = new BinaryFormatter();//定义BinaryFormatter以反序列化DataSet对象  

			DataSet ds;

			try
			{
				ds = (DataSet)sfFormatter.Deserialize(fs);//反序列化  
			}
			catch
			{
				throw;
			}
			finally
			{
				fs.Close();//关闭内存流  
				fs.Dispose();//释放资源  
			}
			fs.Close();//关闭文件流  
			fs.Dispose();//释放资源  
			return ds;
		}

		/* static void Main(string[] args)
		 {


			 DataSet dataSet = new DataSet();

			 DataSetSerializer(dataSet);
			 DataSetSerializerCompression(dataSet);
		 }  */
	}
}