class CsToD
{
   //基本思想是：一个对象所占据的内存空间，取决于它的实例字段（包括继承树上的私有实例字段）
   public T DeepCloneObject<T>(T obj) where T : class
   {
      //System.String类型似乎比较特殊，复制它的所有字段，并不能复制它本身
      //不过由于System.String的不可变性，即使指向同一对象，也无所谓
      //而且.NET里本来就用字符串池来维持
      if (obj == null || obj.GetType() == typeof(string))
      return obj;
      object newObj = null;
      try
      {
         //尝试调用默认构造函数
         newObj = Activator.CreateInstance(obj.GetType());
      }
      catch
      {
         //失败的话，只好枚举构造函数了
         foreach (ConstructorInfo ci in obj.GetType().GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
         {
            try
            {
               ParameterInfo[] pis = ci.GetParameters();
               object[] objs = new object[pis.Length];
               for (int i = 0; i < pis.Length; i++)
               {
                  if (pis[i].ParameterType.IsValueType)
                  objs[i] = Activator.CreateInstance(pis[i].ParameterType);
                  else
                  //参数类型可能是抽象类或接口，难以实例化
                  //我能想到的就是枚举应用程序域里的程序集，找到实现了该抽象类或接口的类
                  //但显然过于复杂了
                  objs[i] = null;
               }
               newObj = ci.Invoke(objs);
               //无论调用哪个构造函数，只要成功就行了
               break;
            }
            catch
            {
            }
         }
      }
      foreach (FieldInfo fi in obj.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
      {
         if (fi.FieldType.IsValueType || fi.FieldType == typeof(string))
         fi.SetValue(newObj, fi.GetValue(obj));
         else
         fi.SetValue(newObj, DeepCloneObject(fi.GetValue(obj)));
      }
      //基类的私有实例字段在子类里检索不到，但它仍占据子类对象的内存空间
      Deep(newObj, obj);
      return (T)newObj;
   }
   
   //克隆继承树上的私有实例字段
   public void Deep(object newObj, object obj)
   {
      for (Type father = newObj.GetType().BaseType; father != typeof(object); father = father.BaseType)
      {
         foreach (FieldInfo fi in father.GetFields(BindingFlags.NonPublic | BindingFlags.Instance))
         {
            //只需要处理私有字段，因为非私有成员已经在子类处理过了
            if (fi.IsPrivate)
            {
               if (fi.FieldType.IsValueType || fi.FieldType == typeof(string))
               {
                  fi.SetValue(newObj, fi.GetValue(obj));
               }
               else
               {
                  fi.SetValue(newObj, DeepCloneObject(fi.GetValue(obj)));
               }
            }
         }
      }
   }
}

class Program
{
   static void Main()
   {
      Data3 data3 = new Data3();
      Data data = new Data(data3);
      data.PriValue = "Pri";
      data.Integer = 3;
      
      
      //修改cloneData对象，并未影响到data对象，说明克隆成功
      CsToD ctd = new CsToD();
      Data cloneData = ctd.DeepCloneObject(data);
      cloneData.Integer = 1000;
      cloneData.PriValue = "clone";
      cloneData.Value.D3String = "clonestr";
      Console.WriteLine(data.Integer + "<->" + cloneData.Integer);
      Console.WriteLine(data.PriValue + "<->" + cloneData.PriValue);
      Console.WriteLine(data.Value.D3String + "<->" + cloneData.Value.D3String);
      
      
      //而如果修改refData对象，data对象也被改变，说明是同一对象
      Data refData = data;
      refData.Integer = 555;
      refData.PriValue = "ref";
      refData.Value.D3String = "refstr";
      Console.WriteLine(data.Integer + "<->" + refData.Integer);
      Console.WriteLine(data.PriValue + "<->" + refData.PriValue);
      Console.WriteLine(data.Value.D3String + "<->" + refData.Value.D3String);
   }
}
class Data:Data2
{
   public Data(Data3 value)
   {
      this.Value = value;
   }
   public Data() { }
   public Data3 Value;
   
}
class Data2
{
   public Data2(int value)
   {
      this.Integer = value;
   }
   public string PriValue
   {
      get
      {
         return priValue;
      }
      set
      {
         priValue = value;
      }
   }
   public Data2() { }
   public int Integer;
   private string priValue;
}
class Data3
{
   public Data3()
   {
      D3String = "D3";
      d3Integer = 3;
   }
   public string D3String;
   private int d3Integer;
}