/// <summary>
/// Registers an object.
/// </summary>
/// <typeparam name="TDependency">The type of the registration object in IoC.</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public IIoCRegistrar Register <TDependency, TImplementation>(IocRegisterSettings settings) where TImplementation : TDependency
{
this.context.Register(new RegisterContext()
{
Dependency = typeof(TDependency),
Implementation = typeof(TImplementation),
Settings = settings
});
return(this);
}
/// <summary>
/// Continues the process of registration.
/// </summary>
/// <typeparam name="TObject">The type of the registration object in IoC.</typeparam>
/// <param name="registrationResult">The registration result.</param>
/// <param name="settings">The settings.</param>
private void ContinueRegistration <TObject>(object registrationResult, IocRegisterSettings settings)
{
MethodInfo asMethod = this.GetMethod(registrationResult.GetType().GetTypeInfo(), "As", new Type[] { typeof(Type[]) }, cached: false);
object asResult = asMethod.Invoke(registrationResult, new object[] { new Type[] { typeof(TObject) } });
if (settings.IsSingleton())
{
MethodInfo singletonInstanceMethod = this.GetMethod(asResult.GetType().GetTypeInfo(), "SingleInstance", new Type[0]);
singletonInstanceMethod.Invoke(asResult, new object[0]);
}
}
/// <summary>
/// Registers an object.
/// </summary>
/// <typeparam name="TDependency">The type of the registration object in IoC.</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public override IIoCRegistrar Register <TDependency, TImplementation>(IocRegisterSettings settings)
{
this.AssertNoResolver();
// Invocation of containerBuilder.RegisterType(typeof(TDependency)).As(typeof(TImplementation));
MethodInfo registerMethod = this.GetMethod(this.autofacContainerExtensionsTypeInfo, "RegisterType", this.registerParameters);
object registrationResult = registerMethod.Invoke(null, new object[]
{
this.registrar,
typeof(TImplementation)
});
this.ContinueRegistration <TDependency>(registrationResult, settings);
return(this);
}
/// <summary>
/// Registers an object.
/// </summary>
/// <typeparam name="TDependency">The type of the registration object in IoC.</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public override IIoCRegistrar Register <TDependency, TImplementation>(IocRegisterSettings settings)
{
// Invocation of kernel.Bind(typeof(TDependency)).To(typeof(TImplementation));
object[] bindArguments = new object[] { new Type[] { typeof(TDependency) } };
object bindResult = this.GetMethod(this.registrar, "Bind", bindArguments.Length).Invoke(this.registrar, bindArguments);
object[] toArguments = new object[] { typeof(TImplementation) };
object toResult = this.GetMethod(bindResult, "To", toArguments.Length).Invoke(bindResult, toArguments);
if (settings.IsSingleton())
{
this.GetMethod(toResult, "InSingletonScope", 0).Invoke(toResult, new object[0]);
}
return(this);
}
/// <summary>
/// Registers an object.
/// </summary>
/// <typeparam name="TDependency">The type of the registration object in IoC.</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public override IIoCRegistrar Register <TDependency, TImplementation>(IocRegisterSettings settings)
{
// Invocation of IUnityContainer RegisterSingleton(this IUnityContainer container, Type from, Type to, params InjectionMember[] injectionMembers);
// and IUnityContainer RegisterType(this IUnityContainer container, Type from, Type to, params InjectionMember[] injectionMembers);
MethodInfo method = settings.IsSingleton()
? this.GetMethod(this.unityContainerExtensionsTypeInfo, "RegisterSingleton", this.registerParameters, "RegisterSingletonForSimpleRegistration")
: this.GetMethod(this.unityContainerExtensionsTypeInfo, "RegisterType", this.registerParameters, "RegisterTypeForSimpleRegistration");
method.Invoke(null, new object[]
{
this.registrar,
typeof(TDependency),
typeof(TImplementation),
null
});
return(this);
}
/// <summary>
/// Registers a factory for an object.
/// </summary>
/// <typeparam name="TObject">The type of the registration object in IoC.</typeparam>
/// <param name="creationAction">The factory method.</param>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public override IIoCRegistrar Register <TObject>(Func <IIoCResolver, TObject> creationAction, IocRegisterSettings settings)
{
this.AssertNoResolver();
// Invocation of containerBuilder.Register<TObject>(Func<..., TObject>).As(typeof(TObject))
MethodInfo registerMethod = this.GetMethod(this.autofacContainerExtensionsTypeInfo, "Register", 2);
registerMethod = registerMethod.MakeGenericMethod(typeof(TObject));
object registrationResult = registerMethod.Invoke(null, new object[]
{
this.registrar,
new Func <object, TObject>(originalContainer => creationAction(this))
});
this.ContinueRegistration <TObject>(registrationResult, settings);
return(this);
}
/// <summary>
/// Registers a factory for an object.
/// </summary>
/// <typeparam name="TObject">The type of the registration object in IoC.</typeparam>
/// <param name="builder">The factory method builder.</param>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
private IIoCRegistrar InternalRegister <TObject>(ObjectFactoryMethodBuilder builder, IocRegisterSettings settings)
{
Func <IIoCResolver, object> factoryMethod = builder.Build();
this.factories[typeof(TObject)] = settings.IsSingleton()
? new SingleObjectFactory(factoryMethod)
: new ObjectFactory(factoryMethod);
return(this);
}
/// <summary>
/// Registers a factory for an object.
/// </summary>
/// <typeparam name="TObject">The type of the registration object in IoC.</typeparam>
/// <param name="creationAction">The factory method.</param>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public IIoCRegistrar Register <TObject>(Func <IIoCResolver, TObject> creationAction, IocRegisterSettings settings)
{
return(this.InternalRegister <TObject>(new ObjectFactoryMethodBuilder().FactoryMethod <TObject>(creationAction), settings));
}
/// <summary>
/// Registers an object.
/// </summary>
/// <typeparam name="TDependency">The type of the registration object in IoC.</typeparam>
/// <typeparam name="TImplementation">The type of the implementation.</typeparam>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public IIoCRegistrar Register <TDependency, TImplementation>(IocRegisterSettings settings) where TImplementation : TDependency
{
return(this.InternalRegister <TDependency>(new ObjectFactoryMethodBuilder().ImplementationType <TImplementation>(), settings));
}
/// <summary>
/// Registers a factory for an object.
/// </summary>
/// <typeparam name="TObject">The type of the registration object in IoC.</typeparam>
/// <param name="creationAction">The factory method.</param>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public override IIoCRegistrar Register <TObject>(Func <IIoCResolver, TObject> creationAction, IocRegisterSettings settings)
{
// Invocation of kernel.Bind(typeof(TDependency)).ToMethod(context => creationAction(this));
object[] bindArguments = new object[] { new Type[] { typeof(TObject) } };
object bindResult = this.GetMethod(this.registrar, "Bind", bindArguments.Length).Invoke(this.registrar, bindArguments);
object[] toMethodArguments = new object[] { new Func <object, TObject>((object originalContainer) => creationAction(this)) };
object toMethodResult = this.GetMethod(bindResult, "ToMethod", toMethodArguments.Length).Invoke(bindResult, toMethodArguments);
if (settings.IsSingleton())
{
this.GetMethod(toMethodResult, "InSingletonScope", 0).Invoke(toMethodResult, new object[0]);
}
return(this);
}
/// <summary> /// Registers a factory for an object. /// </summary> /// <typeparam name="TObject">The type of the registration object in IoC.</typeparam> /// <param name="creationAction">The factory method.</param> /// <param name="settings">The settings.</param> /// <returns>The registrar.</returns> public abstract IIoCRegistrar Register <TObject>(Func <IIoCResolver, TObject> creationAction, IocRegisterSettings settings);
/// <summary> /// Registers an object. /// </summary> /// <typeparam name="TDependency">The type of the registration object in IoC.</typeparam> /// <typeparam name="TImplementation">The type of the implementation.</typeparam> /// <param name="settings">The settings.</param> /// <returns>The registrar.</returns> public abstract IIoCRegistrar Register <TDependency, TImplementation>(IocRegisterSettings settings) where TImplementation : TDependency;
/// <summary>
/// Registers a factory for an object.
/// </summary>
/// <typeparam name="TObject">The type of the registration object in IoC.</typeparam>
/// <param name="creationAction">The factory method.</param>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public override IIoCRegistrar Register <TObject>(Func <IIoCResolver, TObject> creationAction, IocRegisterSettings settings)
{
// Invocation of IUnityContainer RegisterSingleton(this IUnityContainer container, Type t, string name, params InjectionMember[] injectionMembers);
// and IUnityContainer RegisterType(this IUnityContainer container, Type t, string name, params InjectionMember[] injectionMembers);
MethodInfo method = settings.IsSingleton()
? this.GetMethod(this.unityContainerExtensionsTypeInfo, "RegisterSingleton", this.registerFactoryParameters, "RegisterSingletonForFactoryRegistration")
: this.GetMethod(this.unityContainerExtensionsTypeInfo, "RegisterType", this.registerFactoryParameters, "RegisterTypeForFactoryRegistration");
Array array = Array.CreateInstance(this.injectionMemberType, 1);
array.SetValue(Activator.CreateInstance(this.injectionFactoryType, new object[] { new Func <object, object>(originalContainer => creationAction(this)) }), 0);
method.Invoke(null, new object[]
{
this.registrar,
typeof(TObject),
null,
array
});
return(this);
}
/// <summary>
/// Checks if the settings contains the singleton setting.
/// </summary>
/// <param name="settings">The settings to check.</param>
/// <returns><c>True</c> if the settings contains the singleton setting, otherwise <c>false</c>.</returns>
public static bool IsSingleton(this IocRegisterSettings settings)
{
return((settings & IocRegisterSettings.Singleton) != 0);
}
/// <summary>
/// Registers a factory for an object.
/// </summary>
/// <typeparam name="TObject">The type of the registration object in IoC.</typeparam>
/// <param name="creationAction">The factory method.</param>
/// <param name="settings">The settings.</param>
/// <returns>The registrar.</returns>
public IIoCRegistrar Register <TObject>(Func <IIoCResolver, TObject> creationAction, IocRegisterSettings settings)
{
this.context.RegisterFactory(new RegisterFactoryContext()
{
Type = typeof(TObject),
ObjectFactory = () => creationAction(this),
Settings = settings
});
return(this);
}
