public class DefaultServiceManager : IServiceManager
{
   private IEnumerable<Service> m_localServices; // 用于缓存本地应用服务
   private IEnumerable<Service> m_allServices; // 用于缓存所有应用服务

   public DefaultServiceManager(IEnumerable<IServiceProvider> providers) // 在服务管理器的构造器注入所有的服务提供者
   {
       UpdateServices(providers); // 使用注入所有的服务提供者实现解析应用服务
   }

   private void UpdateServices(IEnumerable<IServiceProvider> providers)
   {
       var allServices = new List<Service>();
       foreach (var provider in providers)
       {
           var services = provider.GetServices();
           allServices.AddRange(services);
       }
       if (allServices.GroupBy(p => p.Id).Any(p => p.Count() > 1))
       {
           throw new SilkyException(
               "There is duplicate service information, please check the service you set");
       }
       m_allServices = allServices.ToList();
       m_localServices = allServices.Where(p => p.IsLocal).ToList();
   }

// 其他代码略...

}

public class DefaultServiceProvider : IServiceProvider
{
    private readonly ITypeFinder _typeFinder;
    private readonly IServiceGenerator _serviceGenerator;

    public DefaultServiceProvider(ITypeFinder typeFinder,
        IServiceGenerator serviceGenerator)
    {
        _typeFinder = typeFinder;
        _serviceGenerator = serviceGenerator;
    }

    public IReadOnlyCollection<Service> GetServices()
    {
        var serviceTypes = ServiceHelper.FindAllServiceTypes(_typeFinder);
        if (!EngineContext.Current.IsContainHttpCoreModule()) // 如果不包含HttpCoreModule模块,则忽略标识了`[DashboardAppService]`的应用服务
        {
            serviceTypes = serviceTypes.Where(p =>
                p.Item1.GetCustomAttributes().OfType<DashboardAppServiceAttribute>().FirstOrDefault() == null);
        }
        var services = new List<Service>();
        foreach (var serviceTypeInfo in serviceTypes)
        {
            services.Add(_serviceGenerator.CreateService(serviceTypeInfo)); // 委托给 IServiceGenerator 创建应用服务对象
        }
        if (EngineContext.Current.IsContainWebSocketModule())
        {
            var wsServiceTypes = ServiceHelper.FindServiceLocalWsTypes(_typeFinder);
            foreach (var wsServiceType in wsServiceTypes)
            {
                services.Add(_serviceGenerator.CreateWsService(wsServiceType));
            }
        }
        return services;
    }
}

// 其他代码略...

public static IEnumerable<(Type, bool)> FindAllServiceTypes(ITypeFinder typeFinder)
{
    var serviceTypes = new List<(Type, bool)>();
    var exportedTypes = typeFinder.GetaAllExportedTypes();
    var serviceInterfaces = exportedTypes
            .Where(p => p.IsInterface
                        && p.GetCustomAttributes().Any(a => a is ServiceRouteAttribute)
                        && !p.IsGenericType
            )
        ;
    foreach (var entryInterface in serviceInterfaces)
    {
        serviceTypes.Add(
            exportedTypes.Any(t => entryInterface.IsAssignableFrom(t) && t.IsClass && !t.IsAbstract)
                ? (entryInterface, true)
                : (entryInterface, false));
    }
    return serviceTypes;
}

public static IEnumerable<Type> FindServiceLocalWsTypes(ITypeFinder typeFinder)
{
    var types = typeFinder.GetaAllExportedTypes()
            .Where(p => p.IsClass
                        && !p.IsAbstract
                        && !p.IsGenericType
                        && p.GetInterfaces().Any(i =>
                            i.GetCustomAttributes().Any(a => a is ServiceRouteAttribute))
                        && p.BaseType?.FullName == ServiceConstant.WebSocketBaseTypeName
            )
            .OrderBy(p =>
                p.GetCustomAttributes().OfType<ServiceKeyAttribute>().Select(q => q.Weight).FirstOrDefault()
            )
        ;
    return types;
}

public Service CreateService((Type, bool) serviceTypeInfo)
{
    var serviceId = _idGenerator.GenerateServiceId(serviceTypeInfo.Item1);
    var serviceInfo = new Service()
    {
        Id = serviceId,
        ServiceType = serviceTypeInfo.Item1,
        IsLocal = serviceTypeInfo.Item2,
        ServiceProtocol = ServiceHelper.GetServiceProtocol(serviceTypeInfo.Item1, serviceTypeInfo.Item2, true),
        ServiceEntries =  _serviceEntryManager.GetServiceEntries(serviceId)
    };
    serviceInfo.ServiceDescriptor = CreateServiceDescriptor(serviceInfo);
    return serviceInfo;
}

