/// <summary>
/// Registers a context with the current thread - always put a matching
/// <see cref="Close"/> call in a finally block to ensure that the correct
/// context is available in the enclosing block.
/// </summary>
/// <param name="stepExecution">the step context to register</param>
/// <returns>a new StepContext or the current one if it has the same StepExecution</returns>
public static StepContext Register(StepExecution stepExecution)
{
var context = Manager.Register(stepExecution);
StepScopeSynchronization.ResetInstances();
return(context);
}
/// <summary>
/// Resolves the dependency by crating a proxy and registers it with <see cref="StepScopeSynchronization"/>.
/// </summary>
/// <param name="context">Current build context</param>
/// <returns>The created proxy</returns>
public object Resolve(IBuilderContext context)
{
var mappedType = StepScopeSynchronization.GetMappedType(_dependency.RegisteredType, _dependency.Name);
var proxy = ProxyFactory.Create(mappedType.GetInterfaces(), typeof(StepScopeProxyObject));
StepScopeSynchronization.AddProxy(_dependency.RegisteredType, _dependency.Name, (IProxyObject)proxy);
return(proxy);
}
private static void ResolveProperties(IBuilderContext context, IPropertySelectorPolicy propertySelector,
IPolicyList resolverPolicyDestination, Dictionary <string, StepScopeDependency> properties)
{
foreach (var property in propertySelector.SelectProperties(context, resolverPolicyDestination))
{
var namedTypeResolver = property.Resolver as NamedTypeDependencyResolverPolicy;
if (namedTypeResolver != null)
{
var type = namedTypeResolver.Type;
var name = namedTypeResolver.Name;
if (StepScopeSynchronization.IsStepScope(type, name))
{
properties[property.Property.Name] = new StepScopeDependency(type, name);
}
}
}
}
private void CheckStepScope(object sender, RegisterEventArgs args)
{
var isStepScope = args.LifetimeManager is StepScopeLifetimeManager;
// First we need to check any registered dependency with the same registered type and name
Container.Registrations.Where(r => r.RegisteredType != (args.TypeFrom ?? args.TypeTo) &&
r.MappedToType == args.TypeTo && r.Name == args.Name).ForEach(r =>
{
if (StepScopeSynchronization.IsStepScope(r.MappedToType, r.Name))
{
// if the previously registered dependency is in step scope, a newly defined
// liftetime manager takes precedence. If no lifetime manager is defined for
// the new dependency, it is in step scope.
if (args.LifetimeManager == null)
{
isStepScope = true;
}
if (!isStepScope)
{
StepScopeSynchronization.RemoveScopeDependency(r.RegisteredType, r.Name);
StepScopeSynchronization.RemoveScopeDependency(r.MappedToType, r.Name);
}
}
else if (isStepScope)
{
// if the previously registered dependency is not in step scope but the new dependency
// is, the previously registered dependency is put in step scope.
if (r.RegisteredType != r.MappedToType)
{
StepScopeSynchronization.AddStepScopeDependency(r.RegisteredType, r.Name, Container, r.MappedToType);
}
StepScopeSynchronization.AddStepScopeDependency(r.MappedToType, r.Name, Container, r.MappedToType);
}
});
// Finally, we register the new dependency in the step scope if required
if (isStepScope)
{
if (args.TypeFrom != null)
{
StepScopeSynchronization.AddStepScopeDependency(args.TypeFrom, args.Name, Container, args.TypeTo);
}
StepScopeSynchronization.AddStepScopeDependency(args.TypeTo, args.Name, Container, args.TypeTo);
}
}
private static void ResolveConstructorParameters(SelectedConstructor constructor, Dictionary <string, StepScopeDependency> constructorParameters)
{
var parameterResolvers = constructor.GetParameterResolvers();
for (var i = 0; i < parameterResolvers.Length; i++)
{
var namedTypeResolver = parameterResolvers[i] as NamedTypeDependencyResolverPolicy;
if (namedTypeResolver != null)
{
var type = namedTypeResolver.Type;
var name = namedTypeResolver.Name;
if (StepScopeSynchronization.IsStepScope(type, name))
{
var parameter = constructor.Constructor.GetParameters()[i];
constructorParameters[parameter.Name] = new StepScopeDependency(type, name);
}
}
}
}
private static void ResolveMethodParameters(IBuilderContext context, IMethodSelectorPolicy methodSelector,
IPolicyList resolverPolicyDestination, Dictionary <Tuple <string, string>, IList <StepScopeDependency> > methodParameters)
{
foreach (var method in methodSelector.SelectMethods(context, resolverPolicyDestination))
{
var parameterResolvers = method.GetParameterResolvers();
for (var i = 0; i < parameterResolvers.Length; i++)
{
var namedTypeResolver = parameterResolvers[i] as NamedTypeDependencyResolverPolicy;
if (namedTypeResolver != null)
{
var type = namedTypeResolver.Type;
var name = namedTypeResolver.Name;
if (StepScopeSynchronization.IsStepScope(type, name))
{
var parameter = method.Method.GetParameters()[i];
var key = new Tuple <string, string>(GetSignature(method.Method), parameter.Name);
AddMethodParameterDependency(methodParameters, key,
new StepScopeDependency(type, name));
}
}
}
}
}
/// <summary>
/// A convenient "deep" close operation. Call this instead of
/// <see cref="Close"/> if the step execution for the current context is ending.
/// Delegates to StepContext<see cref="Close"/> and then ensures that
/// <see cref="Close"/> is also called in a finally block.
/// </summary>
public static void Release()
{
Manager.Release();
StepScopeSynchronization.ResetInstances();
}
