WingCloudServer/Tools/GeneralDocTool/Service/LoadData.cs

using WingCloudServer.GeneralDocTools.Model;
using WingCloudServer.GeneralDocTools.Helper;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Xml;

namespace WingCloudServer.GeneralDocTools.Service
{
    /// <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 == "docFirstDirectory")
                            {
                                entity.DocFirstDirectory = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "docSecondDirectory")
                            {
                                entity.DocSecondDirectory = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "enumDocFirstDirectory")
                            {
                                entity.EnumDocFirstDirectory = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "errorCodes")
                            {
                                entity.ErrorCodes = childNode.InnerText.Trim();
                            }
                            else if (childNode.Name == "show")
                            {
                                entity.Show = (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()
        {
            var moduleList = new List<APIModuleEntity>();
            var memberList = GetInterfaceConfigToCache();
            var otherApiModuleList = new List<QueryMethodMemberEntity>();
            //获取一级目录，其中Show为true，表示显示，其他为不显示
            var firstMemberList = memberList.FindAll(c => c.ParamName.Contains("T:WingInterfaceLibrary.") && !string.IsNullOrEmpty(c.DocFirstDirectory) && c.Show && c.DocFirstDirectory == "AI诊断API").Select(d => d.DocFirstDirectory).Distinct().ToList();
            if (firstMemberList != null && firstMemberList.Count > 0)
            {
                //添加枚举一级目录,枚举
                var enumApiModuleEntity = new APIModuleEntity()
                {
                    DocDirectory = CommonHelper.EnumApiString,
                    IsEnumFolder = true
                };
                moduleList.Add(enumApiModuleEntity);
                foreach (var firstMemberStr in firstMemberList)
                {
                    //一级目录,针对的是接口
                    var interfaceMemberList = memberList.FindAll(c => c.DocFirstDirectory == firstMemberStr && c.ParamName.Contains("T:WingInterfaceLibrary.") && c.Show && !string.IsNullOrEmpty(c.DocSecondDirectory));
                    if (interfaceMemberList?.Count > 0)
                    {
                        //先找到大的api模块,赋值方法上的 docFirstDirectory
                        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.DocFirstDirectory = string.IsNullOrEmpty(methodItem.DocFirstDirectory) ? item.DocFirstDirectory : methodItem.DocFirstDirectory;
                                    methodItem.DocSecondDirectory = string.IsNullOrEmpty(methodItem.DocSecondDirectory) ? item.DocSecondDirectory : methodItem.DocSecondDirectory;
                                }
                            }
                        }
                        var apiModuleEntity = new APIModuleEntity()
                        {
                            DocDirectory = firstMemberStr,
                            IsEnumFolder = false
                        };
                        var list = new List<InterfaceInfoEntity>();
                        foreach (var item in interfaceMemberList)
                        {
                            InterfaceInfoEntity entity;
                            //如果存在就不用新增了，否则就要新增
                            if (list.Exists(c => c.Value == item.DocSecondDirectory))
                            {
                                entity = list.Find(c => c.Value == item.DocSecondDirectory) ?? new InterfaceInfoEntity();
                            }
                            else
                            {
                                entity = new InterfaceInfoEntity();
                            }
                            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:")
                            };
                            Type type = GetAssemblyFromCache().GetType(interfaceModel.InterfaceFullName);
                            if (type == null)
                            {
                                continue;
                            }
                            var methodMemberList = memberList.FindAll(c => c.ParamName.Contains(interfaceModel.MethodNamespace) && c.Show);
                            if (methodMemberList?.Count > 0)
                            {
                                foreach (var methodItem in methodMemberList)
                                {
                                    if (methodItem.DocFirstDirectory != item.DocFirstDirectory || methodItem.DocSecondDirectory != item.DocSecondDirectory)
                                    {
                                        QueryMethodMemberEntity queryItem = new QueryMethodMemberEntity()
                                        {
                                            DocFirstDirectory = methodItem.DocFirstDirectory,
                                            DocSecondDirectory = methodItem.DocSecondDirectory,
                                            MethodInfo = methodItem,
                                            InterfaceType = type,
                                            InterfaceEntity = interfaceModel
                                        };
                                        otherApiModuleList.Add(queryItem);
                                        continue;
                                    }
                                    // if (methodItem.DocFirstDirectory == "预约会诊服务" && methodItem.ParamName == "M:WingInterfaceLibrary.LiveConsultation.ILiveConsultationService.SendInteractiveBoardDataAsync(WingInterfaceLibrary.LiveConsultation.Consultation.SendInteractiveBoardDataRequest)")
                                    // {
                                    //     Console.WriteLine("预约会诊服务");
                                    // }
                                    if (!entity.MethodList.Exists(c => c.MethodNameSpace == methodItem.ParamName))
                                    {
                                        var methodModel = PackageInterfaceMethod(methodItem, interfaceModel, item.DocFirstDirectory, memberList, type);
                                        if (methodModel != null) 
                                        {
                                            entity.MethodList.Add(methodModel);
                                        }
                                    }
                                }
                            }
                            if (entity.MethodList.Count <= 0)
                            {
                                continue;
                            }
                            //如果为空就表示要新增
                            if (!string.IsNullOrEmpty(item.DocSecondDirectory))
                            {
                                if (string.IsNullOrEmpty(entity.Value))
                                {
                                    entity.Value = item.DocSecondDirectory;
                                    list.Add(entity);
                                }
                            }
                            apiModuleEntity.MainModelList = list;
                            if (!moduleList.Exists(f => f.DocDirectory == apiModuleEntity.DocDirectory)) 
                            {
                                moduleList.Add(apiModuleEntity);
                            }
                        }
                    }
                }
                //再次计算其他的项
                //先找到一级目录
                var otherFirstDirectList = otherApiModuleList.Select(c => c.DocFirstDirectory).Distinct().ToList();
                if (otherFirstDirectList != null && otherFirstDirectList.Count > 0)
                {
                    foreach (var otherFirstDirectoryItem in otherFirstDirectList)
                    {
                        var firstFilterModuleList = otherApiModuleList.FindAll(d => d.DocFirstDirectory == otherFirstDirectoryItem);
                        if (firstFilterModuleList != null && firstFilterModuleList.Count > 0)
                        {
                            var curModuleInfo = moduleList.Find(c => c.DocDirectory == otherFirstDirectoryItem) ?? new APIModuleEntity();
                            var otherSecondDirectList = firstFilterModuleList.Select(c => c.DocSecondDirectory).Distinct().ToList();
                            if (otherSecondDirectList != null && otherSecondDirectList.Count > 0)
                            {
                                foreach (var otherSecondDirectoryItem in otherSecondDirectList)
                                {
                                    var secondFilterModuleList = otherApiModuleList.FindAll(d => d.DocFirstDirectory == otherFirstDirectoryItem && d.DocSecondDirectory == otherSecondDirectoryItem);
                                    if (secondFilterModuleList != null && secondFilterModuleList.Count > 0)
                                    {
                                        var curMainModelInfo = curModuleInfo.MainModelList.Find(c => c.Value == otherSecondDirectoryItem);
                                        bool isAdd = false;
                                        if (curMainModelInfo == null || string.IsNullOrEmpty(curMainModelInfo.Value))
                                        {
                                            curMainModelInfo = new InterfaceInfoEntity()
                                            {
                                                Value = otherSecondDirectoryItem
                                            };
                                            isAdd = true;
                                        }
                                        //处理数据
                                        foreach (var item in secondFilterModuleList)
                                        { 
                                            if (!curMainModelInfo.MethodList.Exists(c => c.MethodNameSpace == item.MethodInfo.ParamName))
                                            {
                                                var methodModel = PackageInterfaceMethod(item.MethodInfo, item.InterfaceEntity, item.DocFirstDirectory, memberList, item.InterfaceType);
                                                if (methodModel != null) 
                                                {
                                                    curMainModelInfo.MethodList.Add(methodModel);
                                                }
                                            }
                                            if (curMainModelInfo.MethodList.Count <= 0)
                                            {
                                                continue;
                                            }
                                        }
                                        if (isAdd)
                                        {
                                            curModuleInfo.MainModelList.Add(curMainModelInfo);
                                            isAdd = false;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                string json = Newtonsoft.Json.JsonConvert.SerializeObject(moduleList);
            }
            return moduleList;
        }

        /// <summary>
        /// 封装接口方法
        /// </summary>
        /// <param name="methodItem"></param>
        /// <param name="interfaceModel"></param>
        /// <param name="docFirstDirectory"></param>
        /// <param name="memberList"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        private static MethodBasicEntity PackageInterfaceMethod(MemberEntity methodItem, InterfaceBasicInfoEntity interfaceModel, string docFirstDirectory, 
        List<MemberEntity> memberList, Type type)
        {
            var methodModel = new MethodBasicEntity()
            {
                MethodNameSpace = methodItem.ParamName,
                InterfaceName = interfaceModel.InterfaceName,
                MethodName = methodItem.ParamName.Replace((interfaceModel.MethodNamespace + "."), "").Split('(').ToList().First(),
                Summary = methodItem.Summary,
                Returns = methodItem.Returns,
                Value = methodItem.Value,
                ReturnsTypeFullName = "",
                SubmitType = string.IsNullOrEmpty(methodItem.Remarks) ? "POST" : methodItem.Remarks,
                ParamName = methodItem?.Param?.FirstOrDefault()?.ParamName ?? string.Empty,
                ParamText = methodItem?.Param?.FirstOrDefault()?.ParamText ?? string.Empty
            };
            if (methodItem?.ParamName.Split('(').Length > 1) 
            {
                methodModel.ParamTypeFullName = methodItem.ParamName.Split('(')[1].TrimEnd(')');
            }
            if (!string.IsNullOrEmpty(methodItem?.ErrorCodes))
            {
                methodModel.ErrorCodes = methodItem.ErrorCodes;
            }
            if (!string.IsNullOrEmpty(methodModel.ParamTypeFullName))
            {
                //封装请求参数实体
                var requestClassNamespace = "T:" + methodModel.ParamTypeFullName;
                var requestClassMemberInfo = memberList.Find(c => c.ParamName.Contains(requestClassNamespace));
                if (requestClassMemberInfo == null)
                {
                    return null;
                }
                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);
            }
            return methodModel;
        }

        /// <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;
        }
    }
}