IApi IReturnApi.Return <T>(out IObjectRegistration <T> registration)
{
var reg = _provider.CreateObjectRegistration();
registration = (IObjectRegistration <T>)reg;
return(this);
}
public override void Add(IObjectRegistration registration)
{
if (MyRegistration != null)
{
throw new InvalidOperationException("Can not add items to a SingleObjectBuilderSet when there is an item already!");
}
MyRegistration = registration;
}
public override bool Remove(IObjectRegistration registration)
{
if (MyRegistration != registration)
{
return(false);
}
MyRegistration = null;
return(true);
}
public void Unregister(IObjectRegistration registration)
{
Requires.NotNull(registration, "registration");
var relation = registration.ObjectBuilder.ObjectRelation;
var rootReg = new RootRegistration()
{
ObjectRegistration = registration,
OriginalState = relation.RegistrationState
};
// Change the registration state, this is to make sure that the ObjectBuilderUnregistering event is only triggered once
_stateLock.Enter();
try
{
switch (relation.RegistrationState)
{
case RegistrationState.Unregistering:
case RegistrationState.Unregistered:
return;
default:
//case RegistrationState.Deactivating:
//case RegistrationState.Deactivated:
//case RegistrationState.Registered:
//case RegistrationState.Activating:
//case RegistrationState.Activated:
relation.RegistrationState = RegistrationState.Unregistering;
break;
}
}
finally
{
_stateLock.Exit();
}
NotifyObjectBuilderUnregistering(new ObjectUnregisteringEventArgs(registration.ObjectDescription));
var operations = new List <IOperation>();
var parents = new List <ObjectBuilder>();
_operationLock.EnterWriteLock();
try
{
RemoveRootRegistration(rootReg, ref operations);
DeactivateParentRegistrations(registration, parents.Count, ref parents, ref operations);
}
finally
{
_operationLock.ExitWriteLock();
}
// Must not trigger any events within the scope of a lock to allow the event listeners to operate
// (add/remove/get...) the service registry in the event handler. Otherwise, these operations might
// cause a dead lock problem.
PerformDeactivationOperations(operations);
}
public override IObjectRegistration CreateObjectRegistration()
{
if (_registration != null)
{
return(_registration);
}
var builder = CreateObjectBuilder();
_registration = new ObjectRegistration <T>(builder);
return(_registration);
}
public void Add(IObjectRegistration registration)
{
if (_internalSet == null)
{
_internalSet = new SingleObjectBuilderSet();
}
else if (_internalSet.Count == 1)
{
_internalSet = _internalSet.IsObserved
? new ObservedMultipleObjectBuilderSet((ObservedSingleObjectBuilderSet)_internalSet)
: new MultipleObjectBuilderSet((SingleObjectBuilderSet)_internalSet);
}
_internalSet.Add(registration);
}
void DeactivateParentRegistrations(IObjectRegistration registration, int startIndex,
ref List <ObjectBuilder> allParents, ref List <IOperation> operations)
{
#region breadth-first algorithm
DeactivateParentsAndAddListeners(registration.ObjectBuilder, ref allParents, ref operations);
if (allParents.Count == startIndex)
{
return;
}
for (int i = startIndex; i < allParents.Count; i++)
{
DeactivateParentsAndAddListeners(allParents[i], ref allParents, ref operations);
}
#endregion
}
void AddRegistration(IObjectRegistration registration, ref List <IOperation> operations)
{
var key = GetKey(registration.ObjectDescription.ContractType);
ObjectBuilderGroup group;
if (!_key2Groups.TryGetValue(key, out group))
{
group = new ObjectBuilderGroup();
_key2Groups.Add(key, group);
}
group.Add(registration);
var relation = registration.ObjectBuilder.ObjectRelation;
relation.RegistrationState = RegistrationState.Registered;
relation.ObjectBuilderGroup = group;
operations.Add(new RegistrationOperation(relation));
}
void ActivateListeners(IObjectRegistration registration, int startIndex, ref List <ObjectBuilder> listeners, ref List <IOperation> operations)
{
var current = registration.ObjectBuilder;
#region breadth-first algorithm
ActivateAndRemoveListenersFor(current, ref listeners, ref operations);
if (listeners.Count == startIndex)
{
return;
}
for (int i = startIndex; i < listeners.Count; i++)
{
ActivateAndRemoveListenersFor(listeners[i], ref listeners, ref operations);
}
#endregion
}
public void Register(IObjectRegistration registration)
{
Requires.NotNull(registration, "registration");
var operations = new List <IOperation>();
var listeners = new List <ObjectBuilder>();
_operationLock.EnterWriteLock();
try
{
AddRegistration(registration, ref operations);
ActivateListeners(registration, listeners.Count, ref listeners, ref operations);
}
finally
{
_operationLock.ExitWriteLock();
}
NotifyObjectBuilderRegistered(new ObjectRegisteredEventArgs(registration.ObjectBuilder));
PerformActivationOperations(operations);
}
public override void Add(IObjectRegistration registration)
{
var newRanking = registration.ObjectDescription.Ranking;
if (_candidates.Count == 0)
{
_candidates.Add(registration);
}
else
{
var targetPosition = 0;
for (int i = _candidates.Count - 1; i >= 0; i--)
{
var candidate = _candidates[i];
if (newRanking >= candidate.ObjectDescription.Ranking)
{
targetPosition = i;
break;
}
}
_candidates.Insert(targetPosition + 1, registration);
}
}
public static object Resolve(this IObjectResolver resolver, IObjectRegistration registration, params PositionalParameter[] overridenParameters)
{
return(resolver.Resolve(registration.ObjectBuilder, new PositionalParameterSet(overridenParameters)));
}
public static Exception TryResolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, out T instance, IList <PositionalParameter> overridenParameters)
{
return(TryResolveWithObjectRegistration(resolver, registration, new PositionalParameterSet(overridenParameters), out instance));
}
IApi IReturnApi.Return(out IObjectRegistration registration)
{
registration = _provider.CreateObjectRegistration();
return(this);
}
public static object Resolve(this IObjectResolver resolver, IObjectRegistration registration, IEnumerable <PositionalParameter> overridenParameters)
{
return(resolver.Resolve(registration.ObjectBuilder, new PositionalParameterSet(overridenParameters.ToList())));
}
static Exception TryResolveWithObjectRegistration <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, ParameterSet parameters, out T instance)
{
try
{
instance = resolver.Resolve(registration.ObjectBuilder, parameters);
return(null);
}
catch (Exception ex)
{
instance = default(T);
return(ex);
}
}
/// <summary>
/// Unregisters a service from the container using the <see cref="IObjectRegistration"/> associated with it,
/// so that it can't be used to serve the later requests. The service will be unregistered anyway, whether
/// it is depended on by any other components or not.
/// But if there are components that depends on it, then the dependencies of those components will be updated
/// to allow them to rebind to other components at the next time they are requested.
/// </summary>
/// <param name="registrar">The registrar.</param>
/// <param name="registration">The registration.</param>
/// <returns></returns>
public static void Unregister(this IObjectRegistrar registrar, IObjectRegistration registration)
{
Requires.NotNull(registrar, "registrar");
registrar.Kernel.Unregister(registration);
}
public static Exception TryResolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, out T instance, params NamedParameter[] overridenParameters)
{
return(TryResolveWithObjectRegistration(resolver, registration, new NamedParameterSet(overridenParameters), out instance));
}
public static Exception TryResolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, out T instance, IEnumerable <NamedParameter> overridenParameters)
{
return(TryResolveWithObjectRegistration(resolver, registration, new NamedParameterSet(overridenParameters.ToList()), out instance));
}
public static T Resolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration)
{
return(resolver.Resolve(registration.ObjectBuilder, null));
}
public static Exception TryResolve(this IObjectResolver resolver, IObjectRegistration registration, out object instance, IList <NamedParameter> overridenParameters)
{
return(TryResolveWithObjectRegistration(resolver, registration, new NamedParameterSet(overridenParameters), out instance));
}
public static T Resolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, IList <PositionalParameter> overridenParameters)
{
return(resolver.Resolve(registration.ObjectBuilder, new PositionalParameterSet(overridenParameters)));
}
public static object Resolve(this IObjectResolver resolver, IObjectRegistration registration, IList <NamedParameter> overridenParameters)
{
return(resolver.Resolve(registration.ObjectBuilder, new NamedParameterSet(overridenParameters)));
}
public static Exception TryResolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, out T instance)
{
return(TryResolveWithObjectRegistration(resolver, registration, null, out instance));
}
public static T Resolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, IEnumerable <NamedParameter> overridenParameters)
{
return(resolver.Resolve(registration.ObjectBuilder, new NamedParameterSet(overridenParameters.ToList())));
}
public static T Resolve <T>(this IObjectResolver resolver, IObjectRegistration <T> registration, params NamedParameter[] overridenParameters)
{
return(resolver.Resolve(registration.ObjectBuilder, new NamedParameterSet(overridenParameters)));
}
public static Exception TryResolve(this IObjectResolver resolver, IObjectRegistration registration, out object instance, params PositionalParameter[] overridenParameters)
{
return(TryResolveWithObjectRegistration(resolver, registration, new PositionalParameterSet(overridenParameters), out instance));
}
public bool Remove(IObjectRegistration registration)
{
return(_internalSet.Remove(registration));
}
public DummyClass(IObjectRegistration p1, ContainerOption p2, ILifetimeScope p3)
{
}
public static Exception TryResolve(this IObjectResolver resolver, IObjectRegistration registration, out object instance, IEnumerable <PositionalParameter> overridenParameters)
{
return(TryResolveWithObjectRegistration(resolver, registration, new PositionalParameterSet(overridenParameters.ToList()), out instance));
}
