public IBindingScope ToFactory(IInjectionFactory factory)
{
var binding = new Binding(ContractType, BaseTypes, factory);
Container.Binder.Bind(binding);
return new BindingScope(binding);
}
public AvalancheRunnerTests()
{
_logger = Substitute.For <ILogger <AvalancheRunner> >();
_glacier = Substitute.For <IGlacierGateway>();
_lightroom = Substitute.For <ILightroomReader>();
_avalanche = Substitute.For <IAvalancheRepository>();
_parameters = new ExecutionParameters
{
Glacier = new GlacierParameters
{
},
Avalanche = new AvalancheParameters
{
}
};
_glacierFactory = Substitute.For <IInjectionFactory <IGlacierGateway> >();
_glacierFactory.Create().Returns(_glacier);
_lightroomFactory = Substitute.For <IInjectionFactory <ILightroomReader> >();
_lightroomFactory.Create().Returns(_lightroom);
_lightroom.GetCatalogId().Returns(Guid.NewGuid());
_avalancheFactory = Substitute.For <IInjectionFactory <IAvalancheRepository> >();
_avalancheFactory.Create().Returns(_avalanche);
_sut = new AvalancheRunner(_logger, _glacierFactory, _lightroomFactory, _avalancheFactory, _parameters);
}
public Binding(Type contractType, Type[] baseTypes, IInjectionFactory factory, IInjectionScope scope = null, Predicate<InjectionContext> condition = null)
{
ContractType = contractType;
BaseTypes = baseTypes;
Factory = factory;
Scope = scope;
Condition = condition;
}
public Binding(Type contractType, Type[] baseTypes, IInjectionFactory factory, IInjectionScope scope = null, Predicate <InjectionContext> condition = null)
{
ContractType = contractType;
BaseTypes = baseTypes;
Factory = factory;
Scope = scope;
Condition = condition;
}
public IBindingScope ToFactory(IInjectionFactory factory)
{
var binding = new Binding(ContractType, BaseTypes, factory);
Container.Binder.Bind(binding);
return(new BindingScope(binding));
}
public void Add(Type interfaceKey, string identity, IInjectionFactory factory)
{
if (!_typeFactories.ContainsKey(interfaceKey))
{
_typeFactories.Add(interfaceKey, new Dictionary <string, IInjectionFactory>());
}
_typeFactories[interfaceKey].Add(identity, factory);
}
public object GetInstance(IInjectionFactory factory, InjectionContext context)
{
if (!created)
{
instance = factory.Create(context);
created = true;
}
return instance;
}
public object GetInstance(IInjectionFactory factory, InjectionContext context)
{
if (!created)
{
instance = factory.Create(context);
created = true;
}
return(instance);
}
public AvalancheRunner(ILogger <AvalancheRunner> logger,
IInjectionFactory <IGlacierGateway> glacierFactory,
IInjectionFactory <ILightroomReader> lightroomFactory,
IInjectionFactory <IAvalancheRepository> avalancheFactory,
ExecutionParameters parameters)
{
_logger = logger;
_glacierFactory = glacierFactory;
_lightroomFactory = lightroomFactory;
_avalancheFactory = avalancheFactory;
_parameters = parameters;
}
public TClass Resolve <TClass>()
{
if (!_factories.ContainsKey(typeof(TClass)))
{
return(_container.Resolve <TClass>());
}
IInjectionFactory <TClass> factory = _factories[typeof(TClass)] as IInjectionFactory <TClass>;
if (factory == null)
{
throw new ArgumentException("TClass : factory = null");
}
TClass result = factory.Create(this);
if (factory.IsSingleFactory)
{
_factories.Remove(typeof(TClass));
RegisterInstance <TClass>(result);
}
return(result);
}
public object GetInstance(IInjectionFactory factory, InjectionContext context)
{
return factory.Create(context);
}
public static InjectionFactoryObjectWrapper <T> CreateWrapper <T>(this IInjectionFactory <T> factory)
{
var item = factory.Create();
return(new InjectionFactoryObjectWrapper <T>(item, factory));
}
public InjectionFactoryObjectWrapper(T item, IInjectionFactory <T> factory)
{
Item = item;
_factory = factory;
}
public DeepCloneInjection(IInjectionFactory injectionFactory)
{
_injectionFactory = injectionFactory;
}
public Binding(Type contractType, IInjectionFactory factory, IInjectionScope scope = null, Predicate <InjectionContext> condition = null)
: this(contractType, Type.EmptyTypes, factory, scope, condition)
{
}
public Binding(Type contractType, IInjectionFactory factory, IInjectionScope scope = null, Predicate<InjectionContext> condition = null)
: this(contractType, Type.EmptyTypes, factory, scope, condition)
{
}
public object GetInstance(IInjectionFactory factory, InjectionContext context)
{
return(factory.Create(context));
}
public DomainService(IInjectionFactory <IDataService> dataServiceFactory)
{
_dataServiceFactory = dataServiceFactory;
}
