private static FieldDelegate CreateDelegate <TMiddleware>(
Func <IServiceProvider, FieldDelegate, TMiddleware> factory,
FieldDelegate next)
where TMiddleware : class
{
object sync = new object();
TMiddleware middleware = null;
ClassQueryDelegate <TMiddleware, IMiddlewareContext> compiled =
MiddlewareActivator
.CompileMiddleware <TMiddleware, IMiddlewareContext>();
return(context =>
{
if (middleware == null)
{
lock (sync)
{
if (middleware == null)
{
middleware = factory(
context.Service <IServiceProvider>(),
next);
}
}
}
return compiled(
context,
context.Service <IServiceProvider>(),
middleware);
});
}
public void CompileDelegate()
{
// arrange
MiddlewareFactory <CustomClassMiddleware, IServiceProvider, CustomDelegate> factory =
MiddlewareCompiler <CustomClassMiddleware>
.CompileFactory <IServiceProvider, CustomDelegate>(
(services, next) =>
new List <IParameterHandler>
{
new TypeParameterHandler(typeof(string), Expression.Constant("abc")),
new ServiceParameterHandler(services)
});
CustomClassMiddleware middleware =
factory.Invoke(new EmptyServiceProvider(), c => default);
// act
ClassQueryDelegate <CustomClassMiddleware, CustomContext> pipeline =
MiddlewareCompiler <CustomClassMiddleware> .CompileDelegate <CustomContext>(
(context, middleware) =>
new List <IParameterHandler>
{
new TypeParameterHandler(typeof(string), Expression.Constant("def"))
});
// assert
var context = new CustomContext(new EmptyServiceProvider());
pipeline.Invoke(context, middleware);
Assert.Equal("abcdef", context.Result);
}
internal static DirectiveDelegate CreateDelegate <TMiddleware>(
Func <IServiceProvider, FieldDelegate, TMiddleware> factory,
FieldDelegate next)
where TMiddleware : class
{
object sync = new object();
TMiddleware middleware = null;
ClassQueryDelegate <TMiddleware, IDirectiveContext> compiled =
MiddlewareCompiler <TMiddleware> .CompileDelegate <IDirectiveContext>(
(context, middleware) => new List <IParameterHandler>
{
new ServiceParameterHandler(Expression.Property(context, _services))
});
return(context =>
{
if (middleware is null)
{
lock (sync)
{
middleware = middleware ?? factory(context.Services, next);
}
}
return compiled(context, middleware);
});
}
internal static RequestDelegate CreateDelegate <TMiddleware>(
Func <IServiceProvider, RequestDelegate, TMiddleware> factory,
RequestDelegate next)
where TMiddleware : class
{
object sync = new object();
TMiddleware?middleware = null;
ClassQueryDelegate <TMiddleware, IRequestContext> compiled =
MiddlewareActivator.CompileMiddleware <TMiddleware, IRequestContext>();
return(context =>
{
if (middleware == null)
{
lock (sync)
{
if (middleware == null)
{
middleware = factory(context.Services, next);
}
}
}
return compiled(context, context.Services, middleware);
});
}
internal static RequestCoreMiddleware Create <TMiddleware>()
where TMiddleware : class
{
return((context, next) =>
{
TMiddleware middleware =
MiddlewareCompiler <TMiddleware>
.CompileFactory <IRequestCoreMiddlewareContext, RequestDelegate>(
(c, n) => CreateFactoryParameterHandlers(c, context.Options))
.Invoke(context, next);
ClassQueryDelegate <TMiddleware, IRequestContext> compiled =
MiddlewareCompiler <TMiddleware> .CompileDelegate <IRequestContext>(
(c, m) => CreateDelegateParameterHandlers(c, context.Options));
return c => compiled(c, middleware);
});
}
