private void InternalRegister(Type contract, string name, IComponentFactory factory,
bool performChecking)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (factory == null)
{
throw new ArgumentNullException(nameof(factory));
}
if (performChecking && !Configuration.DisableAttributeChecking)
{
ComponentContextUtils.ThrowIfNotContract(contract);
}
if (!factory.ValidateContractType(contract))
{
throw new CompositionException("This component type / factory cannot be registered with the contract " +
$"{contract.FullName}. The component type is not assignable to the contract " +
"or the factory logic prevents such registration.");
}
factory.Initialize(this);
_repository.Add(new ContractIdentity(contract, name), factory);
}
public virtual void Register(Type component)
{
if (component == null)
{
throw new ArgumentNullException();
}
Register(ComponentContextUtils.GetComponentDefaultName(component), ComponentContextUtils.CreateLocalFactory(component));
}
public virtual void Register(string name, Type componentType)
{
if (componentType == null)
{
throw new ArgumentNullException(nameof(componentType));
}
Register(name, ComponentContextUtils.CreateLocalFactory(componentType));
}
private void RegisterBuiltInComponents()
{
InternalRegister(typeof(DefaultComponentCache), null,
ComponentContextUtils.CreateLocalFactory(typeof(DefaultComponentCache)), false);
InternalRegister(typeof(ContractAgnosticComponentCache), null,
ComponentContextUtils.CreateLocalFactory(typeof(ContractAgnosticComponentCache)), false);
InternalRegister(typeof(StaticComponentCache), null,
ComponentContextUtils.CreateLocalFactory(typeof(StaticComponentCache)), false);
InternalRegister(typeof(ThreadLocalComponentCache), null,
ComponentContextUtils.CreateLocalFactory(typeof(ThreadLocalComponentCache)), false);
}
public virtual void Register(Type contract, string name, Type component)
{
if (contract == null)
{
throw new ArgumentNullException(nameof(contract));
}
if (component == null)
{
throw new ArgumentNullException(nameof(component));
}
ComponentContextUtils.ThrowIfNotSubTypeOf(contract, component);
InternalRegister(contract, name, ComponentContextUtils.CreateLocalFactory(component), true);
}
public virtual void InitializePlugs(object componentInstance, Type componentType)
{
var initializationPoints = ComponentContextUtils.ExtractInitializationPoints(this, componentType);
var initializationPointResults = new List <object>();
foreach (var initializationPoint in initializationPoints)
{
if (initializationPoint.Query == null)
{
throw new CompositionException(
$"Query is null for initialization point '{initializationPoint.Name}' on component instance of type '{componentType.FullName}'");
}
var initializationPointResult = initializationPoint.Query.Query(this);
initializationPointResults.Add(initializationPointResult);
ComponentContextUtils.ApplyInitializationPoint(componentInstance,
initializationPoint.Name,
initializationPoint.MemberType,
initializationPointResult);
}
foreach (var compositionListener in _compositionListeners.Values)
{
compositionListener.OnComponentComposed(null, initializationPoints, initializationPointResults, componentType,
componentInstance, componentInstance);
}
var compositionNotificationMethods = ComponentContextUtils.FindCompositionNotificationMethods(componentType);
if (compositionNotificationMethods != null)
{
foreach (var method in compositionNotificationMethods)
{
method(this, componentInstance);
}
}
}
public virtual void Register(Type contract, Type component)
{
Register(contract, ComponentContextUtils.GetComponentDefaultName(component), component);
}