GeneralDocTools/DocTools/LoadData.cs

using DocTools.Entity;
using DocTools.Helper;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Xml;

namespace DocTools
{
    /// <summary>
    /// 导入帮助类
    /// </summary>
    public class LoadData
    {
        /// <summary>
        /// 根据xml获取成员信息
        ///  = @"D:\Project\git\New_Wing_Solution\WingInterfaceLibrary\src\bin\Debug\net6.0\"
        /// </summary>
        public static List<MemberEntity> GetInterfaceMemberInfo(string physicsPath, string version)
        {
            var memberList = new List<MemberEntity>();
            var xmlPath = physicsPath + $"WingInterfaceLibrary{version}.xml";
            XmlDocument doc = new XmlDocument();
            doc.Load(xmlPath);

            XmlNodeList interfaceNodeList = doc.SelectNodes("//member");
            if (interfaceNodeList != null)
            {
                foreach (XmlNode memberNode in interfaceNodeList)
                {
                    MemberEntity entity = new MemberEntity();
                    //通过Attributes获得属性名为name的属性
                    if (memberNode.Attributes["name"] != null)
                    {
                        entity.ParamName = memberNode.Attributes["name"].Value;
                    }
                    if (memberNode.HasChildNodes)
                    {
                        foreach (XmlNode childNode in memberNode.ChildNodes)
                        {
                            if (childNode.Name == "summary")
                            {
                                entity.Summary = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "param")
                            {
                                var pEntity = new ParamEntity();
                                pEntity.ParamText = childNode.InnerText.Trim();
                                if (childNode.Attributes["name"] != null)
                                {
                                    pEntity.ParamName = childNode.Attributes["name"].Value;
                                }
                                entity.Param.Add(pEntity);
                            }
                            else if (childNode.Name == "returns")
                            {
                                entity.Returns = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "value")
                            {
                                entity.Value = childNode.InnerText.Trim().Replace("%26","&");
                            }
                            else if (childNode.Name == "remarks")
                            {
                                entity.Remarks = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "code")
                            {
                                entity.Code = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "example")
                            {
                                entity.Example = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "para")
                            {
                                entity.Para = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "notshow")
                            {
                                entity.C = (string.IsNullOrEmpty(childNode.InnerText.Trim()) || childNode.InnerText.Trim() == "true") ? true : false;
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(entity.ParamName))
                    {
                        memberList.Add(entity);
                    }
                }
            }
            return memberList;
        }

        /// <summary>
        /// 封装接口和成员信息
        /// </summary>
        /// <returns>封装号的实体</returns>
        public static List<APIModuleEntity> PackageInterfaceMemberInfo(string classNamespace = "T:WingInterfaceLibrary.Interface.I")
        {
            var moduleList = new List<APIModuleEntity>();
            var memberList = GetInterfaceConfigToCache();
            //其中C为true，表示显示，其他为不显示
            var interfaceMemberList = memberList.FindAll(c => c.ParamName.Contains(classNamespace) && !string.IsNullOrEmpty(c.Example) && c.C);
            if (interfaceMemberList?.Count > 0)
            {
                //先找到大的api模块,赋值方法上的example
                foreach (var item in interfaceMemberList)
                {
                    var methodNamespace = item.ParamName.Replace("T:", "M:");
                    var methodMemberList = memberList.FindAll(c => c.ParamName.Contains(methodNamespace));
                    if (methodMemberList?.Count > 0)
                    {
                        foreach (var methodItem in methodMemberList)
                        {
                            methodItem.Example = string.IsNullOrEmpty(methodItem.Example) ? item.Example : methodItem.Example;
                        }
                    }
                }
                var apiModuleNameList = memberList.FindAll(c => !string.IsNullOrEmpty(c.Example)).Select(c => c.Example).Distinct().ToList();
                if (apiModuleNameList == null || apiModuleNameList.Count <= 0)
                {
                    return moduleList;
                }
                foreach (var apiModuleNameItem in apiModuleNameList)
                {
                    var apiModuleEntity = new APIModuleEntity()
                    {
                        Example = apiModuleNameItem,
                        IsShowEnumFolder = apiModuleNameItem == "客户端API" ? true : false
                    };
                    var list = new List<InterfaceInfoEntity>();
                    foreach (var item in interfaceMemberList)
                    {
                        InterfaceInfoEntity entity = null;
                        //如果存在就不用新增了，否则就要新增
                        if (list.Exists(c => c.Value == item.Value))
                        {
                            entity = list.Find(c => c.Value == item.Value);
                        }
                        else
                        {
                            entity = new InterfaceInfoEntity();
                        }
                        if (!entity.InterfaceList.Exists(c => c.InterfaceNamespace == item.ParamName))
                        {
                            var interfaceModel = new InterfaceBasicInfoEntity()
                            {
                                InterfaceNamespace = item.ParamName,
                                InterfaceFullName = item.ParamName.Replace("T:", ""),
                                InterfaceName = item.ParamName.Split('.').ToList().Last(),
                                InterfaceSummary = item.Summary,
                                MethodNamespace = item.ParamName.Replace("T:", "M:")
                            };
                            var methodMemberList = memberList.FindAll(c => c.ParamName.Contains(interfaceModel.MethodNamespace) && c.Example == apiModuleNameItem);
                            if (methodMemberList?.Count > 0)
                            {
                                Type type = GetAssemblyFromCache().GetType(interfaceModel.InterfaceFullName);
                                foreach (var methodItem in methodMemberList)
                                {
                                    if (!methodItem.C) 
                                    {
                                        continue;
                                    }
                                    if (!interfaceModel.MethodList.Exists(c => c.MethodNameSpace == methodItem.ParamName))
                                    {
                                        var methodModel = new MethodBasicEntity()
                                        {
                                            MethodNameSpace = methodItem.ParamName,
                                            InterfaceName = interfaceModel.InterfaceName,
                                            MethodName = methodItem.ParamName.Replace((interfaceModel.MethodNamespace + "."), "").Split('(').ToList().First(),
                                            Summary = apiModuleNameItem.Replace("API", "——") + methodItem.Summary,
                                            Returns = methodItem.Returns,
                                            Value = methodItem.Value,
                                            ReturnsTypeFullName = "",
                                            SubmitType = string.IsNullOrEmpty(methodItem.Remarks) ? "POST" : methodItem.Remarks,
                                            ParamName = methodItem.Param?.FirstOrDefault()?.ParamName,
                                            ParamText = methodItem.Param?.FirstOrDefault()?.ParamText
                                        };
                                        if (methodItem.ParamName.Split('(').Length > 1) 
                                        {
                                            methodModel.ParamTypeFullName = methodItem.ParamName.Split('(')[1].TrimEnd(')');
                                        }
                                        if (!string.IsNullOrEmpty(methodItem.Para) && methodItem.Para.Split(',').Length > 0)
                                        {
                                            foreach (var paraItem in methodItem.Para.Split(','))
                                            {
                                                methodModel.ParaList.Add(paraItem);
                                            }
                                        }
                                        if (!string.IsNullOrEmpty(methodModel.ParamTypeFullName))
                                        {
                                            //封装请求参数实体
                                            var requestClassNamespace = "T:" + methodModel.ParamTypeFullName;
                                            var requestClassMemberInfo = memberList.Find(c => c.ParamName.Contains(requestClassNamespace));
                                            if (requestClassMemberInfo == null)
                                            {
                                                continue;
                                            }
                                            var tuple = GetRequestParameterPropertyList(methodModel.ParamTypeFullName);
                                            ParamPropertyEntity requestEntity = new ParamPropertyEntity()
                                            {
                                                Desc = requestClassMemberInfo.Summary,
                                                ParamPropertyList = tuple.Item1,
                                                Name = methodModel.ParamTypeFullName.Split('.').Last(),
                                                TypeFullName = !string.IsNullOrEmpty(tuple.Item2) ? tuple.Item2 : methodModel.ParamTypeFullName,
                                                DefaultValue = requestClassMemberInfo.Value,
                                                IsNotNull = "1"
                                            };
                                            methodModel.RequestList.Add(requestEntity);
                                        }
                                        //封装响应参数实体
                                        var methodInfoItem = type.GetMethod(methodModel.MethodName);
                                        var returnTypeParams = methodInfoItem.ReturnParameter?.ParameterType?.GenericTypeArguments;
                                        if (returnTypeParams != null && returnTypeParams.Length > 0)
                                        {
                                            methodModel.ResponseList = GetReturnParameterPropertyList(returnTypeParams, methodModel.Returns, methodModel.Value);
                                        }
                                        interfaceModel.MethodList.Add(methodModel);
                                    }
                                }
                            }
                            if (interfaceModel.MethodList.Count <= 0)
                            {
                                continue;
                            }
                            entity.InterfaceList.Add(interfaceModel);
                        }
                        //如果为空就表示要新增
                        if (!string.IsNullOrEmpty(item.Value))
                        {
                            if (string.IsNullOrEmpty(entity.Value))
                            {
                                entity.Value = item.Value;
                                list.Add(entity);
                            }
                        }
                    }
                    apiModuleEntity.MainModelList = list;
                    moduleList.Add(apiModuleEntity);
                }
            }
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(moduleList);
            return moduleList;
        }

        /// <summary>
        /// 获取返回参数列表
        /// </summary>
        /// <param name="returnTypeParams"></param>
        /// <param name="desc"></param>
        /// <returns></returns>
        private static List<ParamPropertyEntity> GetReturnParameterPropertyList(Type[] returnTypeParams, string desc, string value)
        {
            var resultList = new List<ParamPropertyEntity>();
            try
            {
                if (returnTypeParams == null || returnTypeParams[0] == null)
                {
                    return resultList;
                }
                var propertyModel = new ParamPropertyEntity()
                {
                    Desc = desc,
                    Name = returnTypeParams[0].Name
                };
                if (returnTypeParams[0].FullName.Contains("System.Collections.Generic.List") && CommonHelper.SubstringCount(returnTypeParams[0].FullName, "WingInterfaceLibrary") > 2)
                {
                    propertyModel.TypeFullName = returnTypeParams[0].Namespace + "." + returnTypeParams[0].Name;
                    var fxClassNamespace = returnTypeParams[0].FullName.Replace(propertyModel.TypeFullName, "") ?? string.Empty;
                    propertyModel.ParamPropertyList = GetRequestParameterPropertyList(propertyModel.TypeFullName, fxClassNamespace).Item1;
                }
                else if (returnTypeParams[0].GenericTypeArguments?.Length > 0)
                {
                    propertyModel.TypeFullName = returnTypeParams[0].Namespace + "." + returnTypeParams[0].Name;
                    var fxClassNamespace = returnTypeParams[0].FullName.Replace(propertyModel.TypeFullName, "").Replace("[[", "").Split(',')?.FirstOrDefault() ?? string.Empty;
                    propertyModel.ParamPropertyList = GetRequestParameterPropertyList(propertyModel.TypeFullName, fxClassNamespace).Item1;
                }
                else
                {
                    propertyModel.TypeFullName = returnTypeParams[0].FullName;
                    propertyModel.DefaultValue = value;
                    propertyModel.ParamPropertyList = GetRequestParameterPropertyList(propertyModel.TypeFullName).Item1;
                }
                resultList.Add(propertyModel);
                return resultList;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"GetChildArguments异常信息：{ex}");
                return resultList;
            }
        }

        /// <summary>
        /// 获取请求参数列表
        /// </summary>
        /// <returns></returns>
        private static Tuple<List<ParamPropertyEntity>,string> GetRequestParameterPropertyList(string namespacePath, string fxClassNamespace = "")
        {
            string returnSpecialType = "";
            Assembly assembly = GetAssemblyFromCache();
            var memberList = GetInterfaceConfigToCache();
            var resultList = new List<ParamPropertyEntity>();
            try
            {
                if (string.IsNullOrEmpty(namespacePath))
                {
                    return Tuple.Create(resultList, returnSpecialType);
                }
                else if (namespacePath.Contains("System.Collections.Generic.List"))
                {
                    if (!string.IsNullOrEmpty(fxClassNamespace))
                    {
                        if (CommonHelper.SubstringCount(fxClassNamespace, "WingInterfaceLibrary") > 2)
                        {
                            var fxn1 = fxClassNamespace.Split('`')[0].Replace("[[", "") + "`1"; 
                            var fxn2 = fxClassNamespace.Split('`')[1].Split(',')[0].Replace("1[[", "");
                            var propertyModelTemp = new ParamPropertyEntity();
                            propertyModelTemp.TypeFullName = fxn1;
                            var requestClassNamespace = "T:" + propertyModelTemp.TypeFullName;
                            var requestClassMemberInfo = memberList.Find(c => c.ParamName.Contains(requestClassNamespace));
                            if (requestClassMemberInfo != null)
                            {
                                propertyModelTemp.DefaultValue = requestClassMemberInfo.Value;
                                propertyModelTemp.Desc = requestClassMemberInfo.Summary;
                                propertyModelTemp.IsNotNull = requestClassMemberInfo.Code;
                                propertyModelTemp.Name = propertyModelTemp.TypeFullName.Split('.').LastOrDefault();
                                var tuple = GetRequestParameterPropertyList(propertyModelTemp.TypeFullName, fxn2);
                                propertyModelTemp.ParamPropertyList = tuple.Item1;
                                if (!string.IsNullOrEmpty(tuple.Item2))
                                {
                                    propertyModelTemp.TypeFullName = tuple.Item2;
                                }
                            }
                            resultList.Add(propertyModelTemp);
                        }
                        else
                        {
                            var propertyModelTemp = new ParamPropertyEntity();
                            propertyModelTemp.TypeFullName = fxClassNamespace;
                            var requestClassNamespace = "T:" + propertyModelTemp.TypeFullName;
                            var requestClassMemberInfo = memberList.Find(c => c.ParamName.Contains(requestClassNamespace));
                            if (requestClassMemberInfo != null)
                            {
                                propertyModelTemp.DefaultValue = requestClassMemberInfo.Value;
                                propertyModelTemp.Desc = requestClassMemberInfo.Summary;
                                propertyModelTemp.IsNotNull = requestClassMemberInfo.Code;
                                propertyModelTemp.Name = propertyModelTemp.TypeFullName.Split('.').LastOrDefault();
                                var tuple = GetRequestParameterPropertyList(propertyModelTemp.TypeFullName);
                                propertyModelTemp.ParamPropertyList = tuple.Item1;
                                if (!string.IsNullOrEmpty(tuple.Item2))
                                {
                                    propertyModelTemp.TypeFullName = tuple.Item2;
                                }
                            }
                            resultList.Add(propertyModelTemp);
                        }
                    }
                }
                else
                {
                    Type newType = assembly.GetType(namespacePath);
                    if (newType != null)
                    {
                        var parentResultList = GetParentProperty(newType.BaseType, ref returnSpecialType);
                        if (parentResultList?.Count > 0)
                        {
                            resultList.AddRange(parentResultList);
                        }
                        PropertyInfo[] p = newType.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
                        foreach (var item in p)
                        {
                            var propertyModel = new ParamPropertyEntity();
                            var type = item.PropertyType.Name;
                            var paramName = "P:" + namespacePath + "." + item.Name;
                            var memberEntity = memberList.Find(c => c.ParamName == paramName) ?? new MemberEntity();
                            string desc = "";
                            if (memberEntity == null || string.IsNullOrEmpty(memberEntity.Summary))
                            {
                                AttributeCollection attributes = TypeDescriptor.GetProperties(newType)[item.Name].Attributes;
                                DescriptionAttribute myAttribute = (DescriptionAttribute)attributes[typeof(DescriptionAttribute)];
                                desc = myAttribute.Description;
                            }
                            else
                            {
                                desc = memberEntity.Summary.Replace("\r\n", "").Replace(" ", "").Replace(" ", "").Replace("　", "");
                            }
                            propertyModel.TypeFullName = type;
                            propertyModel.DefaultValue = memberEntity.Value;
                            propertyModel.IsNotNull = memberEntity.Code;
                            propertyModel.Name = item.Name;
                            propertyModel.Desc = desc;
                            if (!string.IsNullOrEmpty(item.PropertyType.FullName))
                            {
                                if (item.PropertyType.FullName.Contains("WingInterfaceLibrary"))
                                {
                                    if (item.PropertyType.FullName.Contains("System.Collections.Generic.List"))
                                    {
                                        var fx = item.PropertyType.FullName.Split(',')?.FirstOrDefault()?.Replace("System.Collections.Generic.List`1[[", "");
                                        if (!fx.Contains(namespacePath))
                                        {
                                            var tuple = GetRequestParameterPropertyList(item.PropertyType.FullName, fx);
                                            propertyModel.ParamPropertyList = tuple.Item1;
                                            if (!string.IsNullOrEmpty(tuple.Item2))
                                            {
                                                propertyModel.TypeFullName = tuple.Item2;
                                            }
                                        }
                                    }
                                    else if(item.PropertyType.FullName.Contains("WingInterfaceLibrary.Enum."))
                                    {
                                        propertyModel.TypeFullName = item.PropertyType.FullName;
                                    }
                                    else
                                    {
                                        var propertyModelTemp = new ParamPropertyEntity();
                                        propertyModelTemp.TypeFullName = item.PropertyType.FullName;
                                        propertyModelTemp.DefaultValue = "";
                                        propertyModelTemp.Desc = desc;
                                        propertyModelTemp.IsNotNull = memberEntity.Code;
                                        propertyModelTemp.Name = item.Name;
                                        if (!item.PropertyType.FullName.Contains(namespacePath))
                                        {
                                            var tuple = GetRequestParameterPropertyList(item.PropertyType.FullName);
                                            propertyModelTemp.ParamPropertyList = tuple.Item1;
                                            if (!string.IsNullOrEmpty(tuple.Item2))
                                            {
                                                propertyModelTemp.TypeFullName = tuple.Item2;
                                            }
                                        }
                                        propertyModel.ParamPropertyList.Add(propertyModelTemp);
                                    }
                                }
                                else
                                {
                                    if (item.PropertyType.FullName.Contains("System.Collections.Generic.List"))
                                    {
                                        propertyModel.GenericityType = item.PropertyType.FullName.Split(',').FirstOrDefault().Replace("System.Collections.Generic.List`1[[", "");
                                    }
                                }
                            }
                            else if (type.Contains("List`1"))
                            {
                                if (!string.IsNullOrEmpty(fxClassNamespace))
                                {
                                    if (fxClassNamespace.Contains("WingInterfaceLibrary"))
                                    {
                                        var propertyModelTemp = new ParamPropertyEntity();
                                        propertyModelTemp.TypeFullName = fxClassNamespace;
                                        var requestClassNamespace = "T:" + propertyModelTemp.TypeFullName;
                                        var requestClassMemberInfo = memberList.Find(c => c.ParamName.Contains(requestClassNamespace));
                                        if (requestClassMemberInfo != null)
                                        {
                                            propertyModelTemp.DefaultValue = requestClassMemberInfo.Value;
                                            propertyModelTemp.Desc = requestClassMemberInfo.Summary;
                                            propertyModelTemp.IsNotNull = requestClassMemberInfo.Code;
                                            propertyModelTemp.Name = propertyModelTemp.TypeFullName.Split('.').LastOrDefault();
                                            if (!propertyModelTemp.TypeFullName.Contains(namespacePath))
                                            {
                                                var tuple = GetRequestParameterPropertyList(propertyModelTemp.TypeFullName);
                                                propertyModelTemp.ParamPropertyList = tuple.Item1;
                                                if (!string.IsNullOrEmpty(tuple.Item2))
                                                {
                                                    propertyModelTemp.TypeFullName = tuple.Item2;
                                                }
                                            }
                                            propertyModel.ParamPropertyList.Add(propertyModelTemp);
                                        }
                                    }
                                    else if (fxClassNamespace.Contains("WingInterfaceLibrary.Enum."))
                                    {
                                        propertyModel.TypeFullName = fxClassNamespace;
                                    }
                                    else
                                    {
                                        propertyModel.GenericityType = "String";
                                    }
                                }
                                else
                                {
                                    propertyModel.GenericityType = "String";
                                }
                            }
                            resultList.Add(propertyModel);
                        }
                    }
                }
                return Tuple.Create(resultList, returnSpecialType);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"GetChildArguments异常信息：{ex}");
                return Tuple.Create(resultList, returnSpecialType); 
            }
        }

