using System;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Text;
|
using System.Xml.Serialization;
|
using System.IO;
|
using System.Xml;
|
using System.Security.Cryptography;
|
|
namespace CY.Infrastructure.Common
|
{
|
/// <summary>
|
/// 序列化帮助类
|
/// </summary>
|
public class SerializationHelper
|
{
|
private SerializationHelper()
|
{
|
}
|
private static Dictionary<int, XmlSerializer> serializer_dict = new Dictionary<int, XmlSerializer>();
|
public static XmlSerializer GetSerializer(Type t)
|
{
|
int type_hash = t.GetHashCode();
|
|
if (!serializer_dict.ContainsKey(type_hash))
|
serializer_dict.Add(type_hash, new XmlSerializer(t));
|
|
return serializer_dict[type_hash];
|
}
|
|
/// <summary>
|
/// 反序列化
|
/// </summary>
|
/// <param name="type">对象类型</param>
|
/// <param name="filename">文件路径</param>
|
/// <returns></returns>
|
public static object Load(Type type, string filename)
|
{
|
FileStream fs = null;
|
try
|
{
|
// open the stream...
|
fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
|
XmlSerializer serializer = new XmlSerializer(type);
|
return serializer.Deserialize(fs);
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
finally
|
{
|
if (fs != null)
|
fs.Close();
|
}
|
}
|
|
|
/// <summary>
|
/// 序列化
|
/// </summary>
|
/// <param name="obj">对象</param>
|
/// <param name="filename">文件路径</param>
|
public static bool Save(object obj, string filename)
|
{
|
bool success = false;
|
|
FileStream fs = null;
|
// serialize it...
|
try
|
{
|
fs = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
|
XmlSerializer serializer = new XmlSerializer(obj.GetType());
|
serializer.Serialize(fs, obj);
|
success = true;
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
finally
|
{
|
if (fs != null)
|
fs.Close();
|
}
|
return success;
|
|
}
|
|
/// <summary>
|
/// xml序列化成字符串
|
/// </summary>
|
/// <param name="obj">对象</param>
|
/// <returns>xml字符串</returns>
|
public static string Serialize(object obj)
|
{
|
string returnStr = "";
|
XmlSerializer serializer = new XmlSerializer(obj.GetType());
|
MemoryStream ms = new MemoryStream();
|
XmlTextWriter xtw = null;
|
StreamReader sr = null;
|
try
|
{
|
xtw = new System.Xml.XmlTextWriter(ms, Encoding.UTF8);
|
xtw.Formatting = System.Xml.Formatting.Indented;
|
serializer.Serialize(xtw, obj);
|
ms.Seek(0, SeekOrigin.Begin);
|
sr = new StreamReader(ms);
|
returnStr = sr.ReadToEnd();
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
finally
|
{
|
if (xtw != null)
|
xtw.Close();
|
if (sr != null)
|
sr.Close();
|
ms.Close();
|
}
|
return returnStr;
|
|
}
|
|
/// <summary>
|
/// 反序列化实体
|
/// </summary>
|
/// <param name="type"></param>
|
/// <param name="s"></param>
|
/// <returns></returns>
|
public static object DeSerialize(Type type, string s)
|
{
|
byte[] b = System.Text.Encoding.UTF8.GetBytes(s);
|
try
|
{
|
XmlSerializer serializer = new XmlSerializer(type);
|
return serializer.Deserialize(new MemoryStream(b));
|
}
|
catch (Exception ex)
|
{
|
throw ex;
|
}
|
}
|
|
private static byte[] Keys = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF };
|
|
/// <summary>
|
/// DES加密字符串
|
/// </summary>
|
/// <param name="encryptString">待加密的字符串</param>
|
/// <param name="encryptKey">加密密钥,要求为8位</param>
|
/// <returns>加密成功返回加密后的字符串，失败返回源串 </returns>
|
public static string EncryptDES(string encryptString, string encryptKey)
|
{
|
try
|
{
|
byte[] rgbKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, 8));//转换为字节
|
byte[] rgbIV = Keys;
|
byte[] inputByteArray = Encoding.UTF8.GetBytes(encryptString);
|
DESCryptoServiceProvider dCSP = new DESCryptoServiceProvider();//实例化数据加密标准
|
MemoryStream mStream = new MemoryStream();//实例化内存流
|
//将数据流链接到加密转换的流
|
CryptoStream cStream = new CryptoStream(mStream, dCSP.CreateEncryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
|
cStream.Write(inputByteArray, 0, inputByteArray.Length);
|
cStream.FlushFinalBlock();
|
return Convert.ToBase64String(mStream.ToArray());
|
}
|
catch
|
{
|
return encryptString;
|
}
|
}
|
|
/// <summary>
|
/// DES解密字符串
|
/// </summary>
|
/// <param name="decryptString">待解密的字符串</param>
|
/// <param name="decryptKey">解密密钥,要求为8位,和加密密钥相同</param>
|
/// <returns>解密成功返回解密后的字符串，失败返源串</returns>
|
public static string DecryptDES(string decryptString, string decryptKey)
|
{
|
try
|
{
|
byte[] rgbKey = Encoding.UTF8.GetBytes(decryptKey);
|
byte[] rgbIV = Keys;
|
byte[] inputByteArray = Convert.FromBase64String(decryptString);
|
DESCryptoServiceProvider DCSP = new DESCryptoServiceProvider();
|
MemoryStream mStream = new MemoryStream();
|
CryptoStream cStream = new CryptoStream(mStream, DCSP.CreateDecryptor(rgbKey, rgbIV), CryptoStreamMode.Write);
|
cStream.Write(inputByteArray, 0, inputByteArray.Length);
|
cStream.FlushFinalBlock();
|
return Encoding.UTF8.GetString(mStream.ToArray());
|
}
|
catch
|
{
|
return decryptString;
|
}
|
}
|
|
|
}
|
}
|
