private static IPipelineBuilder <TService, TContext> UseMiddlewareInterface <TService, TContext>(IPipelineBuilder <TService, TContext> app, Type middlewareType) where TService : BaseDomainService where TContext : IRequestContext { return(app.Use(next => { return async context => { IMiddlewareFactory <TContext> middlewareFactory = (IMiddlewareFactory <TContext>)context.RequestServices.GetService(typeof(IMiddlewareFactory <TContext>)); if (middlewareFactory == null) { // No middleware factory throw new InvalidOperationException("UseMiddlewareNoMiddlewareFactory(typeof(IMiddlewareFactory))"); } IMiddleware <TContext> middleware = middlewareFactory.Create(middlewareType); if (middleware == null) { // The factory returned null, it's a broken implementation throw new InvalidOperationException("UseMiddlewareUnableToCreateMiddleware(middlewareFactory.GetType(), middlewareType)"); } try { await middleware.InvokeAsync(context, next); } finally { middlewareFactory.Release(middleware); } }; })); }
public static IApplicationBuilder UseMiddleware <TMiddleware>(this IApplicationBuilder app) where TMiddleware : IMiddleware { return(app.Use(next => { IMiddlewareFactory middlewareFactory = (IMiddlewareFactory)app.ApplicationServices.GetService(typeof(IMiddlewareFactory)); var middleware = middlewareFactory.Create(typeof(TMiddleware)); if (middleware == null) { // The factory returned null, it's a broken implementation throw new InvalidOperationException(string.Format("Create middleware failed, middleware factory:{0},{1}", middlewareFactory.GetType(), typeof(TMiddleware))); } return async context => { try { await middleware.InvokeAsync(context, next); } finally { middlewareFactory.Release(middleware); } }; })); }
///// <summary> ///// Adds a middleware type to the application's request pipeline. ///// </summary> ///// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param> ///// <param name="middleware">The middleware type.</param> ///// <param name="args">The arguments to pass to the middleware type instance's constructor.</param> ///// <returns>The <see cref="IApplicationBuilder"/> instance.</returns> //public static IApplicationBuilder UseMiddleware(this IApplicationBuilder app, Type middleware, params object[] args) //{ // if (typeof(IMiddleware).GetTypeInfo().IsAssignableFrom(middleware.GetTypeInfo())) // { // // IMiddleware doesn't support passing args directly since it's // // activated from the container // if (args.Length > 0) // { // throw new NotSupportedException(string.Format("IMiddleware {0} doesn't support passing args directly.", typeof(IMiddleware))); // } // return UseMiddleware(app, middleware); // } // IServiceProvider applicationServices = app.ApplicationServices; // return app.Use(next => // { // MethodInfo[] invokeMethods = middleware.GetMethods(BindingFlags.Instance | BindingFlags.Public) // .Where(m => string.Equals(m.Name, InvokeMethodName, StringComparison.Ordinal) // || string.Equals(m.Name, InvokeAsyncMethodName, StringComparison.Ordinal)) // .ToArray(); // if (invokeMethods.Length > 1) // throw new InvalidOperationException(Resources.FormatException_UseMiddleMutlipleInvokes(InvokeMethodName, InvokeAsyncMethodName)); // if (invokeMethods.Length == 0) // throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNoInvokeMethod(InvokeMethodName, InvokeAsyncMethodName, middleware)); // MethodInfo methodInfo = invokeMethods[0]; // if (!typeof(Task).IsAssignableFrom(methodInfo.ReturnType)) // throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNonTaskReturnType(InvokeMethodName, InvokeAsyncMethodName, nameof(Task))); // ParameterInfo[] parameters = methodInfo.GetParameters(); // if (parameters.Length == 0 || parameters[0].ParameterType != typeof(HttpContext)) // throw new InvalidOperationException(Resources.FormatException_UseMiddlewareNoParameters(InvokeMethodName, InvokeAsyncMethodName, nameof(HttpContext))); // object[] ctorArgs = new object[args.Length + 1]; // ctorArgs[0] = next; // Array.Copy(args, 0, ctorArgs, 1, args.Length); // var instance = ActivatorUtilities.CreateInstance(app.ApplicationServices, middleware, ctorArgs); // if (parameters.Length == 1) // { // return (RequestDelegate)methodInfo.CreateDelegate(typeof(RequestDelegate), instance); // } // var factory = Compile<object>(methodInfo, parameters); // return context => // { // var serviceProvider = context.RequestServices ?? applicationServices; // if (serviceProvider == null) // { // throw new InvalidOperationException(Resources.FormatException_UseMiddlewareIServiceProviderNotAvailable(nameof(IServiceProvider))); // } // return factory(instance, context, serviceProvider); // }; // }); //} public static IApplicationBuilder UseMiddleware(this IApplicationBuilder app, Type middlewareType) { return(app.Use(next => { return async context => { IMiddlewareFactory middlewareFactory = (IMiddlewareFactory)context.RequestServices.GetService(typeof(IMiddlewareFactory)); if (middlewareFactory == null) { throw new InvalidOperationException(string.Format("There is not instance of the {0} configured.", typeof(IMiddlewareFactory))); } IConsoleMiddleware middleware = middlewareFactory.Create(middlewareType); if (middleware == null) { throw new InvalidOperationException(string.Format("The factory {0} cannot create a middleware of type {1}.", middlewareFactory.GetType(), middlewareType)); } try { await middleware.InvokeAsync(context, next); } finally { middlewareFactory.Release(middleware); } }; })); }
public object GetService(Type serviceType) { if (serviceType == typeof(IMiddlewareFactory)) { return(new MiddlewareFactory(Commands)); } if (serviceType == typeof(MiddlewareCollection)) { IMiddlewareFactory middlewareFactory = (IMiddlewareFactory)GetService(typeof(IMiddlewareFactory)); return(new MiddlewareCollection(middlewareFactory)); } return(Activator.CreateInstance(serviceType)); }
private static IApplicationBuilder UseMiddlewareInterface(IApplicationBuilder app, Type middlewareType) { return(app.Use((RequestDelegate next) => async delegate(HttpContext context) { IMiddlewareFactory middlewareFactory = (IMiddlewareFactory)context.RequestServices.GetService(typeof(IMiddlewareFactory)); if (middlewareFactory == null) { throw new InvalidOperationException(FormatException(typeof(IMiddlewareFactory))); } IMiddleware middleware = middlewareFactory.Create(middlewareType); if (middleware == null) { throw new InvalidOperationException(FormatException(middlewareFactory.GetType(), middlewareType)); } try { await middleware.InvokeAsync(context, next); } finally { middlewareFactory.Release(middleware); } })); }
public PipelineFactory(IMiddlewareFactory middlewareFactory, IContextFactory contextFactory) { _middlewareFactory = middlewareFactory; _contextFactory = contextFactory; }
internal AuthorizedPipeline(IContextFactory contextFactory, IMiddlewareFactory middlewareFactory) : base(contextFactory) { Register(middlewareFactory.CorrelationId()); Register(middlewareFactory.FunctionHostKey()); Register(middlewareFactory.FunctionHostKey()); }
public Pipeline(IMiddlewareFactory factory) { _factory = factory; }
public MiddlewareCollection(IMiddlewareFactory middlewareFactory) { this.middlewareFactory = middlewareFactory ?? throw new ArgumentNullException(nameof(middlewareFactory)); }
public ValuesController(IMiddlewareFactory middlewareFactory) { _middlewareFactory = middlewareFactory; _factoryMidd = _middlewareFactory.Create(typeof(FactoryActivatedMiddleware)); }