C# 深拷贝源码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml;
using System.Reflection;

namespace RTDevSoftFucFrame
{
/// <summary>自动存储基类接口
/// 实现GetRTSaveObjID接口， 可在对象内部保存一个string类型对象，
/// 利用RTAutoSaveHelp.MakeRTSaveObjID()函数返回的结果对其初始化，
/// 在GetRTSaveObjID接口实现中返回
/// </summary>
public interface RTAutoSaveInterface
    {
string GetRTSaveObjID();
    }

/// <summary>自动保存辅助类</summary>
static public class RTAutoSaveHelp
    {
// static int Num = 0;
/// <summary>生成存储标示ID号</summary>
/// <returns></returns>
public static string MakeRTSaveObjID()
        {
/* 测试用
 Console.WriteLine(Num.ToString());
 return Num++ + "";
 */
            Guid NewGuid = Guid.NewGuid();
//Console.WriteLine(NewGuid.ToString());
return NewGuid.ToString();

        }
    }

/// <summary>对于保存字段的配置特征
/// 用法如 [RTDevSoftFucFrame.RTAutoSaveField(true)]
/// </summary>
    [AttributeUsage(AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
public class RTAutoSaveFieldAttribute : Attribute
    {
/// <summary>构造函数</summary>
/// <param name="RefOtherObj">是否聚合引用的其他对象</param>
/// <param name="SaveField">是否保存此字段</param>
public RTAutoSaveFieldAttribute(bool RefOtherObj, bool SaveField = true)
        {
            _RefOther = RefOtherObj;
            _SaveThisField = SaveField;
        }

private bool _RefOther = false;
public bool RefOther
        {
get { return (_RefOther); }
set { _RefOther = value; }
        }

private bool _SaveThisField = true;
public bool SaveThisField
        {
get { return (_SaveThisField); }
set { _SaveThisField = value; }
        }
    }

internal class RTAnyObjectLoadInf
    {
public List<Object> m_AllObj = new List<Object>();
/// <summary>ID和对象映射关系的字典</summary>
public Dictionary<String, Object> m_AllIdAndObj = new Dictionary<String, Object>();

/// <summary>通过ID获得接口对象</summary>
/// <param name="RTSaveObjID"></param>
/// <returns></returns>
public RTAutoSaveInterface GetRTAutoSaveInterfaceObjFromID(string RTSaveObjID)
        {
            RTAutoSaveInterface RefObj = null;
for (int j = 0; j < m_AllObj.Count; j++)
            {
                RTAutoSaveInterface RTAutoSaveInterfaceObj = m_AllObj[j] as RTAutoSaveInterface;

if (RTAutoSaveInterfaceObj != null)
                {
if (RTAutoSaveInterfaceObj.GetRTSaveObjID() == RTSaveObjID)
                    {
                        RefObj = RTAutoSaveInterfaceObj;
break;
                    }
                }
            }

return RefObj;
        }
/// <summary>通过ID获得普通对象</summary>
/// <param name="RTSaveObjID"></param>
/// <returns></returns>
public Object GetRTObjFromID(string RTSaveObjID)
        {   // 查字典获取到对应id的对象
try
            {
return m_AllIdAndObj[RTSaveObjID];
            }
catch (Exception e)
            {
var ex1 = new System.Exception(e.Message);
throw ex1;
            }
        }

//参照方式的信息
public List<Object> m_ObjParentList = new List<Object>();
public List<String> m_ParNameList = new List<String>();
public List<XmlElement> m_XMLNodeList = new List<XmlElement>();
public List<bool> m_IsList = new List<bool>();                    //是否是List变量
    }

/// <summary>保存属性</summary>
internal class RTSaveProperty
    {
public XmlElement ParentXMLNode = null;
public XmlDocument Xmldoc = null;
    }

/// <summary>保存读取过程中异常信息</summary>
public class RefObjIsNotRTAutoSaveInterfaceException : ApplicationException
    {
/// <summary>
/// 默认构造函数
/// </summary>
public RefObjIsNotRTAutoSaveInterfaceException() { }

public RefObjIsNotRTAutoSaveInterfaceException(string message)
            : base(message)
        { }

public RefObjIsNotRTAutoSaveInterfaceException(string message, Exception inner)
            : base(message, inner)
        { }
    }

/// <summary>对象的自动保存</summary>
public class RTObjectAutoSave
    {
private const string RefObjAttStrFlag = "RefObjID_17CB4EAD";
private const string TrueTypeAttStrFlag = "TrueType_17CB4EAD";
private const string ValueAttStrFlag = "Value_17CB4EAD";
private const string TypeAssambleAttStrFlag = "TypeAssamble_17CB4EAD";
private const string IsClassNullAttStrFlag = "IsClassNull_17CB4EAD";
/// <summary>标识是否自编ID</summary>
private static Boolean m_IsMakeID = false;
/// <summary>对象及其id的字典</summary>
private static Dictionary<Object, string> m_ObjIdDict = new Dictionary<object, string>();
/// <summary>引用对象的字典</summary>
private static Dictionary<Object, XmlElement> m_RefObjDict = new Dictionary<object, XmlElement>();
/// <summary>根节点(待完善)</summary>
private static RTObjectTreeNode m_ObjRootNode = new RTObjectTreeNode();

/// <summary>标识对象是否是继承于自动保存接口对象的布尔值（默认为True）</summary>
public static Boolean IsMakeID
        {
get { return RTObjectAutoSave.m_IsMakeID; }
set { RTObjectAutoSave.m_IsMakeID = value; }
        }

/// <summary>写入一个Object到XMLNode</summary>
/// <param name="SaveRTAnyObject">保存的对象</param>
/// <param name="SaveParentXMLNode">保存到的XMLNode</param>
/// <returns></returns>
public static bool SaveRTObjectToXML(Object SaveRTAnyObject, XmlElement SaveParentXMLNode)
        {
if (SaveRTAnyObject is RTAutoSaveInterface) m_IsMakeID = false;
else m_IsMakeID = true;
try
            {
// 创建一个保存属性，并将 XmlDoc 和 Xml 节点赋值进去
                RTSaveProperty parentSave = new RTSaveProperty();
                parentSave.ParentXMLNode = SaveParentXMLNode;
                parentSave.Xmldoc = SaveParentXMLNode.OwnerDocument;
// 
                Boolean Result = SaveOneRTObject(parentSave, SaveRTAnyObject);
// 如果是自我生成编号即非继承于自动保存接口
if (m_IsMakeID)
foreach (Object Obj in m_RefObjDict.Keys)
                    {   // 对引用对象字典遍历，去对象字典搜索获得值
if (m_ObjIdDict.Keys.Contains(Obj))
                            m_RefObjDict[Obj].Attributes[RefObjAttStrFlag].Value = m_ObjIdDict[Obj];
                    }
return Result;
            }
catch (RefObjIsNotRTAutoSaveInterfaceException ex)
            {
var ex1 = new System.Exception(ex.Message);
throw ex1;
            }
finally { }
        }

/// <summary>从XMLNode读取Object</summary>
/// <param name="SaveRTAnyObject">读取的对象</param>
/// <param name="SaveParentXMLNode">XMLNode</param>
/// <returns></returns>
public static bool LoadRTObjectFromXML(Object SaveRTAnyObject, XmlElement LoadParentXMLNode)
        {
if (SaveRTAnyObject is RTAutoSaveInterface) m_IsMakeID = false;
else m_IsMakeID = true;
// 创建一个保存属性，并将 XmlDoc 和 Xml 节点赋值进去
            RTSaveProperty parentSave = new RTSaveProperty();
            parentSave.ParentXMLNode = LoadParentXMLNode;
            parentSave.Xmldoc = LoadParentXMLNode.OwnerDocument;

return LoadRTObject(parentSave, SaveRTAnyObject);
        }

/// <summary>写入一个变量</summary>
/// <param name="parentSave">辅助数据</param>
/// <param name="SaveRTAnyObject">保存的对象</param>
/// <returns></returns>
private static bool SaveOneRTObject(RTSaveProperty parentSave, Object SaveRTAnyObject)
        {
            Type ClassType = SaveRTAnyObject.GetType();
return SaveRTParWithType(parentSave, SaveRTAnyObject, ClassType);
        }

delegate bool SaveParDelagate(XmlElement ParXMLNode, Object SavePar, Type SaveParType); 

/// <summary>写入一个变量</summary>
/// <param name="parentSave">辅助数据</param>
/// <param name="SaveRTAnyObject">读取的对象</param>
/// <param name="ClassType">当前读取对象继承层次中的类型</param>
/// <returns></returns>
private static bool SaveRTParWithType(RTSaveProperty parentSave, Object SaveRTAnyObject, Type ClassType)
        {
// 获取保存对象类型的基类型
            Type BaseClassType = ClassType.BaseType;
// 深拷贝一个保存属性 BaseSave
            RTSaveProperty BaseSaveProperty = Copy(parentSave);
// 递归判断，如果基类型是 Object，则退出递归；否则继续递归寻找基类型
if (BaseClassType != null && BaseClassType.FullName != "System.Object" && !BaseClassType.Name.Contains("`"))
            {
// 根据基类型创建一个 XmlNode 
                XmlElement NewNode = parentSave.Xmldoc.CreateElement("BaseClass_" + BaseClassType.Name);
                XmlAttribute RTObjID = parentSave.Xmldoc.CreateAttribute("m_RTObjID_17CB4EAD");
                RTObjID.Value = "";
if (m_IsMakeID && !m_ObjIdDict.Keys.Contains(SaveRTAnyObject))
                {
// 自编id
                    RTObjID.Value = RTAutoSaveHelp.MakeRTSaveObjID();
                    NewNode.Attributes.Append(RTObjID);
                    m_ObjIdDict.Add(SaveRTAnyObject, RTObjID.Value);
                }
                BaseSaveProperty.ParentXMLNode = NewNode;
                parentSave.ParentXMLNode.AppendChild(NewNode);
                SaveRTParWithType(BaseSaveProperty, SaveRTAnyObject, BaseClassType);
            }


            FieldInfo[] myFields = ClassType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);

for (int i = 0; i < myFields.Length; i++)
            {
string ParName = myFields[i].Name;
object ParVal = myFields[i].GetValue(SaveRTAnyObject);

//空值保存
if (ParVal == null)
                {
                    parentSave.ParentXMLNode.SetAttribute(ParName, "null");
continue;
                }
                Type ParType = null;
try
                {
//此处必须取变量值得类型,不能取字段类型
                    ParType = ParVal.GetType();  //myFields[i].FieldType;
                }
catch (Exception ex)
                {
// 抛出异常，引用对象不是自动保存接口
                    ex = new RefObjIsNotRTAutoSaveInterfaceException(ClassType.FullName + "中的变量:" +
                        ParName + "以RTAutoSaveField特征标记引用方式引用了非RTAutoSaveInterface变量");
throw ex;
                }

bool IsRefOther = false;
bool SaveThisField = true;
object[] attrs111 = myFields[i].GetCustomAttributes(true);
foreach (object obj in attrs111)
                {
                    RTAutoSaveFieldAttribute att = obj as RTAutoSaveFieldAttribute;
if (att != null)
                    {
                        IsRefOther = att.RefOther;
                        SaveThisField = att.SaveThisField;
                    }
                }
//此Field不存储
if (!SaveThisField)
                {
continue;
                }

/////////////////////////////////////////匿名方法:保存一个Class类型变量//////////////////////////////////////////
                SaveParDelagate SaveParDelagateObj = delegate(XmlElement ParXMLNode, Object SaveParVal, Type SaveParType)
                {
// 如果是引用对象
if (IsRefOther)
                    {
if (!m_IsMakeID)
                        {
// 将需要保存的数值类型转换为自动保存接口
                            RTAutoSaveInterface ItemFDD = SaveParVal as RTAutoSaveInterface;
// 如果转换后的数值类型为空
if (ItemFDD == null)
                            {   // 抛出异常，引用对象不是自动保存接口
var ex = new RefObjIsNotRTAutoSaveInterfaceException(ClassType.FullName + "中的变量:" +
                                    ParName + "以RTAutoSaveField特征标记引用方式引用了非RTAutoSaveInterface变量");
throw ex;
                            }
// 为xml节点设置属性为id
                            ParXMLNode.SetAttribute(RefObjAttStrFlag, (SaveParVal as RTAutoSaveInterface).GetRTSaveObjID());
                        }
else
                        {
// 为xml节点设置属性id
if (!m_ObjIdDict.Keys.Contains(SaveParVal))
                            {
if (!m_RefObjDict.ContainsKey(SaveParVal))
                                    m_RefObjDict.Add(SaveParVal, ParXMLNode);
                                ParXMLNode.SetAttribute(RefObjAttStrFlag, null);
                            }
else
                            {
                                ParXMLNode.SetAttribute(RefObjAttStrFlag, m_ObjIdDict[SaveParVal]);
                            }
                        }
                    }
else // 如果不是引用对象
                    {
//存储变量存储时的真实类型,供反序列化时创建真实类型(针对对于基类或dynamic变量引用时如此处理)
                        ParXMLNode.SetAttribute(TrueTypeAttStrFlag, SaveParType.FullName);  // 类型名
                        ParXMLNode.SetAttribute(TypeAssambleAttStrFlag, SaveParType.Assembly.ManifestModule.Name);  // 程序集名
// 深拷贝一个辅助数据
                        RTSaveProperty NewFIDSaveProperty = Copy(parentSave);
// 设置其xml节点
                        NewFIDSaveProperty.ParentXMLNode = ParXMLNode;

                        SaveOneRTObject(NewFIDSaveProperty, SaveParVal);
                    }

return true;
                }; 
//////////////////////////////////////////////

//值类型
if (!ParType.IsClass || ParType.FullName == "System.String")
                {
if (!ParName.Contains("17CB4EAD"))
                        parentSave.ParentXMLNode.SetAttribute(ParName, ParVal.ToString());
                }
else if (ParType.FullName.Contains(@"System.Collections.Generic"))
                {
                    Type[] ListGenTypes = ParType.GetGenericArguments();
                    Type GenType = ListGenTypes[0];

                    XmlElement NewNode = parentSave.Xmldoc.CreateElement(ParName);

                    dynamic ListObj = ParVal;

for (int j = 0; j < ListObj.Count; j++)
                    {
                        XmlElement NewNode2 = parentSave.Xmldoc.CreateElement(ParName + "_One");

                        Object ItemObj = ListObj[j] as Object;
if(ItemObj != null)
                        {
                            Type ItemObjType = ItemObj.GetType();

if (!ItemObjType.IsClass || ParType.FullName == "System.String")
                            {
                                Type ListParType = ListObj[j].GetType();
if (!ListParType.IsClass || ListParType.FullName == "System.String")
                                {
                                    NewNode2.SetAttribute(TrueTypeAttStrFlag, ListParType.FullName);
                                    NewNode2.SetAttribute(ValueAttStrFlag, ListObj[j].ToString());
                                }
else
                                {
continue;
                                }
                            }
else
                            {
                                SaveParDelagateObj(NewNode2, ItemObj, ItemObjType);
                            }
                        }
else
                        {
                            NewNode2.SetAttribute(IsClassNullAttStrFlag, "true");
                        }

                        NewNode.AppendChild(NewNode2);
                    }

                    parentSave.ParentXMLNode.AppendChild(NewNode);
                }
else if (ParType.IsClass)
                {
                    XmlElement NewNode = parentSave.Xmldoc.CreateElement(ParName);
if (ParVal == null)
                    {
continue;
                    }
                    SaveParDelagateObj(NewNode, ParVal, ParType);

                    parentSave.ParentXMLNode.AppendChild(NewNode);
                }

            }


return true;
        }

/// <summary>读取一个变量</summary>
/// <param name="parentSave">辅助数据</param>
/// <param name="SaveRTAnyObject">读取的对象</param>
/// <param name="AllLoadInf">存储所有读取的数据,及二次赋值时需要的</param>
/// <returns></returns>
private static bool LoadRTObject(RTSaveProperty parentSave, Object SaveRTAnyObject)
        {
            Type ClassType = SaveRTAnyObject.GetType();

            RTAnyObjectLoadInf AllLoadInf = new RTAnyObjectLoadInf();

bool IsLoadOK = LoadRTParWithType(parentSave, SaveRTAnyObject, ClassType, AllLoadInf);

bool IsTwoOK = TwoStepDo(AllLoadInf);

return IsLoadOK && IsTwoOK;
        }

//由字符串和值变量类型，解析得到相应的值
private static Object ParseStringToValueObj(string ValueStr, Type ValueType)
        {
            Object ValueObj = null;
if (ValueStr.Equals("")) return null;
if (ValueType.IsEnum)
            {
                ValueObj = Enum.Parse(ValueType, ValueStr);
            }
else if (ValueType.IsValueType)
            {
                Type[] FunParTypes = new Type[1];
                FunParTypes[0] = typeof(string);

var ValMethod = ValueType.GetMethod("Parse", FunParTypes);

object TemSimpleObj = ValueType.Assembly.CreateInstance(ValueType.FullName);
object ReVal = ValMethod.Invoke(TemSimpleObj, new object[] { ValueStr });

                ValueObj = ReVal;
            }
else   //String类型
            {
                ValueObj = ValueStr;
            }

return ValueObj;
        }
private static Object CreateClassObjFromSaveXMLNode(XmlElement ThisFieldNode)
        {

            Object ParVal = null;
if (ThisFieldNode != null)
            {
string TrueTypeFullName = ThisFieldNode.GetAttribute(TrueTypeAttStrFlag);
string AssambleModuleName = ThisFieldNode.GetAttribute(TypeAssambleAttStrFlag);

if (!string.IsNullOrEmpty(TrueTypeFullName) && !string.IsNullOrEmpty(TrueTypeFullName))
                {
                    Assembly ParDefAsmb = Assembly.LoadFrom(AssambleModuleName);
                    dynamic ParTrueobj = null;
if (TrueTypeFullName.Equals("System.Double[]"))
                    {
                        ParTrueobj = Array.CreateInstance(typeof(Double), 100);
                    }
else if (TrueTypeFullName.Equals("System.String"))
                    {
                        ParTrueobj = Activator.CreateInstance(typeof(String), new char[]{' '});
                    }
else
                    {
                        ParTrueobj = ParDefAsmb.CreateInstance(TrueTypeFullName, true);
                    }
if (ParTrueobj != null)
                    {
                        ParVal = ParTrueobj;
                    }
                }
else
                {
// 通过ID查找到xml节点（可改对象树）
string RefObjId = ThisFieldNode.GetAttribute(RefObjAttStrFlag);
                    XmlDocument XmlDoc = ThisFieldNode.OwnerDocument;
                    XmlNode FindNode = null;
                    FindNode = SearchNode(XmlDoc.FirstChild, RefObjId, FindNode);
if (FindNode != null)
                    {
return CreateClassObjFromSaveXMLNode(FindNode as XmlElement);
                    }
                }
            }

return ParVal;
        }

/// <summary>读取一个变量</summary>
/// <param name="parentSave">辅助数据</param>
/// <param name="SaveRTAnyObject">读取的对象</param>
/// <param name="ClassType">当前读取对象继承层次中的类型</param>
/// <param name="AllLoadInf">存储所有读取的数据,及二次赋值时需要的</param>
/// <param name="BaseCal">是否基类方式调用</param>
/// <returns></returns>
private static bool LoadRTParWithType(RTSaveProperty parentSave, Object SaveRTAnyObject, Type ClassType, RTAnyObjectLoadInf AllLoadInf, bool BaseCal = false)
        {
            Type BaseClassType = ClassType.BaseType;
if (!BaseCal)
            {
// TODO 添加id和对象的映射关系
                AllLoadInf.m_AllObj.Add(SaveRTAnyObject);
            }

            RTSaveProperty BaseSaveProperty = Copy(parentSave);
if (BaseClassType.FullName != "System.Object")
            {
// 找到基类xml节点
if (parentSave.ParentXMLNode == null) return false;
                XmlElement SelNode = (XmlElement)parentSave.ParentXMLNode.SelectSingleNode("BaseClass_" + BaseClassType.Name);
                BaseSaveProperty.ParentXMLNode = SelNode;

//基类数据读入
                LoadRTParWithType(BaseSaveProperty, SaveRTAnyObject, BaseClassType, AllLoadInf, true);
            }

// 基类的所有属性
            FieldInfo[] AllFields = ClassType.GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);

for (int i = 0; i < AllFields.Length; i++)
            {
bool IsRefOtherObj = false;     //是否引用其他参数
bool SaveThisField = true;
//读取Field特征参数
                {
object[] FieldAttrs = AllFields[i].GetCustomAttributes(true);
foreach (object obj in FieldAttrs)
                    {
                        RTAutoSaveFieldAttribute att = obj as RTAutoSaveFieldAttribute;
if (att != null)
                        {   // 将特征的值取出赋值
                            IsRefOtherObj = att.RefOther;
                            SaveThisField = att.SaveThisField;
                        }
                    }
                }

//此Field不存储,也不读取
if (!SaveThisField)
                {
continue;
                }



string ParName = AllFields[i].Name;
string ParAttributeVal = parentSave.ParentXMLNode.GetAttribute(ParName);
//空值赋值
if (ParAttributeVal == "null")
                {
                    AllFields[i].SetValue(SaveRTAnyObject, null);
continue;
                }


                Object ParVal = null;
//获得字段对应的真实变量
                {
//找到变量存储时的真实类型(针对对于基类或dynamic变量引用时如此处理)
//动态创建变量,保存时的真实类型
                    {
                        XmlElement ThisFieldNode = (XmlElement)parentSave.ParentXMLNode.SelectSingleNode(ParName);
if (ThisFieldNode != null)
                        {
                            ParVal = CreateClassObjFromSaveXMLNode(ThisFieldNode);
                        }
                    }

if (ParVal == null)
                    {
                        ParVal = AllFields[i].GetValue(SaveRTAnyObject);
                    }
else
                    {
                        AllFields[i].SetValue(SaveRTAnyObject, ParVal);
                    }
                }
                Type ParType = null;
try
                {
if (ParVal == null) continue;
                    ParType = ParVal.GetType();   //考虑到继承问题,不能取字段类型
                }
catch (Exception e)
                {
// 抛出异常，引用对象不是自动保存接口
var ex = new RefObjIsNotRTAutoSaveInterfaceException(ClassType.FullName + "中的变量:" +
                        ParName + "以RTAutoSaveField特征标记引用方式引用了非RTAutoSaveInterface变量");
throw ex;
                }

//根据不同类型成员变量
//值类型
if (!ParType.IsClass || ParType.FullName == "System.String")
                {
string SaveVal = parentSave.ParentXMLNode.GetAttribute(ParName);
                    Object ValueObj = ParseStringToValueObj(SaveVal, ParType);
                    AllFields[i].SetValue(SaveRTAnyObject, ValueObj);

                }
else if (ParType.FullName.StartsWith(@"System.Collections.Generic.List`1"))
                {
                    Type[] ListGenTypes = ParType.GetGenericArguments();
                    Type GenType = ListGenTypes[0];

                    XmlElement SelNode = (XmlElement)parentSave.ParentXMLNode.SelectSingleNode(ParName);

if (!IsRefOtherObj)
                    {
for (int j = 0; j < SelNode.ChildNodes.Count; j++)
                        {
                            XmlElement SelNode2 = SelNode.ChildNodes[j] as XmlElement;
string ListValueStr = SelNode2.GetAttribute(ValueAttStrFlag);                       //简单类型参数直接保存的值
string IsNullStr = SelNode2.GetAttribute(IsClassNullAttStrFlag);                 //此变量是空值

object NewListObj = null;
if (IsNullStr == "true")
                            {
                                NewListObj = null;
                            }
else
                            {
if (!string.IsNullOrEmpty(ListValueStr))    //值类型
                                {
string TrueTypeFullName = SelNode2.GetAttribute(TrueTypeAttStrFlag);
                                    Type ListItemTrueType = Type.GetType(TrueTypeFullName);

                                    NewListObj = ParseStringToValueObj(ListValueStr, ListItemTrueType);
                                }
else
                                {
                                    Object NewListMemberObj = null;

//创建对象
                                    {
//找到变量存储时的真实类型(针对对于基类或dynamic变量引用时如此处理)
                                        NewListMemberObj = CreateClassObjFromSaveXMLNode(SelNode2);

//调用默认构造函数构造
if (NewListMemberObj == null)
                                        {
                                            Type[] tps = new Type[0];
object[] obj = new object[0];
                                            NewListMemberObj = GenType.GetConstructor(tps).Invoke(obj) as Object;
                                        }
                                    }

//初始化成员赋值
                                    {
                                        RTSaveProperty NewFIDSaveProperty = Copy(parentSave);
                                        NewFIDSaveProperty.ParentXMLNode = SelNode2;
                                        LoadRTParWithType(NewFIDSaveProperty, NewListMemberObj, GenType, AllLoadInf);
                                    }
                                    NewListObj = NewListMemberObj;
                                }
                            }

//加入到List中
var addMethod = ParType.GetMethod("Add");
                            addMethod.Invoke((object)ParVal, new object[] { NewListObj });
                        }
                    }
else
                    {
                        AllLoadInf.m_ObjParentList.Add(SaveRTAnyObject);
                        AllLoadInf.m_ParNameList.Add(ParName);
                        AllLoadInf.m_XMLNodeList.Add(SelNode);
                        AllLoadInf.m_IsList.Add(true);
                    }
                }
else if (ParType.IsClass)
                {
//空值，直接赋值
if (ParVal == null)
                    {
                        AllFields[i].SetValue(SaveRTAnyObject, ParVal);
continue;
                    }
else
                    {
                        XmlElement NewNode = (XmlElement)parentSave.ParentXMLNode.SelectSingleNode(ParName);
if (IsRefOtherObj)
                        {
                            AllLoadInf.m_ObjParentList.Add(SaveRTAnyObject);
                            AllLoadInf.m_ParNameList.Add(ParName);
                            AllLoadInf.m_XMLNodeList.Add(NewNode);
                            AllLoadInf.m_IsList.Add(false);

                        }
else
                        {   // 如果不为引用对象
                            {
                                AllFields[i].SetValue(SaveRTAnyObject, ParVal);
if (m_IsMakeID)
                                {
// 找出与对象id字典中对象类型相同的对象的id
                                    String RefObjID = (from Par in m_ObjIdDict.Keys
where ParType == Par.GetType()
select m_ObjIdDict[Par]).FirstOrDefault();
// 添加映射关系到id与obj的字典
if (RefObjID != null && !AllLoadInf.m_AllIdAndObj.Keys.Contains(RefObjID))
                                        AllLoadInf.m_AllIdAndObj.Add(RefObjID, ParVal);
                                }
                                RTSaveProperty NewFIDSaveProperty = Copy(parentSave);
                                NewFIDSaveProperty.ParentXMLNode = NewNode;
                                LoadRTParWithType(NewFIDSaveProperty, ParVal, ParType, AllLoadInf);
                            }

//parentSave.ParentXMLNode.AppendChild(NewNode);
                        }
                    }
                }
            }


return true;
        }

private static bool TwoStepDo(RTAnyObjectLoadInf AllLoadInf)
        {
for (int i = 0; i < AllLoadInf.m_ObjParentList.Count && i < AllLoadInf.m_ParNameList.Count && i < AllLoadInf.m_XMLNodeList.Count && i < AllLoadInf.m_IsList.Count; i++)
            {
//父对象类型
                Type ParentType = AllLoadInf.m_ObjParentList[i].GetType();
                FieldInfo ParFieldInfo = ParentType.GetField(AllLoadInf.m_ParNameList[i], BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
                Type ParType = ParFieldInfo.FieldType;

if (!AllLoadInf.m_IsList[i])
                {
string RefObjID = AllLoadInf.m_XMLNodeList[i].GetAttribute(RefObjAttStrFlag);
                    Object RefObj = null;
if (!m_IsMakeID)
                    {
                        RefObj = AllLoadInf.GetRTAutoSaveInterfaceObjFromID(RefObjID) as RTAutoSaveInterface;
//RTAutoSaveInterface RefObj = AllLoadInf.m_AllObj.Find(p1 => (p1.GetRTSaveObjID() == RefObjID));
                    }
else
                    {
                        RefObj = AllLoadInf.GetRTObjFromID(RefObjID);
                    }
if (RefObj != null)
                    {
                        ParFieldInfo.SetValue(AllLoadInf.m_ObjParentList[i], RefObj);
                    }
                }
else
                {
                    XmlElement SelNode = AllLoadInf.m_XMLNodeList[i];

object ParVal = ParFieldInfo.GetValue(AllLoadInf.m_ObjParentList[i]);
                    dynamic FDD = ParVal;

for (int j = 0; j < SelNode.ChildNodes.Count; j++)
                    {
                        XmlElement SelNode2 = SelNode.ChildNodes[j] as XmlElement;

string RefObjID = SelNode2.GetAttribute(RefObjAttStrFlag);
                        Object RefObj = null;
if (!m_IsMakeID)
                        {
                            RefObj = AllLoadInf.GetRTAutoSaveInterfaceObjFromID(RefObjID) as RTAutoSaveInterface;
//RTAutoSaveInterface RefObj = AllLoadInf.m_AllObj.Find(p1 => (p1.GetRTSaveObjID() == RefObjID));
                        }
else
                        {
                            RefObj = AllLoadInf.GetRTObjFromID(RefObjID);
                        }

if (RefObj != null)
                        {
var addMethod = ParType.GetMethod("Add");
                            addMethod.Invoke((object)ParVal, new object[] { RefObj });
                        }
                    }
                }

            }

return true;
        }

/// <summary>通过引用对象的ID来找到对应的xml节点</summary>
/// <param name="Node">根节点</param>
/// <param name="RefObjId">ID</param>
/// <param name="FindNode">查找的节点（空）用于传递</param>
/// <returns>查找的节点</returns>
private static XmlNode SearchNode(XmlNode Node, string RefObjId, XmlNode FindNode)
        {
if (RefObjId == "") return null;
for (int i = 0; i < Node.Attributes.Count; i++)
            {   // 匹配属性
if (Node.Name.StartsWith("BaseClass") && Node.Attributes[i].Value.Equals(RefObjId))
                {
                    FindNode = Node.ParentNode;
break;
                }
            }
if (Node.ChildNodes.Count > 0)
            {
foreach (XmlNode Child in Node.ChildNodes)
                {
                    XmlNode Temp = SearchNode(Child, RefObjId, FindNode);
if (Temp != null) FindNode = Temp;
                }
            }
return FindNode;
        }

/// <summary>保存属性的深拷贝</summary>
/// <param name="rth"></param>
/// <returns></returns>
private static RTSaveProperty Copy(RTSaveProperty rth)
        {
            RTSaveProperty NewFIDSaveProperty = new RTSaveProperty();

            NewFIDSaveProperty.Xmldoc = rth.Xmldoc;
            NewFIDSaveProperty.ParentXMLNode = rth.ParentXMLNode;

return NewFIDSaveProperty;
        }

    }

/// <summary>拷贝辅助</summary>
public class RTCloneHelp
    {
/// <summary>标识对象是否是继承于自动保存接口对象的布尔值（默认为True）</summary>
public static Boolean IsMakeID
        {
get { return RTObjectAutoSave.IsMakeID; }
set { RTObjectAutoSave.IsMakeID = value; }
        }

/// <summary>对象深拷贝（默认为接口对象）
/// 注意：如果为RTAutoSaveInterface的接口派生对象，则可以直接调用；
/// 若不是接口派生对象，则需要设置IsInterfaceObj为false
/// </summary>
/// <param name="rthAnyObject"></param>
/// <returns></returns>
public static Object DeepClone(Object rthAnyObject)
        {

// 创建 XmlDoc，并添加空节点 Root
            XmlDocument Tem1 = new XmlDocument();
            XmlElement Ele1 = Tem1.CreateElement("Root");
            Tem1.AppendChild(Ele1);
// 将源对象保存进 XmlDoc
            RTObjectAutoSave.SaveRTObjectToXML(rthAnyObject, Ele1);
// 将 XMLDoc 保存到一个文件
//Tem1.Save(@"C:\Users\jclu\Desktop\Demo.xml");
// 获取到源对象的类型
            Type ThisType = rthAnyObject.GetType();
// 通过源对象的类型创建一个新的空对象
            Object ParTrueobj = Activator.CreateInstance(ThisType, true);
//RTAutoSaveInterface ReturnAnyObject = ParTrueobj as RTAutoSaveInterface;
// 通过 XmlDoc 为空对象赋值
            RTObjectAutoSave.LoadRTObjectFromXML(ParTrueobj, Ele1);
return ParTrueobj;
        }
    }

/// <summary>任意RT对象</summary>
public class RTAnyObject : RTAutoSaveInterface
    {
public RTAnyObject()
        {
            m_RTObjID = RTAutoSaveHelp.MakeRTSaveObjID();
        }

private string m_RTObjID = "";
/// <summary>获得ID</summary>
/// <returns></returns>
public string GetRTSaveObjID()
        {
return m_RTObjID;
        }
    }

/// <summary>树结构(待完善)</summary>
public class RTObjectTreeNode
    {
public String NodeID = "";
public Object NodeObj = null;
public XmlElement NodeXmlEle = null;
public RTObjectTreeNode Parent = null;
public List<RTObjectTreeNode> Children = new List<RTObjectTreeNode>();
    }

}