public string GenerateServiceId(Type serviceType)
{
    Check.NotNull(serviceType, nameof(serviceType));
    return serviceType.FullName;
}

        private ServiceDescriptor CreateServiceDescriptor(Service service)
        {
           
            var serviceBundleProvider = ServiceDiscoveryHelper.GetServiceBundleProvider(service.ServiceType);
            var serviceDescriptor = new ServiceDescriptor
            {
                ServiceProtocol = service.ServiceProtocol,
                Id = service.Id,
                ServiceName = serviceBundleProvider.GetServiceName(service.ServiceType),
                ServiceEntries = service.ServiceEntries.Select(p => p.ServiceEntryDescriptor).ToArray()
            };

            if (service.IsLocal)
            {
                var implementTypes = ServiceHelper.FindLocalServiceImplementTypes(_typeFinder, service.ServiceType);
                var serviceKeys = new Dictionary<string, int>();
                foreach (var implementType in implementTypes)
                {
                    var serviceKeyProvider = implementType.GetCustomAttributes().OfType<IServiceKeyProvider>()
                        .FirstOrDefault();
                    if (serviceKeyProvider != null)
                    {
                        if (serviceKeys.ContainsKey(serviceKeyProvider.Name))
                        {
                            throw new SilkyException(
                                $"The {service.ServiceType.FullName} set ServiceKey is not allowed to be repeated");
                        }

                        serviceKeys.Add(serviceKeyProvider.Name, serviceKeyProvider.Weight);
                    }
                }

                if (serviceKeys.Any())
                {
                    serviceDescriptor.Metadatas.Add(ServiceConstant.ServiceKey, serviceKeys);
                }
            }

            var metaDataList = service.ServiceType.GetCustomAttributes<MetadataAttribute>();
            foreach (var metaData in metaDataList)
            {
                serviceDescriptor.Metadatas.Add(metaData.Key, metaData.Value);
            }

            if (service.ServiceProtocol == ServiceProtocol.Ws)
            {
                serviceDescriptor.Metadatas.Add(ServiceConstant.WsPath,
                    WebSocketResolverHelper.ParseWsPath(service.ServiceType));
            }

            return serviceDescriptor;
        }

