C#对象深拷贝DeepClone

#region 程序集 Kingdee.BOS, Version=7.7.2388.8, Culture=neutral, PublicKeyToken=null
// D:\WorkSpace\K3Cloud\BIN\Kingdee.BOS.dll
// Decompiled with ICSharpCode.Decompiler 3.1.0.3652
#endregion
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Xml.Serialization;

namespace Kingdee.BOS.Util
{
	public static class ObjectUtils
	{
		/// <summary>
		/// 判断指定的对象是否是空引用，或空字符串。
		/// </summary>
		/// <param name="value">需要测试的对象</param>
		/// <returns>如果 value 参数为空引用或空字符串 ("")，则为 true；否则为 false。</returns>
		public static bool IsNullOrEmpty(this object value)
		{
			if (value != null && value != DBNull.Value && value.ToString().Length != 0)
			{
				return false;
			}
			return true;
		}

		/// <summary>
		/// 判断指定的对象是否是空引用，或空字符串， 或空白字符。
		/// </summary>
		/// <param name="value">需要测试的对象</param>
		/// <returns>如果 value 参数为空引用或空字符串 ("")或空白字符，则为 true；否则为 false。</returns>
		public static bool IsNullOrEmptyOrWhiteSpace(this object value)
		{
			if (value != null && value != DBNull.Value && value.ToString().Length != 0 && !string.IsNullOrWhiteSpace(value.ToString()))
			{
				return false;
			}
			return true;
		}

		/// <summary>
		/// 为对象创建一个拷贝
		/// </summary>
		/// <param name="obj">需要创建拷贝的对象</param>
		/// <returns>新建立的拷贝对象</returns>
		public static object CreateCopy(object obj)
		{
			return CreateCopy(obj, FormatterType.BinaryFormatter);
		}

		/// <summary>
		/// 为对象创建一个拷贝
		/// </summary>
		/// <param name="obj">需要创建拷贝的对象</param>
		/// <param name="formatterType">格式类型</param>
		/// <returns>新建立的拷贝对象</returns>
		public static object CreateCopy(object obj, FormatterType formatterType)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (obj == null)
			{
				return null;
			}
			object obj2 = null;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				IFormatter formatter = null;
				formatter = ((formatterType != FormatterType.NetDataContract) ? new BinaryFormatter() : ((IFormatter)new NetDataContractSerializer()));
				formatter.Serialize(memoryStream, obj);
				memoryStream.Position = 0L;
				obj2 = formatter.Deserialize(memoryStream);
				memoryStream.Close();
				memoryStream.Dispose();
				formatter = null;
				return obj2;
			}
		}

		/// <summary>
		/// 将对象序列化为字节流
		/// </summary>
		/// <param name="obj">需要序列化的对象</param>
		/// <returns>序列化后的字节流</returns>
		public static byte[] GetObjectSream(object obj)
		{
			if (obj == null)
			{
				return null;
			}
			byte[] array = null;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				IFormatter formatter = new BinaryFormatter();
				formatter.Serialize(memoryStream, obj);
				array = memoryStream.ToArray();
				memoryStream.Close();
				memoryStream.Dispose();
				return array;
			}
		}

		/// <summary>
		/// 将字节流反序列化为对象
		/// </summary>
		/// <param name="bytes">需要反序列化的字节流</param>
		/// <returns>反序列化后的对象</returns>
		public static object GetObject(byte[] bytes)
		{
			if (bytes == null)
			{
				return null;
			}
			object obj = null;
			using (MemoryStream memoryStream = new MemoryStream(bytes))
			{
				IFormatter formatter = new BinaryFormatter();
				obj = formatter.Deserialize(memoryStream);
				memoryStream.Close();
				memoryStream.Dispose();
				return obj;
			}
		}

		/// <summary>
		/// 判断返回主键值是否是一个无效的值。
		/// </summary>
		/// <param name="pkValue">主键值</param>
		/// <returns>主键值是一个无效的值，则为 true；否则为 false。</returns>
		public static bool IsEmptyPrimaryKey(this object pkValue)
		{
			if (pkValue == null)
			{
				return true;
			}
			string text = pkValue as string;
			if (text != null)
			{
				return string.IsNullOrWhiteSpace(text);
			}
			if (pkValue is int)
			{
				return (int)pkValue == 0;
			}
			if (pkValue is long)
			{
				return (long)pkValue == 0;
			}
			if (pkValue.GetType().IsValueType)
			{
				object objA = Activator.CreateInstance(pkValue.GetType());
				return object.Equals(objA, pkValue);
			}
			return false;
		}

		/// <summary>
		/// 返回字符串
		/// </summary>
		/// <param name="obj"></param>
		/// <returns></returns>
		public static string Object2String(object obj)
		{
			if (obj != null)
			{
				return obj.ToString();
			}
			return "";
		}

		/// <summary>
		/// 得到对象对应的数值
		/// </summary>
		/// <param name="obj">要转换的对象</param>
		/// <param name="iDefaultValue">默认值</param>
		/// <returns>得到的int值</returns>
		public static int Object2Int(object obj, int iDefaultValue = 0)
		{
			if (obj.IsNullOrEmptyOrWhiteSpace())
			{
				return iDefaultValue;
			}
			try
			{
				return Convert.ToInt32(obj);
			}
			catch
			{
				return iDefaultValue;
			}
		}

		/// <summary>
		/// 得到对象对应的数值
		/// </summary>
		/// <param name="obj">要转换的对象</param>
		/// <param name="iDefaultValue">默认值</param>
		/// <returns>得到的bool值</returns>
		public static bool Object2Bool(object obj, bool iDefaultValue = false)
		{
			if (obj.IsNullOrEmptyOrWhiteSpace())
			{
				return iDefaultValue;
			}
			try
			{
				return Convert.ToBoolean(obj);
			}
			catch
			{
				return iDefaultValue;
			}
		}

		/// <summary>
		/// 得到对象对应的数值
		/// </summary>
		/// <param name="obj">要转换的对象</param>
		/// <param name="iDefaultValue">默认值</param>
		/// <returns>得到的int值</returns>
		public static long Object2Int64(object obj, long iDefaultValue = 0L)
		{
			if (obj.IsNullOrEmptyOrWhiteSpace())
			{
				return iDefaultValue;
			}
			tr