public static ITypeFactory GetAutoWiredFunqTypeFactory()
{
var container = GetContainerWithDependencies();
var typeFactory = new AutoWireContainer(container);
typeFactory.RegisterTypes(typeof(StoreCustomersService), typeof(GetCustomerService));
return typeFactory;
}
public void With_Funq_and_Expressions()
{
var container = new Container();
container.Register<IFoo>(c => new Foo());
container.Register<IBar>(c => new Bar());
var funqlet = new AutoWireContainer(container);
funqlet.RegisterTypes(typeof(AutoWireService));
Console.WriteLine("With_Funq_and_Expressions(): {0}", Measure(() => container.Resolve<AutoWireService>(), Times));
}
/// <summary>
/// Auto-scans the provided assemblies for a <see cref="IValidator"/>
/// and registers it in the provided IoC container.
/// </summary>
/// <param name="container">The IoC container</param>
/// <param name="assemblies">The assemblies to scan for a validator</param>
public static void RegisterValidators(this Container container, params Assembly[] assemblies)
{
var autoWire = new AutoWireContainer(container);
foreach (var assembly in assemblies)
{
foreach (var validator in assembly.GetTypes()
.Where(t => t.IsOrHasGenericInterfaceTypeOf(typeof(IValidator<>))))
{
RegisterValidator(autoWire, validator);
}
}
}
private static void RegisterValidator(AutoWireContainer autoWire, Type validator)
{
var baseType = validator.BaseType;
while (!baseType.IsGenericType)
{
baseType = baseType.BaseType;
}
var dtoType = baseType.GetGenericArguments()[0];
var validatorType = typeof (IValidator<>).MakeGenericType(dtoType);
autoWire.RegisterType(validator, validatorType);
}
public FunqControllerFactory(Container container)
{
this.funqBuilder = new AutoWireContainer(container) {
Scope = ReuseScope.None //don't re-use instances
};
// Also register all the controller types as transient
var controllerTypes =
(from type in Assembly.GetCallingAssembly().GetTypes()
where typeof(IController).IsAssignableFrom(type)
select type).ToList();
funqBuilder.RegisterTypes(controllerTypes);
}
public void Can_AutoWire_types_dynamically_with_expressions()
{
var serviceType = typeof(AutoWireService);
var container = new Container();
container.Register<IFoo>(c => new Foo());
container.Register<IBar>(c => new Bar());
var typeContainer = new AutoWireContainer(container);
typeContainer.RegisterTypes(serviceType);
var service = container.Resolve<AutoWireService>();
Assert.That(service.Foo, Is.Not.Null);
Assert.That(service.Bar, Is.Not.Null);
}
public FunqValidatorFactory(Container container=null)
{
this.funqBuilder = new AutoWireContainer(container ?? AppHostBase.Instance.Container) {
Scope = ReuseScope.None //don't re-use instances
};
}
