public async Task Authorize()
{
Assert.False(_httpContext.User.HasClaim("role", "Admin"));
_configuration[GraphQLService.SecretTokenKey] = _secretToken;
_httpContext.Request.Headers.Add("Authorization", $"Basic {_secretToken}");
await _middleware.InvokeAsync(
_httpContext,
_requestDelegate);
Assert.True(_httpContext.User.HasClaim("role", "Admin"));
}
public static void UseMiddleware(
this SimpleInjectorUseOptions options, Type middlewareType, IApplicationBuilder app)
{
Requires.IsNotNull(options, nameof(options));
Requires.IsNotNull(middlewareType, nameof(middlewareType));
Requires.IsNotNull(app, nameof(app));
Requires.ServiceIsAssignableFromImplementation(
typeof(IMiddleware), middlewareType, nameof(middlewareType));
Requires.IsNotOpenGenericType(middlewareType, nameof(middlewareType));
var container = options.Container;
var lifestyle = container.Options.LifestyleSelectionBehavior.SelectLifestyle(middlewareType);
// By creating an InstanceProducer up front, it will be known to the container, and will be part
// of the verification process of the container.
InstanceProducer <IMiddleware> producer =
lifestyle.CreateProducer <IMiddleware>(middlewareType, container);
app.Use((c, next) =>
{
IMiddleware middleware = producer.GetInstance();
return(middleware.InvokeAsync(c, _ => next()));
});
}
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);
}
};
}));
}
/// <summary>
/// Adds a middleware type to the application's request pipeline. The middleware will be resolved from
/// the supplied the Simple Injector <paramref name="container"/>. The middleware will be added to the
/// container for verification.
/// </summary>
/// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param>
/// <param name="middlewareType">The middleware type that needs to be applied. This type must
/// implement <see cref="IMiddleware"/>.</param>
/// <param name="container">The container to resolve <paramref name="middlewareType"/> from.</param>
/// <returns>The supplied <see cref="IApplicationBuilder"/> instance.</returns>
/// <exception cref="ArgumentNullException">Thrown when one of the arguments is a null reference.</exception>
/// <exception cref="ArgumentException">Thrown when the <paramref name="middlewareType"/> does not
/// derive from <see cref="IMiddleware"/>, is an open-generic type, or not a concrete constructable
/// type.</exception>
public static IApplicationBuilder UseMiddleware(
this IApplicationBuilder app, Type middlewareType, Container container)
{
Requires.IsNotNull(app, nameof(app));
Requires.IsNotNull(middlewareType, nameof(middlewareType));
Requires.IsNotNull(container, nameof(container));
Requires.ServiceIsAssignableFromImplementation(
typeof(IMiddleware), middlewareType, nameof(middlewareType));
Requires.IsNotOpenGenericType(middlewareType, nameof(middlewareType));
var lifestyle = container.Options.LifestyleSelectionBehavior.SelectLifestyle(middlewareType);
// By creating an InstanceProducer up front, it will be known to the container, and will be part
// of the verification process of the container.
// Note that the middleware can't be registered in the container, because at this point the
// container might already be locked (which will happen when the new ASP.NET Core 3 Host class is
// used).
InstanceProducer <IMiddleware> producer =
lifestyle.CreateProducer <IMiddleware>(middlewareType, container);
app.Use((c, next) =>
{
IMiddleware middleware = producer.GetInstance();
return(middleware.InvokeAsync(c, _ => next()));
});
return(app);
}
/// <summary>
/// Adds a middleware type to the application's request pipeline. The middleware will be resolved from the supplied
/// the Simple Injector <paramref name="container"/>. The middleware will be added to the container for verification.
/// </summary>
/// <typeparam name="TMiddleware">The middleware type.</typeparam>
/// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param>
/// <param name="container">The container to resolve <typeparamref name="TMiddleware"/> from.</param>
/// <returns>The supplied <see cref="IApplicationBuilder"/> instance.</returns>
public static IApplicationBuilder UseMiddleware <TMiddleware>(this IApplicationBuilder app, Container container)
where TMiddleware : class, IMiddleware
{
if (app == null)
{
throw new ArgumentNullException(nameof(app));
}
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
var lifestyle = container.Options.LifestyleSelectionBehavior.SelectLifestyle(typeof(TMiddleware));
// By creating an InstanceProducer up front, it will be known to the container, and will be part of the
// verification process of the container.
InstanceProducer <IMiddleware> producer = lifestyle.CreateProducer <IMiddleware, TMiddleware>(container);
app.Use((c, next) =>
{
IMiddleware middleware = producer.GetInstance();
return(middleware.InvokeAsync(c, _ => next()));
});
return(app);
}
public AppBuilder Use <TMiddleWare>(Func <TMiddleWare> getInstance) where TMiddleWare : IMiddleware
{
return(this.Use(next =>
{
IMiddleware middleware = getInstance.Invoke();
if (middleware == null)
{
throw new InvalidOperationException($"cannot get instance of type {typeof(TMiddleWare).ToString()}");
}
return async context =>
{
await middleware.InvokeAsync(context, next);
};
}));
}
/// <summary>
/// Adds a middleware type to the application's request pipeline. The middleware will be resolved
/// from Simple Injector. The middleware will be added to the container for verification.
/// </summary>
/// <typeparam name="TMiddleware">The middleware type.</typeparam>
/// <param name="options">The <see cref="SimpleInjectorUseOptions"/>.</param>
/// <param name="app">The <see cref="IApplicationBuilder"/> instance.</param>
public static void UseMiddleware <TMiddleware>(
this SimpleInjectorUseOptions options, IApplicationBuilder app)
where TMiddleware : class, IMiddleware
{
Requires.IsNotNull(options, nameof(options));
Requires.IsNotNull(app, nameof(app));
var container = options.Container;
var lifestyle = container.Options.LifestyleSelectionBehavior.SelectLifestyle(typeof(TMiddleware));
// By creating an InstanceProducer up front, it will be known to the container, and will be part
// of the verification process of the container.
InstanceProducer <IMiddleware> producer =
lifestyle.CreateProducer <IMiddleware, TMiddleware>(container);
app.Use((c, next) =>
{
IMiddleware middleware = producer.GetInstance();
return(middleware.InvokeAsync(c, _ => next()));
});
}
public void InvokeAsync_SetsActivityPropetry()
{
HttpContext context1 = HttpContextHelper.GetContextWithIp("192.168.0.4");
HttpContext context2 = HttpContextHelper.GetContextWithIp("127.0.0.4");
IMiddleware middleware = GetMiddelware();
string GetActivityUserHash(HttpContext context)
{
Activity activity = new Activity(nameof(InvokeAsync_SetsActivityPropetry)).Start();
middleware.InvokeAsync(context, c => Task.CompletedTask);
activity.Stop();
return(activity.GetUserHash());
}
string hash1 = GetActivityUserHash(context1);
string hash2 = GetActivityUserHash(context2);
Assert.AreNotEqual(hash1, hash2);
Assert.AreEqual(hash1, GetActivityUserHash(context1));
Assert.AreEqual(hash2, GetActivityUserHash(context2));
}
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);
}
}));
}
private static void UseMiddleware(IApplicationBuilder app, IMiddleware middleware) => app.Use((c, next) => middleware.InvokeAsync(c, _ => next()));
public async Task HandlerB0T0P0E0D0()
{
await _middleware1.InvokeAsync(CreateHttpContext("b0t0p0e0d0"), FinishInvokeChain).ConfigureAwait(false);
}
/// <inheritdoc />
public Task InvokeAsync(HttpContext context, RequestDelegate next)
{
return(_etag.InvokeAsync(context, next));
}
