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>();
    }

}