[ServiceKey("v1", 3)]
public class TestAppService : ITestAppService
{
    
}

    [AttributeUsage(AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
    public class ServiceKeyAttribute : Attribute, IServiceKeyProvider
    {
        public ServiceKeyAttribute(string name, int weight)
        {
            Name = name;
            Weight = weight;
        }

        public string Name { get; }

        public int Weight { get; }
    }

public Service CreateWsService(Type wsServiceType)
{
    var wsPath = WebSocketResolverHelper.ParseWsPath(wsServiceType);
    var serviceId = WebSocketResolverHelper.Generator(wsPath);
      
    var serviceInfo = new Service()
    {
        Id = serviceId,
        ServiceType = wsServiceType,
        IsLocal = true,
        ServiceProtocol = ServiceProtocol.Ws,
        ServiceEntries =  _serviceEntryManager.GetServiceEntries(serviceId)
    };
    serviceInfo.ServiceDescriptor = CreateServiceDescriptor(serviceInfo);
    return serviceInfo;
}

public class DefaultServiceEntryManager : IServiceEntryManager
{
    private IEnumerable<ServiceEntry> m_localServiceEntries;  //用于缓存本地服务条目
    private IEnumerable<ServiceEntry> m_allServiceEntries;  // 用于缓存全部服务条目
    private IChangeToken? _changeToken;

    public DefaultServiceEntryManager(IEnumerable<IServiceEntryProvider> providers)
    {
        UpdateEntries(providers);
    }

    private void UpdateEntries(IEnumerable<IServiceEntryProvider> providers)
    {
        var allServiceEntries = new List<ServiceEntry>();
        foreach (var provider in providers) // 遍历所有服务条目提供者,有服务条目服务者创建服务条目
        {
            var entries = provider.GetEntries();
            foreach (var entry in entries)
            {
                if (allServiceEntries.Any(p => p.ServiceEntryDescriptor.Id == entry.ServiceEntryDescriptor.Id))
                {
                    throw new InvalidOperationException(
                        $"Locally contains multiple service entries with Id: {entry.ServiceEntryDescriptor.Id}");
                }
                allServiceEntries.Add(entry);
            }
        }
        if (allServiceEntries.GroupBy(p => p.Router).Any(p => p.Count() > 1))
        {
            throw new SilkyException(
                "There is duplicate routing information, please check the service routing you set");
        }
        m_allServiceEntries = allServiceEntries;
        m_localServiceEntries = allServiceEntries.Where(p => p.IsLocal);
    }

    public void Update(ServiceEntry serviceEntry)
    {
        m_allServiceEntries = m_allServiceEntries
            .Where(p => !p.ServiceEntryDescriptor.Id.Equals(serviceEntry.ServiceEntryDescriptor.Id))
            .Append(serviceEntry);
        if (serviceEntry.IsLocal)
        {
            m_localServiceEntries = m_localServiceEntries
                .Where(p => !p.ServiceEntryDescriptor.Id.Equals(serviceEntry.ServiceEntryDescriptor.Id))
                .Append(serviceEntry);
        }
        OnUpdate?.Invoke(this, serviceEntry);
    }

   // 其他代码略...
}

public class DefaultServiceEntryProvider : IServiceEntryProvider
{
    public IReadOnlyList<ServiceEntry> GetEntries()
    {
        var serviceTypeInfos = ServiceHelper.FindAllServiceTypes(_typeFinder);
        if (!EngineContext.Current.IsContainHttpCoreModule())
        {
            serviceTypeInfos = serviceTypeInfos.Where(p =>
                p.Item1.GetCustomAttributes().OfType<DashboardAppServiceAttribute>().FirstOrDefault() == null);
        }
        var entries = new List<ServiceEntry>();
        foreach (var serviceTypeInfo in serviceTypeInfos)
        {
            Logger.LogDebug("The Service were be found,type:{0},IsLocal:{1}", serviceTypeInfo.Item1.FullName,
                serviceTypeInfo.Item2);
            entries.AddRange(_serviceEntryGenerator.CreateServiceEntry(serviceTypeInfo));
        }

        return entries;
    }
   
// 其他代码略...

}

public class DefaultServiceEntryGenerator : IServiceEntryGenerator
{
   public IEnumerable<ServiceEntry> CreateServiceEntry((Type, bool) serviceType)
   {
        var serviceBundleProvider = ServiceDiscoveryHelper.GetServiceBundleProvider(serviceType.Item1);
        var methods = serviceType.Item1.GetTypeInfo().GetMethods();
        foreach (var method in methods)
        {
            var httpMethodInfos = method.GetHttpMethodInfos();
            foreach (var httpMethodInfo in httpMethodInfos)
            {
                yield return Create(method,
                    serviceType.Item1,
                    serviceType.Item2,
                    serviceBundleProvider,
                    httpMethodInfo);
            }
        }
    }

    private ServiceEntry Create(MethodInfo method,
            Type serviceType,
            bool isLocal,
            IRouteTemplateProvider routeTemplateProvider,
            HttpMethodInfo httpMethodInfo)
        {
            var serviceName = serviceType.Name;
            var serviceEntryId = _idGenerator.GenerateServiceEntryId(method, httpMethodInfo.HttpMethod);
            var serviceId = _idGenerator.GenerateServiceId(serviceType);
            var parameterDescriptors = _parameterProvider.GetParameterDescriptors(method, httpMethodInfo);
            if (parameterDescriptors.Count(p => p.IsHashKey) > 1)
            {
                throw new SilkyException(
                    $"It is not allowed to specify multiple HashKey,Method is {serviceType.FullName}.{method.Name}");
            }
            
            var serviceEntryTemplate =
                TemplateHelper.GenerateServerEntryTemplate(routeTemplateProvider.Template, parameterDescriptors,
                    httpMethodInfo, _governanceOptions.ApiIsRESTfulStyle,
                    method.Name);

            var router = new Router(serviceEntryTemplate, serviceName, method, httpMethodInfo.HttpMethod);
            Debug.Assert(method.DeclaringType != null);
            var serviceEntryDescriptor = new ServiceEntryDescriptor()
            {
                Id = serviceEntryId,
                ServiceId = serviceId,
                ServiceName = routeTemplateProvider.GetServiceName(serviceType),
                ServiceProtocol = ServiceHelper.GetServiceProtocol(serviceType, isLocal, false),
                Method = method.Name,
            };

            var metaDataList = method.GetCustomAttributes<MetadataAttribute>();

            foreach (var metaData in metaDataList)
            {
                serviceEntryDescriptor.Metadatas.Add(metaData.Key, metaData.Value);
            }

            var serviceEntry = new ServiceEntry(router,
                serviceEntryDescriptor,
                serviceType,
                method,
                parameterDescriptors,
                isLocal,
                _governanceOptions);

            if (serviceEntry.NeedHttpProtocolSupport())
            {
                serviceEntryDescriptor.Metadatas.Add(ServiceEntryConstant.NeedHttpProtocolSupport, true);
            }
            
            return serviceEntry;
        }

   // 其他代码略...

   
}

        public static ICollection<HttpMethodInfo> GetHttpMethodInfos(this MethodInfo method)
        {
            var httpMethodAttributeInfo = method.GetHttpMethodAttributeInfos();
            var httpMethods = new List<HttpMethodInfo>();

            foreach (var httpMethodAttribute in httpMethodAttributeInfo.Item1)
            {
                var httpMethod = httpMethodAttribute.HttpMethods.First().To<HttpMethod>();
                if (!httpMethodAttributeInfo.Item2)
                {
                    if (method.Name.StartsWith("Create"))
                    {
                        httpMethod = HttpMethod.Post;
                    }

                    if (method.Name.StartsWith("Update"))
                    {
                        httpMethod = HttpMethod.Put;
                    }

                    if (method.Name.StartsWith("Delete"))
                    {
                        httpMethod = HttpMethod.Delete;
                    }

                    if (method.Name.StartsWith("Search"))
                    {
                        httpMethod = HttpMethod.Get;
                    }

                    if (method.Name.StartsWith("Query"))
                    {
                        httpMethod = HttpMethod.Get;
                    }

                    if (method.Name.StartsWith("Get"))
                    {
                        httpMethod = HttpMethod.Get;
                    }
                }

                httpMethods.Add(new HttpMethodInfo()
                {
                    IsSpecify = httpMethodAttributeInfo.Item2,
                    Template = httpMethodAttribute.Template,
                    HttpMethod = httpMethod
                });
            }

            return httpMethods;
        }

    internal ServiceEntry(IRouter router,
            ServiceEntryDescriptor serviceEntryDescriptor,
            Type serviceType,
            MethodInfo methodInfo,
            IReadOnlyList<ParameterDescriptor> parameterDescriptors,
            bool isLocal,
            GovernanceOptions governanceOptions)
        {
            Router = router;
            _serviceEntryDescriptor = serviceEntryDescriptor;
            ParameterDescriptors = parameterDescriptors;
            _serviceType = serviceType;
            IsLocal = isLocal;
            MethodInfo = methodInfo;
            CustomAttributes = MethodInfo.GetCustomAttributes(true);
            (IsAsyncMethod, ReturnType) = MethodInfo.ReturnTypeInfo();
            GovernanceOptions = new ServiceEntryGovernance(governanceOptions); // 根据服务治理配置创建服务条目治理属性

            var governanceProvider = CustomAttributes.OfType<IGovernanceProvider>().FirstOrDefault();
            ReConfiguration(governanceProvider); // 更新服务条目的服务治理配置属性

            _methodExecutor = methodInfo.CreateExecutor(serviceType); // 创建方法执行器
            Executor = CreateExecutor();  //创建服务条目执行器
            AuthorizeData = CreateAuthorizeData(); // 解析服务条目的身份认证元数据

            ClientFilters = CreateClientFilters();  // 解析客户端过滤器
            ServerFilters = CreateServerFilters();  // 解析服务端过滤器
            CreateFallBackExecutor();   // 创建失败回调执行器
            CreateDefaultSupportedRequestMediaTypes();  // 创建默认的请求媒体类型 
            CreateDefaultSupportedResponseMediaTypes(); // 创建默认的响应媒体类型
            CreateCachingInterceptorDescriptors();  // 创建缓存拦截描述符
        }

public class DefaultServiceGenerator : IServiceGenerator
{
    private readonly IIdGenerator _idGenerator;
    private readonly ITypeFinder _typeFinder;
    private readonly IServiceEntryManager _serviceEntryManager;
    
    public DefaultServiceGenerator(IIdGenerator idGenerator,
        ITypeFinder typeFinder,
        IServiceEntryManager serviceEntryManager)
    {
        _idGenerator = idGenerator;
        _typeFinder = typeFinder;
        _serviceEntryManager = serviceEntryManager;
    }
}

public class DefaultServerProvider : IServerProvider
{
    public ILogger<DefaultServerProvider> Logger { get; set; }
    private readonly IServer _server;
    private readonly IServiceManager _serviceManager;
    private readonly ISerializer _serializer;

    public DefaultServerProvider(IServiceManager serviceManager,
        ISerializer serializer)
    {
        _serviceManager = serviceManager;
        _serializer = serializer;
        Logger = EngineContext.Current.Resolve<ILogger<DefaultServerProvider>>();
        _server = new Server(EngineContext.Current.HostName);
    }
}