        /// <summary>
        /// 获取父类的属性
        /// </summary>
        /// <param name="assembly"></param>
        /// <param name="returnSpecialType">返回特殊类型</param>
        private static List<ParamPropertyEntity> GetParentProperty(Type baseType, ref string returnSpecialType)
        {
            List<ParamPropertyEntity> list = new List<ParamPropertyEntity>();
            try
            {
                if (baseType != null)
                {
                    Assembly assembly = GetAssemblyFromCache();
                    var memberList = GetInterfaceConfigToCache();
                    var namespacePath = baseType.FullName;
                    if (namespacePath.Contains("BaseParamsString"))
                    {
                        returnSpecialType = "String";
                        return list;
                    }
                    if (namespacePath != "System.Object")
                    {
                        var resultList = GetParentProperty(baseType.BaseType, ref returnSpecialType);
                        if (resultList?.Count > 0)
                        {
                            list.AddRange(resultList);
                        }
                    }
                    PropertyInfo[] p = baseType.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
                    if (p?.Length > 0)
                    {
                        foreach (var item in p)
                        {
                            ParamPropertyEntity propertyModel = new ParamPropertyEntity();
                            var type = item.PropertyType.Name;
                            var paramName = "P:" + namespacePath + "." + item.Name;
                            var memberEntity = memberList.Find(c => c.ParamName == paramName) ?? new MemberEntity();
                            if (memberEntity != null)
                            {
                                var desc = memberEntity?.Summary?.Replace("\r\n", "")?.Replace(" ", "")?.Replace(" ", "")?.Replace("　", "") ?? string.Empty;
                                propertyModel.DefaultValue = memberEntity.Value;
                                propertyModel.TypeFullName = type;
                                propertyModel.Name = item.Name;
                                propertyModel.IsNotNull = memberEntity.Code;
                                propertyModel.Desc = desc;
                                if (item.PropertyType.FullName.Contains("WingInterfaceLibrary"))
                                {
                                    var fxClassNamespace = "";
                                    if (item.PropertyType.FullName.Contains("System.Collections.Generic.List"))
                                    {
                                        fxClassNamespace = item.PropertyType.FullName.Split(',')?.FirstOrDefault()?.Replace("System.Collections.Generic.List`1[[", "");
                                    }
                                    var tupel = GetRequestParameterPropertyList(item.PropertyType.FullName, fxClassNamespace);
                                    propertyModel.ParamPropertyList = tupel.Item1;
                                    if (!string.IsNullOrEmpty(tupel.Item2))
                                    {
                                        propertyModel.TypeFullName = tupel.Item2;
                                    }
                                }
                            }
                            list.Add(propertyModel);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"GetParentProperty异常信息：{ex}");
                return new List<ParamPropertyEntity>();
            }
            return list;
        }

        /// <summary>
        /// 反射导入dll
        /// </summary>
        private static Assembly GetInterfaceAssemblyInfo(string physicsPath, string version)
        {
            //dll文件路径
            string path = physicsPath + $"WingInterfaceLibrary{version}.dll";
            //加载dll文件
            Assembly assembly = Assembly.LoadFile(path);
            return assembly;
        }

        /// <summary>
        /// 加载信息到缓存
        ///  = @"D:\Project\git\New_Wing_Solution\WingInterfaceLibrary\src\bin\Debug\net6.0\"
        /// </summary>
        public static void SetInterfaceConfigToCache(string physicsPath, string version = "")
        {
            var key = "LoadAssemblyInterface";
            var assembly =  GetInterfaceAssemblyInfo(physicsPath, version);
            CommonMemoryCaching.GetInstance().SetValueToCache(key, assembly, false);

            var keyXml = "LoadAInterfaceLibrary";
            var list = GetInterfaceMemberInfo(physicsPath, version);
            CommonMemoryCaching.GetInstance().SetValueToCache(keyXml, list, false);
        }

        /// <summary>
        /// 从缓存中加载信息
        /// </summary>
        public static Assembly GetAssemblyFromCache()
        {
            var key = "LoadAssemblyInterface";
            var assembly = (Assembly)CommonMemoryCaching.GetInstance().GetValueFromCache(key);
            return assembly;
        }

        /// <summary>
        /// 从缓存中加载信息
        /// </summary>
        public static List<MemberEntity> GetInterfaceConfigToCache()
        {
            var key = "LoadAInterfaceLibrary";
            var list = (List<MemberEntity>)CommonMemoryCaching.GetInstance().GetValueFromCache(key);
            return list;
        }
    }
}