public void UseDependencies_can_be_used_to_set_dependencies_using_an_application_owned_container()
{
var applicationsContainer = new PocketContainer()
.Register<IPaymentService>(_ => new CreditCardPaymentGateway(chargeLimit: 1));
Configuration.Current
.UseDependencies(type =>
{
if (applicationsContainer.Any(reg => reg.Key == type))
{
return () => applicationsContainer.Resolve(type);
}
return null;
});
var order = new Order(new CreateOrder(Any.FullName()))
.Apply(new AddItem
{
Price = 5m,
ProductName = Any.Word()
})
.Apply(new Ship())
.Apply(new ChargeAccount
{
AccountNumber = Any.PositiveInt().ToString()
});
order.Events()
.Last()
.Should()
.BeOfType<Order.PaymentConfirmed>();
}
private static void AddFactoryToList <T>(
PocketContainer container,
Func <PocketContainer, T> factory)
{
// avoid re-entrancy which would result in a stack overflow
if (recursionCounter.Value != 0)
{
return;
}
try
{
recursionCounter.Value++;
// register IEnumerable<Func<PocketContainer, T>>
container.TryRegister(c => c.Resolve <List <Func <PocketContainer, T> > >()
.Select(f => f(c)));
// register the registration list as a singleton
container.TryRegisterSingle(c => new List <Func <PocketContainer, T> >());
// resolve it and add the factory
var registrations = container.Resolve <List <Func <PocketContainer, T> > >();
registrations.Add(factory);
}
finally
{
recursionCounter.Value--;
}
}
internal static Func<PocketContainer, object> InMemoryEventSourcedRepositoryStrategy(Type type, PocketContainer container)
{
if (type.IsGenericType &&
(type.GetGenericTypeDefinition() == typeof (IEventSourcedRepository<>) ||
type.GetGenericTypeDefinition() == typeof (InMemoryEventSourcedRepository<>)))
{
var aggregateType = type.GenericTypeArguments.Single();
var repositoryType = typeof (InMemoryEventSourcedRepository<>).MakeGenericType(aggregateType);
var streamName = AggregateType.EventStreamName(aggregateType);
// get the single registered event stream instance
var stream = container.Resolve<ConcurrentDictionary<string, IEventStream>>()
.GetOrAdd(streamName,
name => container.Clone()
.Register(_ => name)
.Resolve<IEventStream>());
return c => Activator.CreateInstance(repositoryType, stream, c.Resolve<IEventBus>());
}
if (type == typeof(IEventStream))
{
return c => c.Resolve<InMemoryEventStream>();
}
return null;
}
public CommandSchedulerResolver(PocketContainer container)
{
if (container == null)
{
throw new ArgumentNullException(nameof(container));
}
schedulerResolversByAggregateTypeName = new Dictionary<string, Func<dynamic>>();
Command.KnownTargetTypes.ForEach(aggregateType =>
{
var schedulerType = typeof (ICommandScheduler<>).MakeGenericType(aggregateType);
schedulerResolversByAggregateTypeName.Add(
AggregateType.EventStreamName(aggregateType),
() => container.Resolve(schedulerType));
});
}
/// <summary>
/// Retrieves a service from the scope.
/// </summary>
/// <returns>
/// The retrieved service.
/// </returns>
/// <param name="serviceType">The service to be retrieved.</param>
public object GetService(Type serviceType)
{
try
{
return(container.Resolve(serviceType));
}
catch (Exception exception)
{
if (IsFrameworkType(serviceType))
{
if ((exception is TargetInvocationException &&
exception.InnerException is ArgumentException) ||
exception is ArgumentException)
{
return(null);
}
}
if (exception is TargetInvocationException)
{
throw exception.InnerException;
}
throw;
}
}
internal static ICommandSchedulerDispatcher[] InitializeSchedulersPerAggregateType(
PocketContainer container,
GetClockName getClockName,
ISubject<ICommandSchedulerActivity> subject)
{
var binders = AggregateType.KnownTypes
.Select(aggregateType =>
{
var initializerType =
typeof (SchedulerInitializer<>).MakeGenericType(aggregateType);
dynamic initializer = container.Resolve(initializerType);
return (ICommandSchedulerDispatcher) initializer.InitializeScheduler(
subject,
container,
getClockName);
})
.ToArray();
return binders;
}
