public static IWebHostBuilder UseStartup(this IWebHostBuilder builder, Type startupType)
        {
            var typeInfo     = startupType.GetTypeInfo();
            var constructors = typeInfo.GetConstructors()
                               .Where(x => x.IsPublic)
                               .OrderBy(x => x.GetParameters().Length);

            IStartup startup = null;

            foreach (var constructor in constructors)
            {
                var parameters = constructor.GetParameters();
                var objParams  = new object[parameters.Length];
                int i          = 0;
                for (i = 0; i < parameters.Length; i++)
                {
                    if (DefaultParamterValue.TryGetDefaultValue(parameters[i], out var value))
                    {
                        objParams[i] = value;
                        var x = new ConfigurationBuilder();
                    }
                    else
                    {
                        break;
                    }
                }

                if (i < parameters.Length)
                {
                    continue;
                }

                startup = (IStartup)constructor.Invoke(objParams);
                break;
            }

            if (startup == null)
            {
                throw new InvalidOperationException("操作失败,无法构造出Startup类");
            }

            return(builder.Configure(
                       services => startup.ConfigureServices(services),
                       app => startup.Configure(app)));
        }
Example #2
0
        public bool TryBindModel(HttpContext httpContext, IValueProvider valueProvider, ParameterInfo parameter, out object value)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException(nameof(httpContext));
            }

            if (valueProvider == null)
            {
                throw new ArgumentNullException(nameof(valueProvider));
            }

            if (parameter == null)
            {
                throw new ArgumentNullException(nameof(parameter));
            }

            value = null;
            if (!String.IsNullOrWhiteSpace(httpContext.RouteEntity.ParameterValue) &&
                String.Equals(httpContext.RouteEntity.DefaultParameter,
                              parameter.Name,
                              StringComparison.OrdinalIgnoreCase))
            {
                if (httpContext.RouteEntity.ParameterValue != null)
                {
                    TypeConverter converter = TypeDescriptor.GetConverter(parameter.ParameterType);
                    try
                    {
                        value = converter.ConvertTo(httpContext.RouteEntity.ParameterValue, parameter.ParameterType);
                        return(true);
                    }
                    catch
                    {
                    }
                }
            }

            var binderProviders = httpContext.Service.GetRequiredService <IModelBinderProvider>();
            var modelBinder     = binderProviders.GetBinder(parameter.ParameterType);
            var modelMetadata   = httpContext.Service.GetRequiredService <IModelMetadataProvider>().GetMetadataForType(null, parameter.ParameterType);

            //var modelBinderModelBinders.Binders.GetBinder(paramDescriptor.ParameterType);

            if (TryBindValue(modelBinder, modelMetadata, httpContext, valueProvider, "", out var paramValue))
            {
                value = paramValue;
                return(true);
            }

            if (TryBindValue(modelBinder, modelMetadata, httpContext, valueProvider, parameter.Name, out paramValue))
            {
                value = paramValue;
                return(true);
            }

            // 尝试依赖注入
            modelBinder = binderProviders.GetBinder(typeof(IServiceProvider));

            if (TryBindValue(modelBinder, modelMetadata, httpContext, valueProvider, "", out paramValue))
            {
                value = paramValue;
                return(true);
            }

            if (DefaultParamterValue.TryGetDefaultValue(parameter, out paramValue))
            {
                // 注:默认值可能为Null
                value = paramValue;
                return(true);
            }
            else if (TypeHelper.IsNullableValueType(modelMetadata.ModelType))
            {
                value = null;
                return(true);
            }
            else
            {
                return(false);
            }
        }