private T GetStrategyFromCollection <T>(IActivationStrategyCollection <T> strategyCollection, IInjectionScope scope, ActivationStrategyFilter consider, Type locateType, IInjectionContext injectionContext) where T : IActivationStrategy
{
foreach (var strategy in strategyCollection.GetStrategies())
{
if (strategy.HasConditions)
{
var pass = true;
foreach (var condition in strategy.Conditions)
{
if (!condition.MeetsCondition(strategy, new StaticInjectionContext(locateType)))
{
pass = false;
break;
}
}
if (!pass)
{
continue;
}
}
if (consider != null && !consider(strategy))
{
continue;
}
return(strategy);
}
return(default(T));
}
/// <summary>
/// Select the best strategy from collection to satisfy request
/// </summary>
/// <param name="collection"></param>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult SelectStrategyFromCollection(IActivationStrategyCollection <ICompiledExportStrategy> collection, IInjectionScope scope, IActivationExpressionRequest request)
{
var filter = request.Filter;
IActivationExpressionResult result = null;
foreach (var strategy in collection.GetStrategies())
{
if (filter != null && !filter(strategy))
{
continue;
}
if (strategy.HasConditions)
{
var context = request.GetStaticInjectionContext();
if (!strategy.Conditions.All(condition => condition.MeetsCondition(strategy, context)))
{
continue;
}
}
result = strategy.GetActivationExpression(scope, request);
if (result != null)
{
break;
}
}
return(result);
}
private void LocateEnumerablesFromStrategyCollection <TStrategy, TValue>(IActivationStrategyCollection <TStrategy> collection, IExportLocatorScope scope, IDisposalScope disposalScope, Type type, IInjectionContext context, ActivationStrategyFilter filter, List <TValue> returnList) where TStrategy : IWrapperOrExportActivationStrategy
{
foreach (var strategy in collection.GetStrategies())
{
ProcessStrategyForCollection(scope, disposalScope, type, context, filter, returnList, strategy);
}
if (InternalFieldStorage.ScopeConfiguration.ReturnKeyedInEnumerable)
{
foreach (var keyValuePair in collection.GetKeyedStrategies())
{
ProcessStrategyForCollection(scope, disposalScope, type, context, filter, returnList, keyValuePair.Value);
}
}
}
private ActivationStrategyDelegate GetStrategyFromCollection <T>(IActivationStrategyCollection <T> strategyCollection, IInjectionScope scope, ActivationStrategyFilter consider, Type locateType, IInjectionContext injectionContext) where T : IWrapperOrExportActivationStrategy
{
foreach (var strategy in strategyCollection.GetStrategies())
{
if (strategy.HasConditions)
{
var pass = true;
foreach (var condition in strategy.Conditions)
{
if (!condition.MeetsCondition(strategy, new StaticInjectionContext(locateType)))
{
pass = false;
break;
}
}
if (!pass)
{
continue;
}
}
if (consider != null && !consider(strategy))
{
continue;
}
var strategyDelegate = strategy.GetActivationStrategyDelegate(scope, this, locateType);
if (strategyDelegate != null)
{
return(strategyDelegate);
}
}
return(null);
}
private void LocateEnumerablesFromStrategyCollection <TStrategy, TValue>(IActivationStrategyCollection <TStrategy> collection, IExportLocatorScope scope, IDisposalScope disposalScope, Type type, IInjectionContext context, ActivationStrategyFilter filter, List <TValue> returnList) where TStrategy : IWrapperOrExportActivationStrategy
{
foreach (var strategy in collection.GetStrategies())
{
if (strategy.HasConditions)
{
var pass = true;
foreach (var condition in strategy.Conditions)
{
if (!condition.MeetsCondition(strategy, new StaticInjectionContext(type)))
{
pass = false;
break;
}
}
if (!pass)
{
continue;
}
}
if (filter != null && !filter(strategy))
{
continue;
}
var activationDelegate = strategy.GetActivationStrategyDelegate(this, InternalFieldStorage.ActivationStrategyCompiler, type);
if (activationDelegate != null)
{
returnList.Add(
(TValue)activationDelegate(scope, disposalScope, context?.Clone()));
}
}
}
public void CanLocateTypeService_CanLocate_Wrapper_Generic(CanLocateTypeService service, IInjectionScope scope, IActivationStrategyCollection <ICompiledWrapperStrategy> collection)
{
scope.WrapperCollectionContainer.
GetActivationStrategyCollection(typeof(Func <>)).Returns(collection);
Assert.True(service.CanLocate(scope, typeof(Func <IBasicService>), null));
}
public void CanLocateTypeService_CanLocate_Strategy_Generic(CanLocateTypeService service, IInjectionScope scope, IActivationStrategyCollection <ICompiledExportStrategy> collection)
{
scope.StrategyCollectionContainer.
GetActivationStrategyCollection(typeof(DependentService <>)).Returns(collection);
Assert.True(service.CanLocate(scope, typeof(DependentService <IBasicService>), null));
}
/// <summary>
/// Get expression from an activation strategy collection
/// </summary>
/// <param name="scope"></param>
/// <param name="arrayElementType"></param>
/// <param name="request"></param>
/// <param name="expressions"></param>
/// <param name="collection"></param>
/// <param name="wrappedType"></param>
/// <param name="wrappers"></param>
public static void GetExpressionFromCollection(IInjectionScope scope, Type arrayElementType,
IActivationExpressionRequest request, List <IActivationExpressionResult> expressions, IActivationStrategyCollection <ICompiledExportStrategy> collection, Type wrappedType,
ImmutableLinkedList <IActivationPathNode> wrappers)
{
foreach (var strategy in collection.GetStrategies())
{
if (strategy.HasConditions)
{
var staticContext = request.GetStaticInjectionContext();
var pass = true;
foreach (var condition in strategy.Conditions)
{
if (!condition.MeetsCondition(strategy, staticContext))
{
pass = false;
break;
}
}
if (!pass)
{
continue;
}
}
var newRequest = request.NewRequest(arrayElementType, request.RequestingStrategy, request.RequestingStrategy?.ActivationType,
RequestType.Other, null, true);
var newPath =
ImmutableLinkedList <IActivationPathNode> .Empty.Add(
new WrapperActivationPathNode(strategy,
wrappedType, null)).AddRange(wrappers);
newRequest.SetWrapperPath(newPath);
var wrapper = newRequest.PopWrapperPathNode();
expressions.Add(wrapper.GetActivationExpression(scope, newRequest));
}
}
