private static ButterflyParser LoadStrategiesFromTypes(this ButterflyParser parser, IParseStrategyFactory strategyFactory, IEnumerable<Type> types)
{
var strategyInterface = typeof(ParseStrategy);
types = types.Where(type => type.IsClass && !type.IsAbstract && strategyInterface.IsAssignableFrom(type));
types.Walk(type => parser.AddStrategy(strategyFactory.Create(type)));
return parser;
}
public static PocketContainer IncludeDependencyResolver(
this PocketContainer container,
IDependencyResolver dependencyResolver)
{
return container.AddStrategy(type =>
{
if (dependencyResolver.GetService(type) != null)
{
return c => dependencyResolver.GetService(type);
}
return null;
});
}
/// <summary>
/// Uses Its.Configuration to resolve unregistered types whose name ends with "Settings".
/// </summary>
/// <param name="container">The container.</param>
/// <returns>The same container instance.</returns>
public static PocketContainer UseItsConfigurationForSettings(
this PocketContainer container)
{
return container.AddStrategy(type =>
{
if (!type.IsInterface &&
!type.IsAbstract &&
!type.IsGenericTypeDefinition &&
type.Name.EndsWith("Settings"))
{
return c => Settings.Get(type);
}
return null;
});
}
public static PocketContainer UseImmediateCommandScheduling(this PocketContainer container)
{
return container.AddStrategy(type =>
{
if (type.IsInterface &&
type.IsGenericType &&
type.GetGenericTypeDefinition() == typeof (ICommandScheduler<>))
{
var targetType = type.GetGenericArguments().First();
var schedulerType = typeof (CommandScheduler<>).MakeGenericType(targetType);
return c => c.Resolve(schedulerType);
}
return null;
});
}
public static PocketContainer AutoMockInterfacesAndAbstractClasses(
this PocketContainer container)
{
return container.AddStrategy(type =>
{
if (type.IsInterface || type.IsAbstract)
{
var moqType = typeof (Mock<>).MakeGenericType(type);
return c =>
{
var mock = Activator.CreateInstance(moqType) as Mock;
mock.DefaultValue = DefaultValue.Mock;
return ((dynamic) mock).Object;
};
}
return null;
});
}
public static PocketContainer IfOnlyOneImplementationUseIt(
this PocketContainer container)
{
return container.AddStrategy(type =>
{
if (type.IsInterface || type.IsAbstract)
{
var implementations = Discover.ConcreteTypesDerivedFrom(type)
.ToArray();
if (implementations.Count() == 1)
{
var implementation = implementations.Single();
return c => c.Resolve(implementation);
}
}
return null;
});
}
public static PocketContainer AddStoreStrategy(this PocketContainer container)
{
return container.AddStrategy(type =>
{
if (type.IsInterface &&
type.IsGenericType &&
type.GetGenericTypeDefinition() == typeof (IStore<>))
{
var targetType = type.GetGenericArguments().First();
Type applierType;
if (typeof (IEventSourced).IsAssignableFrom(targetType))
{
applierType = typeof (IEventSourcedRepository<>).MakeGenericType(targetType);
return c => c.Resolve(applierType);
}
}
return null;
});
}
/// <summary>
/// Registers an open generic type to another open generic type, allowing, for example, IService&T& to be registered to resolve to Service&T&.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="variantsOf">The open generic interface that callers will attempt to resolve, e.g. typeof(IService&T&).</param>
/// <param name="to">The open generic type to resolve, e.g. typeof(Service&T&).</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">
/// Parameter 'variantsOf' is not an open generic type, e.g. typeof(IService&T&)
/// or
/// Parameter 'to' is not an open generic type, e.g. typeof(Service&T&)
/// </exception>
public static PocketContainer RegisterGeneric(this PocketContainer container, Type variantsOf, Type to)
{
if (!variantsOf.IsGenericTypeDefinition)
{
throw new ArgumentException("Parameter 'variantsOf' is not an open generic type, e.g. typeof(IService<>)");
}
if (!to.IsGenericTypeDefinition)
{
throw new ArgumentException("Parameter 'to' is not an open generic type, e.g. typeof(Service<>)");
}
return container.AddStrategy(t =>
{
if (t.IsGenericType && t.GetGenericTypeDefinition() == variantsOf)
{
var closedGenericType = to.MakeGenericType(t.GetGenericArguments());
return c => c.Resolve(closedGenericType);
}
return null;
});
}
internal static PocketContainer RegisterDefaultClockName(this PocketContainer container) =>
container.AddStrategy(t =>
{
if (t == typeof (GetClockName))
{
return c => new GetClockName(e => CommandScheduler.Clock.DefaultClockName);
}
return null;
});
internal static PocketContainer AddFallbackToDefaultClock(this PocketContainer container)
{
return container.AddStrategy(t =>
{
if (t == typeof (GetClockName))
{
return c => new GetClockName(e => CommandScheduler.SqlCommandScheduler.DefaultClockName);
}
return null;
});
}
