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