public void Release(IHandleRequests handler)
{
var disposable = handler as IDisposable;
disposable?.Dispose();
s_released += "|" + handler.Name;
}
public void Add(IHandleRequests instance)
{
if (_handlerFactory == null)
throw new ArgumentException("An instance of a handler can not be added without a HandlerFactory.");
_trackedObjects.Add(instance);
_logger.Value.DebugFormat("Tracking instance {0} of type {1}", instance.GetHashCode(), instance.GetType());
}
/// <summary>
/// Releases the specified handler.
/// </summary>
/// <param name="handler">The handler.</param>
public void Release(IHandleRequests handler)
{
var disposable = handler as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
public void Release(IHandleRequests handler)
{
var disposable = handler as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
handler = null;
}
private void AppendToChain(IEnumerable <RequestHandlerAttribute> attributes, IHandleRequests <TRequest> implicitHandler, IRequestContext requestContext)
{
IHandleRequests <TRequest> lastInChain = implicitHandler;
foreach (var attribute in attributes)
{
var decorator = new HandlerFactory <TRequest>(attribute, container, requestContext).CreateRequestHandler();
lastInChain.Successor = decorator;
lastInChain = decorator;
}
}
void AppendToPipeline(IEnumerable <RequestHandlerAttribute> attributes, IHandleRequests <TRequest> implicitHandler, IRequestContext requestContext)
{
var lastInPipeline = implicitHandler;
attributes.Each((attribute) =>
{
var decorator = new HandlerFactory <TRequest>(attribute, handlerFactory, requestContext).CreateRequestHandler();
lastInPipeline.Successor = decorator;
lastInPipeline = decorator;
});
}
public void Release(IHandleRequests handler)
{
var disposable = handler as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
s_released += "|" + handler.Name;
}
/// <summary>
/// Release the request handler - actual behavior depends on lifetime, we only dispose if we are transient
/// </summary>
/// <param name="handler"></param>
public void Release(IHandleRequests handler)
{
if (!_isTransient)
{
return;
}
var disposal = handler as IDisposable;
disposal?.Dispose();
}
public void Add(IHandleRequests instance)
{
if (_handlerFactory == null)
{
throw new ArgumentException("An instance of a handler can not be added without a HandlerFactory.");
}
_trackedObjects.Add(instance);
if (_logger != null)
{
_logger.DebugFormat("Tracking instance {0} of type {1}", instance.GetHashCode(), instance.GetType());
}
}
public void Setup()
{
var logger = new Mock <ILog>().Object;
var registry = new SubscriberRegistry();
registry.Register <TestCommand, TestCommandHandler>();
var handlerFactory = new TestHandlerFactory <TestCommand, TestCommandHandler>(() => new TestCommandHandler(logger));
pipelineBuilder = new PipelineBuilder <TestCommand>(registry, handlerFactory, logger);
pipeline = pipelineBuilder.Build(new RequestContext()).First();
}
public IHandleRequests Create(Type handlerType)
{
IServiceScope scope = _serviceProvider.CreateScope();
IServiceProvider scopedProvider = scope.ServiceProvider;
IHandleRequests result = (IHandleRequests)scopedProvider.GetService(handlerType);
if (_activeHandlers.TryAdd(result, scope))
{
return(result);
}
scope.Dispose();
throw new InvalidOperationException("The handler could not be tracked properly. It may be declared in the service collection with the wrong lifecyle.");
}
public void Setup()
{
var logger = new Mock <ILog>().Object;
var registry = new SubscriberRegistry();
registry.Register <TestCommand, TestImplicitHandler>();
var container = new TinyIoCContainer();
var handlerFactory = new TinyIoCHandlerFactory(container);
container.Register <IHandleRequests <TestCommand>, TestImplicitHandler>();
container.Register <IHandleRequests <TestCommand>, TestLoggingHandler <TestCommand> >();
container.Register(logger);
pipelineBuilder = new PipelineBuilder <TestCommand>(registry, handlerFactory, logger);
pipeline = pipelineBuilder.Build(new RequestContext()).First();
}
private void AppendToPipeline(IEnumerable <RequestHandlerAttribute> attributes, IHandleRequests <TRequest> implicitHandler, IRequestContext requestContext)
{
IHandleRequests <TRequest> lastInPipeline = implicitHandler;
attributes.Each(attribute =>
{
var handlerType = attribute.GetHandlerType();
if (handlerType.GetTypeInfo().GetInterfaces().Contains(typeof(IHandleRequests)))
{
var decorator =
new HandlerFactory <TRequest>(attribute, _handlerFactory, requestContext).CreateRequestHandler();
lastInPipeline.SetSuccessor(decorator);
lastInPipeline = decorator;
}
else
{
var message = string.Format("All handlers in a pipeline must derive from IHandleRequests. You cannot have a mixed pipeline by including handler {0}", handlerType.Name);
throw new ConfigurationException(message);
}
});
}
public void When_Building_A_Pipeline_Preserve_The_Order()
{
_pipeline = _pipelineBuilder.Build(new RequestContext()).First();
PipelineTracer().ToString().Should().Be("MyLoggingHandler`1|MyValidationHandler`1|MyDoubleDecoratedHandler|");
}
public void Release(IHandleRequests handler)
{
var disposable = handler as IDisposable;
disposable?.Dispose();
}
public void Add(IHandleRequests instance)
{
_trackedObjects.Add(instance);
if (_logger != null)
_logger.DebugFormat("Tracking instance {0} of type {1}", instance.GetHashCode(), instance.GetType());
}
public void Add(IHandleRequests <TRequest> handler)
{
chains.Add(handler);
}
public void Release(IHandleRequests handler)
{
// nothing to do
}
/// <summary>
/// Sets the successor.
/// </summary>
/// <param name="successor">The successor.</param>
public void SetSuccessor(IHandleRequests <TRequest> successor)
{
_successor = successor;
}
public void Release(IHandleRequests handler) {}
public void When_Building_A_Pipeline_Allow_Pre_And_Post_Tasks()
{
_pipeline = _pipelineBuilder.Build(new RequestContext()).First();
TraceFilters().ToString().Should().Be("MyValidationHandler`1|MyPreAndPostDecoratedHandler|MyLoggingHandler`1|");
}
public void Release(IHandleRequests handler)
{
var disposable = handler as IDisposable;
disposable?.Dispose();
}
public CommentsController(IHandleRequests handler, IMongoStore mongo)
{
_handler = handler;
_mongo = mongo;
}
IHandleRequests <TRequest> PushOntoPipeline(IEnumerable <RequestHandlerAttribute> attributes, IHandleRequests <TRequest> lastInPipeline, IRequestContext requestContext)
{
attributes.Each((attribute) =>
{
var decorator = new HandlerFactory <TRequest>(attribute, handlerFactory, requestContext).CreateRequestHandler();
decorator.Successor = lastInPipeline;
lastInPipeline = decorator;
});
return(lastInPipeline);
}
private IHandleRequests <TRequest> PushOntoChain(IEnumerable <RequestHandlerAttribute> attributes, IHandleRequests <TRequest> lastInChain, IRequestContext requestContext)
{
foreach (var attribute in attributes)
{
var decorator = new HandlerFactory <TRequest>(attribute, container, requestContext).CreateRequestHandler();
decorator.Successor = lastInChain;
lastInChain = decorator;
}
return(lastInChain);
}
public void Release(IHandleRequests handler)
{
}
public PostRequestDecorator(IHandleRequests <TRequest, TResponse> inner) : base(inner)
{
}
public void Add(IHandleRequests <TRequest> handler)
{
filters.Add(handler);
}
public MaternityBenefitsBulkRequestHandler(
IHandleRequests <MaternityBenefitsRequest, MaternityBenefitsResponse> requestHandler
)
{
_requestHandler = requestHandler;
}
public void When_Building_A_Pipeline_Allow_ForeignAttributes()
{
_pipeline = _pipelineBuilder.Build(new RequestContext()).First();
TraceFilters().ToString().Should().Be("MyValidationHandler`1|MyObsoleteCommandHandler|MyLoggingHandler`1|");
}
public void When_Building_A_Pipeline_Allow_ForiegnAttribues()
{
_pipeline = _pipelineBuilder.Build(new RequestContext()).First();
Assert.AreEqual("MyValidationHandler`1|MyObsoleteCommandHandler|MyLoggingHandler`1|", TraceFilters().ToString());
}