public LogDecorator(
IAsyncRequestHandler <TRequest, TResponse> inner,
ILogger <LogDecorator <TRequest, TResponse> > logger)
{
_inner = inner;
_logger = logger;
}
public UserInputState(
GameModel gameModel,
IAsyncRequestHandler <GameStateEnum, int> answerRequestHandler)
{
_gameModel = gameModel;
_answerRequestHandler = answerRequestHandler;
}
public AsyncValidatorHandler(
IAsyncRequestHandler <TRequest, TResponse> inner,
IValidator <TRequest>[] validators)
{
_inner = inner;
_validators = validators;
}
public MediatorPipeline(IAsyncRequestHandler <TRequest, TResponse> inner,
IRequestMiddleware <TRequest, TResponse>[] middleware)
{
_inner = inner;
_middleware = middleware;
Array.Sort(_middleware, RelativeOrderAttribute.Compare);
}
public IHandlerSetup WithRequestHandler <TRequest, TResponse>(IAsyncRequestHandler <TRequest, TResponse> handler)
where TRequest : class
where TResponse : class
{
requestDispatcher.Register(handler);
return(this);
}
public SortedAccountTransactionsRequestHandler(
IAsyncRequestHandler <AccountTransactionsRequest, AccountTransactions> decoratedHandler)
{
Guard.That(() => decoratedHandler).IsNotNull();
_decoratedHandler = decoratedHandler;
}
public AsyncValidationRequestHandler(
IAsyncRequestHandler <TRequest, TResponse> inner,
IEnumerable <IValidator <TRequest> > validators)
{
Debug.WriteLine($"Create {GetType().Name}");
_inner = inner;
_validators = validators;
}
public AsyncMediatorPipeline(
IAsyncRequestHandler <TRequest, TResponse> inner,
IAsyncPreRequestHandler <TRequest>[] preRequestHandlers
)
{
_inner = inner;
_preRequestHandlers = preRequestHandlers;
}
public void RegisterQueryHandler <TQuery, TResponse>(IAsyncRequestHandler <TQuery, TResponse> queryHandler)
where TQuery : IRequest <TResponse>
{
Register(typeof(IAsyncRequestHandler <TQuery, TResponse>), queryHandler);
//Registration needed internally by MediatR
Register(typeof(IPipelineBehavior <TQuery, TResponse>), new object[] { });
Register(typeof(IRequestHandler <TQuery, TResponse>), new IRequestHandler <TQuery, TResponse>[] { });
}
public AsyncMediatorPipeline(IAsyncRequestHandler <TRequest, TResponse> inner,
IAsyncPreRequestHandler <TRequest>[] preRequestHandlers,
IAsyncPostRequestHandler <TRequest, TResponse>[] postRequestHandlers)
{
this.inner = inner;
this.preRequestHandlers = preRequestHandlers;
this.postRequestHandlers = postRequestHandlers;
}
/// <summary>
/// Registers an <see cref="IAsyncRequestHandler{TRequest, TResponse}"/>
/// </summary>
/// <typeparam name="TRequest">Type of request message</typeparam>
/// <typeparam name="TResponse">Type of response message</typeparam>
/// <param name="handler">Request handler instance</param>
public void Register <TRequest, TResponse>(IAsyncRequestHandler <TRequest, TResponse> handler)
{
ValidateTypes <TRequest, TResponse>();
requestHandlers.Add(
typeof(TRequest),
request =>
handler
.Handle((TRequest)request)
.GetAwaiter()
.GetResult());
}
public AsyncDbContextScopeBoundary(
IDbContextScopeFactory dbContextScopeFactory,
IAsyncRequestHandler <TRequest, TResponse> inner
)
{
if (dbContextScopeFactory == null)
{
throw new ArgumentNullException("dbContextScopeFactory");
}
_dbContextScopeFactory = dbContextScopeFactory;
_inner = inner;
}
public SecurityGuardAsync(
IAsyncRequestHandler <TRequest, TResponse> innerCommand,
RequestHandlerGuardRegister requestHandlerGuardRegister,
DependencyInjectionContainer dependencyInjectionContainer,
UserContext userContext,
SystemPermissionManager permissionManager)
{
this.InnerCommand = innerCommand;
this.requestHandlerGuardRegister = requestHandlerGuardRegister;
this.dependencyInjectionContainer = dependencyInjectionContainer;
this.userContext = userContext;
this.permissionManager = permissionManager;
}
public void Setup()
{
receiver = mockReceiver.Object;
handler = mockHandler.Object;
asyncHandler = mockAsyncHandler.Object;
mockHandler
.Setup(m => m.Handle(It.IsAny <Request>()))
.Returns(response);
mockAsyncHandler
.Setup(m => m.Handle(It.IsAny <Request>()))
.Returns(Task.FromResult(response));
}
public void Run(IAsyncRequestHandler requestHandler)
{
Task.Run(() =>
{
try
{
// Start the HTTP listener:
_listener.Start();
}
catch (HttpListenerException hlex)
{
Console.Error.WriteLine(hlex.Message);
return;
}
// Accept connections:
// Higher values mean more connections can be maintained yet at a much slower average response time; fewer connections will be rejected.
// Lower values mean less connections can be maintained yet at a much faster average response time; more connections will be rejected.
var sem = new Semaphore(_accepts, _accepts);
while (true)
{
sem.WaitOne();
#pragma warning disable 4014
_listener.GetContextAsync().ContinueWith(async (t) =>
{
string errMessage;
try
{
sem.Release();
var ctx = await t;
await ProcessListenerContext(ctx, requestHandler);
return;
}
catch (Exception ex)
{
errMessage = ex.ToString();
}
await Console.Error.WriteLineAsync(errMessage);
});
#pragma warning restore 4014
}
}).Wait();
}
public GetMeetupsHandlerTests()
{
var meetups = new List <Meetup>
{
new Meetup
{
Id = 1,
Name = "React London",
Location = "London",
StartTime = DateTime.Today,
EndTime = DateTime.Today
}
};
var mockSet = DbSetHelper.MockDbSet(meetups);
_db.Setup(o => o.Meetups).Returns(mockSet.Object);
_handler = new GetMeetupsHandler(_db.Object);
}
public GetMeetupHandlerTests()
{
var meetups = new List <Meetup>
{
new Meetup
{
Id = 1,
Name = "React London",
Location = "London",
StartTime = DateTime.Today,
EndTime = DateTime.Today
}
};
var mockSet = new Mock <DbSet <Meetup> >();
mockSet.Setup(o => o.FindAsync(1)).ReturnsAsync(meetups.FirstOrDefault());
_db.Setup(o => o.Meetups).Returns(mockSet.Object);
_handler = new GetMeetupHandler(_db.Object);
}
public AsyncValidationHandlerDecorator(IAsyncRequestHandler <TRequest, TResponse> inner, IEnumerable <IValidator <TRequest> > validators)
{
_inner = inner;
_validators = validators;
}
public MediatrPipeline(IAsyncRequestHandler <TRequest, TResponse> inner)
{
_inner = inner;
}
public AsyncRequestHandlerWrapperImpl(IAsyncRequestHandler <TCommand> inner)
{
_inner = inner;
}
public AsyncLoggingHandler(IAsyncRequestHandler <TRequest, TResponse> inner)
{
_inner = inner;
}
public Decorator(IActionHandler handler, IAsyncRequestHandler <TRequest, TResponse> inner)
{
Handler = handler;
Inner = inner;
}
public AsyncAuthorizationHandler(IAsyncRequestHandler <TRequest, TResponse> inner, AppContext appContext)
{
_inner = inner;
_appContext = appContext;
}
public SqlExceptionHandler(IAsyncRequestHandler <TRequest, TResponse> inner,
IUnitOfWork dbConnectionProvider)
{
_inner = inner;
_dbConnectionProvider = dbConnectionProvider;
}
public CreateReservationHandlerTests()
{
_handler = new CreateReservationHandler(_validator.Object, _db.Object);
}
public AsyncDecoratorTwo(IAsyncRequestHandler <TRequest, TResponse> innerHandler)
{
_innerHander = innerHandler;
}
public AsyncTransactionHandlerDecorator(IAsyncRequestHandler <TRequest, TResponse> inner, SchoolContext db)
{
_inner = inner;
_db = db;
}
public void Run(IAsyncRequestHandler handler)
{
Debug.Assert(handler != null);
_handler = handler;
_fcgiApplication.Run(_port);
}
public MediatorPipeline(IAsyncRequestHandler <TRequest, TResponse> inner, ILoggedOnUser loggedOnUser)
{
_inner = inner;
_loggedOnUser = loggedOnUser;
}
public ExceptionLoggerAsync(
IAsyncRequestHandler <TRequest, TResponse> inner
)
{
_inner = inner;
}
static async Task ProcessListenerContext(HttpListenerContext context, IAsyncRequestHandler handler)
{
Debug.Assert(context != null);
Debug.Assert(handler != null);
try
{
using (var response = await handler.Execute(new RequestWrapper(context.Request)) as HttpResponse)
{
if (response != null)
{
context.Response.StatusCode = response.StatusCode;
context.Response.Headers = response.Headers;
response.WriteBody(context.Response.OutputStream);
}
}
context.Response.Close();
}
catch (HttpListenerException)
{
// Ignored.
}
catch (Exception ex)
{
// TODO: better exception handling
Trace.WriteLine(ex.ToString());
}
}
public AsyncRequestHandlerWrapper(IAsyncRequestHandler <TRequest, TResponse> innerHandler)
{
_innerHandler = innerHandler;
}
public AsyncMetricsHandlerDecorator(IAsyncRequestHandler <TRequest, TResponse> inner, ILoggerFactory loggerFactory)
{
_inner = inner;
_logger = loggerFactory.CreateLogger("Metrics");
}
