public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope injectionScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
object returnValue = null;
if (HttpContext.Current != null)
{
returnValue = HttpContext.Current.Items[uniqueId];
}
if (returnValue == null)
{
IDisposalScope disposalScope = injectionContext.DisposalScope;
IInjectionScope requestingScope = injectionContext.RequestingScope;
injectionContext.DisposalScope = MVCDisposalScopeProvider.GetDisposalScope();
injectionContext.RequestingScope = exportStrategy.OwningScope;
returnValue = creationDelegate(exportStrategy.OwningScope, injectionContext);
injectionContext.DisposalScope = disposalScope;
injectionContext.RequestingScope = requestingScope;
if (returnValue != null && HttpContext.Current != null)
{
HttpContext.Current.Items[uniqueId] = returnValue;
}
}
return returnValue;
}
public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope injectionScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
IDictionary<object, object> items = OperationContext.Current.Items();
object returnValue = items[uniqueRequestKey];
if (returnValue == null)
{
IDisposalScope disposalScope = injectionContext.DisposalScope;
IInjectionScope requestingScope = injectionContext.RequestingScope;
injectionContext.DisposalScope = OperationContext.Current.DisposalScope();
injectionContext.RequestingScope = exportStrategy.OwningScope;
returnValue = creationDelegate(exportStrategy.OwningScope, injectionContext);
injectionContext.DisposalScope = disposalScope;
injectionContext.RequestingScope = requestingScope;
if (returnValue != null)
{
items[uniqueRequestKey] = returnValue;
}
}
return returnValue;
}
/// <summary>
/// Condition meet
/// </summary>
/// <param name="scope">injection scope</param>
/// <param name="injectionContext">injection context</param>
/// <param name="exportStrategy">export strategy</param>
/// <returns>condition</returns>
public bool ConditionMeet(IInjectionScope scope, IInjectionContext injectionContext, IExportStrategy exportStrategy)
{
bool found = false;
CurrentInjectionInfo[] injectionStack = injectionContext.GetInjectionStack();
for (int i = injectionStack.Length - 1; i >= 0 && !found; i--)
{
CurrentInjectionInfo injectionInfo = injectionStack[i];
foreach (Type ancestorType in ancestorTypes)
{
if (ancestorType.GetTypeInfo().IsInterface)
{
if(injectionInfo.ActivationType == ancestorType ||
(injectionInfo.CurrentExportStrategy != null && injectionInfo.CurrentExportStrategy.ExportTypes.Contains(ancestorType)))
{
found = true;
break;
}
}
else if (injectionInfo.ActivationType == ancestorType)
{
found = true;
break;
}
}
}
return found;
}
/// <summary>
/// This method is called by the export strategy when attempting to locate an export
/// </summary>
/// <param name="creationDelegate"></param>
/// <param name="exportStrategyScope"></param>
/// <param name="injectionContext"></param>
/// <param name="exportStrategy"></param>
/// <returns></returns>
public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope exportStrategyScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
if (instance.Value != null)
{
return instance.Value;
}
IDisposalScope contextdisposalScope = injectionContext.DisposalScope;
IInjectionScope requestingScope = injectionContext.RequestingScope;
injectionContext.DisposalScope = exportStrategyScope;
injectionContext.RequestingScope = exportStrategyScope;
object instanceValue = creationDelegate(exportStrategyScope, injectionContext);
injectionContext.DisposalScope = contextdisposalScope;
injectionContext.RequestingScope = requestingScope;
instance.Value = instanceValue;
IDisposable disposable = instanceValue as IDisposable;
if (disposable != null)
{
disposalScope.AddDisposable(disposable);
}
return instance.Value;
}
/// <summary>
/// Activate value
/// </summary>
/// <param name="exportInjectionScope">injection scope</param>
/// <param name="context">injection context</param>
/// <param name="consider">consider filter</param>
/// <param name="locateKey"></param>
/// <returns>activated value</returns>
public object Activate(IInjectionScope exportInjectionScope, IInjectionContext context, ExportStrategyFilter consider, object locateKey)
{
string parameterName = ParameterName;
if (context.TargetInfo == null)
{
throw new Exception("Must be injecting into type");
}
if (string.IsNullOrEmpty(parameterName))
{
parameterName = context.TargetInfo.InjectionTargetName;
}
string propertyString = HttpContext.Current.Request.QueryString[parameterName];
if (context.TargetInfo.InjectionTargetType != typeof(string) && !string.IsNullOrEmpty(propertyString))
{
Type underlyingType = Nullable.GetUnderlyingType(context.TargetInfo.InjectionTargetType);
if (underlyingType != null)
{
return Convert.ChangeType(propertyString, underlyingType);
}
if (context.TargetInfo.InjectionTargetType.IsValueType)
{
return Convert.ChangeType(propertyString, context.TargetInfo.InjectionTargetType);
}
throw new ArgumentException("You can only import ValueTypes or Nullable Types");
}
return propertyString;
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="exportDelegateInfo"></param>
/// <param name="activationDelegate"></param>
/// <param name="exportStrategy"></param>
/// <param name="owningScope"></param>
public FuncCompiledExportDelegate(CompiledExportDelegateInfo exportDelegateInfo,
ExportActivationDelegate activationDelegate,
IExportStrategy exportStrategy,
IInjectionScope owningScope)
: base(exportDelegateInfo,exportStrategy, owningScope)
{
exportActivationDelegate = activationDelegate;
}
public NavigationService(Frame frame, IInjectionScope injectionScope)
{
this.injectionScope = injectionScope;
frameReference = frame != null ?
new WeakReference<Frame>(frame) :
new WeakReference<Frame>(ViewHelper.MainContent as Frame);
}
public Binding(Type contractType, Type[] baseTypes, IInjectionFactory factory, IInjectionScope scope = null, Predicate<InjectionContext> condition = null)
{
ContractType = contractType;
BaseTypes = baseTypes;
Factory = factory;
Scope = scope;
Condition = condition;
}
public object Activate(IInjectionScope exportInjectionScope, IInjectionContext context, ExportStrategyFilter consider, object locateKey)
{
if (HttpContext.Current != null)
{
return HttpContext.Current.Request.Path;
}
return null;
}
/// <summary>
/// activate the strategy
/// </summary>
/// <param name="exportInjectionScope">injection scope</param>
/// <param name="context">injection context</param>
/// <param name="consider">consider filter</param>
/// <param name="locateKey"></param>
/// <returns>activated object</returns>
public override object Activate(IInjectionScope exportInjectionScope, IInjectionContext context, ExportStrategyFilter consider, object locateKey)
{
if (_lifestyle != null)
{
return _lifestyle.Locate(InternalActivate, exportInjectionScope, context, this);
}
return InternalActivate(exportInjectionScope, context);
}
public IDisposalScope ProvideDisposalScope(IInjectionScope injectionScope)
{
if (OperationContext.Current != null)
{
return OperationContext.Current.DisposalScope();
}
return injectionScope;
}
internal override void SetInstance(IInjectionScope scope, object instance)
{
if (!GetIsAlreadyResolved(scope))
{
_instancesPerScope.Add(scope, instance);
}
else
{
_instancesPerScope[scope] = instance;
}
}
/// <summary>
/// Activate the export
/// </summary>
/// <param name="exportInjectionScope"></param>
/// <param name="context"></param>
/// <param name="consider"></param>
/// <param name="locateKey"></param>
/// <returns></returns>
public override object Activate(IInjectionScope exportInjectionScope, IInjectionContext context, ExportStrategyFilter consider, object locateKey)
{
object targetOject = strategy.Activate(exportInjectionScope, context, consider, locateKey);
if (targetOject != null)
{
return propertyAccessor(targetOject);
}
return null;
}
/// <summary>
/// This method is called by the export strategy when attempting to locate an export
/// </summary>
/// <param name="creationDelegate"></param>
/// <param name="injectionScope"></param>
/// <param name="injectionContext"></param>
/// <param name="exportStrategy"></param>
/// <returns></returns>
public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope injectionScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
if (lifestyleContainer == null)
{
lifestyleContainer = LocateContainer(exportStrategy.OwningScope, injectionContext);
}
return lifestyleContainer.Locate(creationDelegate, injectionScope, injectionContext, exportStrategy);
}
/// <summary>
/// Called to determine if the export strategy meets the condition to be activated
/// </summary>
/// <param name="scope">injection scope that this export exists in</param>
/// <param name="injectionContext">injection context for this request</param>
/// <param name="exportStrategy">export strategy being tested</param>
/// <returns>true if the export meets the condition</returns>
public bool ConditionMeet(IInjectionScope scope, IInjectionContext injectionContext, IExportStrategy exportStrategy)
{
foreach (IExportCondition exportCondition in exportConditions)
{
if (!exportCondition.ConditionMeet(scope, injectionContext, exportStrategy))
{
return false;
}
}
return true;
}
/// <summary>
/// Called to determine if the export strategy meets the condition to be activated
/// </summary>
/// <param name="scope">injection scope that this export exists in</param>
/// <param name="injectionContext">injection context for this request</param>
/// <param name="exportStrategy">export strategy being tested</param>
/// <returns>true if the export meets the condition</returns>
public bool ConditionMeet(IInjectionScope scope, IInjectionContext injectionContext, IExportStrategy exportStrategy)
{
if (injectionContext.TargetInfo != null)
{
foreach (Attribute injectionTypeAttribute in injectionContext.TargetInfo.InjectionTypeAttributes)
{
if (injectionTypeAttribute.GetType().GetTypeInfo().IsAssignableFrom(attributeType.GetTypeInfo()))
{
return true;
}
}
}
return false;
}
/// <summary>
/// Called to determine if the export strategy meets the condition to be activated
/// </summary>
/// <param name="scope">injection scope that this export exists in</param>
/// <param name="injectionContext">injection context for this request</param>
/// <param name="exportStrategy">export strategy being tested</param>
/// <returns>true if the export meets the condition</returns>
public bool ConditionMeet(IInjectionScope scope, IInjectionContext injectionContext, IExportStrategy exportStrategy)
{
if (answer.HasValue)
{
return answer.Value;
}
bool returnValue = ConfigurationManager.AppSettings[settingName] == null;
if (cacheAnswer)
{
answer = returnValue;
}
return returnValue;
}
/// <summary>
/// Called to determine if the export strategy meets the condition to be activated
/// </summary>
/// <param name="scope">injection scope that this export exists in</param>
/// <param name="injectionContext">injection context for this request</param>
/// <param name="exportStrategy">export strategy being tested</param>
/// <returns>true if the export meets the condition</returns>
public bool ConditionMeet(IInjectionScope scope, IInjectionContext injectionContext, IExportStrategy exportStrategy)
{
IInjectionTargetInfo targetInfo = injectionContext.TargetInfo;
if (targetInfo != null && injectedType != null)
{
foreach (Type type in injectedType)
{
if (targetInfo.InjectionType.GetTypeInfo().IsAssignableFrom(type.GetTypeInfo()))
{
return true;
}
}
}
return false;
}
/// <summary>
/// returns true when the app.config setting is equal to the provided value
/// </summary>
/// <param name="scope"></param>
/// <param name="injectionContext"></param>
/// <param name="exportStrategy"></param>
/// <returns></returns>
public bool ConditionMeet(IInjectionScope scope, IInjectionContext injectionContext, IExportStrategy exportStrategy)
{
if (answer.HasValue)
{
return answer.Value;
}
string appSetting = ConfigurationManager.AppSettings[settingName];
bool returnValue = false;
if (appSetting != null)
{
if (settingValue == null)
{
return false;
}
if (appSetting.GetType() == settingValue.GetType())
{
returnValue = Equals(settingValue, appSetting);
}
try
{
returnValue = Equals(settingValue, Convert.ChangeType(appSetting, settingValue.GetType()));
}
catch (Exception exp)
{
Logger.Error(
string.Format("Exception thrown while converting {0} to {1}", appSetting, settingValue.GetType().FullName),
supplemental,
exp);
}
}
else if (settingValue == null)
{
returnValue = true;
}
if (cacheAnswer)
{
answer = returnValue;
}
return returnValue;
}
/// <summary>
/// This method is called by the export strategy when attempting to locate an export
/// </summary>
/// <param name="creationDelegate"></param>
/// <param name="exportStrategyScope"></param>
/// <param name="injectionContext"></param>
/// <param name="exportStrategy"></param>
/// <returns></returns>
public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope exportStrategyScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
object returnValue = null;
if (intanceRef != null)
{
returnValue = intanceRef.Target;
}
if (returnValue == null)
{
lock (lockObject)
{
if (intanceRef != null)
{
returnValue = intanceRef.Target;
}
if (returnValue == null)
{
IDisposalScope disposalScope = injectionContext.DisposalScope;
IInjectionScope requeInjectionScope = injectionContext.RequestingScope;
// null scope because weak exports can't have
injectionContext.DisposalScope = null;
injectionContext.RequestingScope = exportStrategyScope;
returnValue = creationDelegate(exportStrategyScope, injectionContext);
injectionContext.DisposalScope = disposalScope;
injectionContext.RequestingScope = requeInjectionScope;
if (returnValue != null)
{
intanceRef = new WeakReference(returnValue);
}
}
}
}
return returnValue;
}
/// <summary>
/// This method is called by the export strategy when attempting to locate an export
/// </summary>
/// <param name="creationDelegate"></param>
/// <param name="exportStrategyScope"></param>
/// <param name="injectionContext"></param>
/// <param name="exportStrategy"></param>
/// <returns></returns>
public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope exportStrategyScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
object returnValue = injectionContext.RequestingScope.GetExtraData(uniqueId);
if (returnValue == null)
{
IInjectionScope requestScope = injectionContext.RequestingScope;
returnValue = creationDelegate(exportStrategyScope, injectionContext);
requestScope.SetExtraData(uniqueId, returnValue);
}
return returnValue;
}
/// <summary>
/// Creates an instance in a singleton scope
/// </summary>
/// <param name="creationDelegate"></param>
/// <param name="exportStrategyScope"></param>
/// <param name="injectionContext"></param>
/// <returns></returns>
public static object CreateInSingletonScope(ExportActivationDelegate creationDelegate,
IInjectionScope exportStrategyScope,
IInjectionContext injectionContext)
{
object returnValue = null;
IDisposalScope disposalScope = injectionContext.DisposalScope;
IInjectionScope requestingScope = injectionContext.RequestingScope;
injectionContext.DisposalScope = exportStrategyScope;
injectionContext.RequestingScope = exportStrategyScope;
returnValue = creationDelegate(exportStrategyScope, injectionContext);
injectionContext.DisposalScope = disposalScope;
injectionContext.RequestingScope = requestingScope;
return returnValue;
}
/// <summary>
/// This method is called by the export strategy when attempting to locate an export
/// </summary>
/// <param name="creationDelegate"></param>
/// <param name="injectionScope"></param>
/// <param name="injectionContext"></param>
/// <param name="exportStrategy"></param>
/// <returns></returns>
public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope injectionScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
object returnValue = injectionContext.GetExtraData(key);
if (returnValue == null)
{
returnValue = creationDelegate(injectionScope, injectionContext);
if (returnValue != null)
{
injectionContext.SetExtraData(key, returnValue);
}
}
return returnValue;
}
/// <summary>
/// Called to determine if the export strategy meets the condition to be activated
/// </summary>
/// <param name="scope">injection scope that this export exists in</param>
/// <param name="injectionContext">injection context for this request</param>
/// <param name="exportStrategy">export strategy being tested</param>
/// <returns>true if the export meets the condition</returns>
public bool ConditionMeet(IInjectionScope scope, IInjectionContext injectionContext, IExportStrategy exportStrategy)
{
if (answer.HasValue)
{
return answer.Value;
}
string appSetting = ConfigurationManager.AppSettings[settingName];
bool returnValue = string.IsNullOrEmpty(appSetting) ||
string.Compare("false", appSetting, StringComparison.CurrentCultureIgnoreCase) == 0;
if (cacheAnswer)
{
answer = returnValue;
}
return returnValue;
}
public object Locate(ExportActivationDelegate creationDelegate,
IInjectionScope injectionScope,
IInjectionContext injectionContext,
IExportStrategy exportStrategy)
{
object returnValue = null;
IInjectionScope locateScope = FindNamedScope(injectionContext.RequestingScope);
if (locateScope == null)
{
throw new InjectionScopeCouldNotBeFoundException(_namedScope);
}
returnValue = locateScope.GetExtraData(_uniqueId);
if (returnValue != null)
{
return returnValue;
}
lock (_lockObject)
{
returnValue = locateScope.GetExtraData(_uniqueId) ??
SingletonLifestyle.CreateInSingletonScope(creationDelegate,
locateScope,
injectionContext);
if (returnValue != null)
{
locateScope.SetExtraData(_uniqueId, returnValue);
IDisposable disposable = returnValue as IDisposable;
if (disposable != null)
{
locateScope.AddDisposable(disposable);
}
}
}
return returnValue;
}
/// <summary>
/// ResolveAll will be called every time a collection is resolved
/// </summary>
/// <param name="owningScope"></param>
/// <param name="context"></param>
/// <param name="resolveName"></param>
/// <param name="resolveType"></param>
/// <param name="collectionEmpty"></param>
/// <param name="consider"></param>
/// <param name="locateKey"></param>
/// <returns></returns>
public IEnumerable<object> LocateAll(IInjectionScope owningScope, IInjectionContext context, string resolveName, Type resolveType, bool collectionEmpty, ExportStrategyFilter consider, object locateKey)
{
if (resolveType != null && resolveType.IsInterface && collectionEmpty)
{
Type createType = typeof(NSubstituteExportStrategy<>).MakeGenericType(resolveType);
ICompiledExportStrategy newStrategy = Activator.CreateInstance(createType) as ICompiledExportStrategy;
if (newStrategy != null)
{
newStrategy.SetLifestyleContainer(new SingletonLifestyle());
newStrategy.AddExportType(resolveType);
owningScope.AddStrategy(newStrategy);
yield return newStrategy.Activate(owningScope, context, null, locateKey);
}
}
}
/// <summary>
/// Activate the export
/// </summary>
/// <param name="exportInjectionScope"></param>
/// <param name="context"></param>
/// <param name="consider"></param>
/// <param name="locateKey"></param>
/// <returns></returns>
public override object Activate(IInjectionScope exportInjectionScope, IInjectionContext context, ExportStrategyFilter consider, object locateKey)
{
if (Log.IsDebugEnabled)
{
if (Lifestyle != null)
{
Log.DebugFormat("Activating export type {0} with life cycle container {1} ",
ActivationType.FullName,
Lifestyle.GetType().FullName);
}
else
{
Log.DebugFormat("Activating export type {0} with no life cycle container ",
ActivationType.FullName);
}
}
try
{
if (_lifestyle != null)
{
return _lifestyle.Locate(activationDelegate, exportInjectionScope, context, this);
}
return activationDelegate(exportInjectionScope, context);
}
catch (LocateException locateException)
{
locateException.AddLocationInformationEntry(new StrategyBeingActivated(this));
throw;
}
catch (Exception exp)
{
GeneralLocateException locateException = new GeneralLocateException(null, (Type)null, context, exp);
locateException.AddLocationInformationEntry(new StrategyBeingActivated(this));
throw locateException;
}
}
/// <summary>
/// Locates an ILifestyle
/// </summary>
/// <param name="injectionScope"></param>
/// <param name="injectionContext"></param>
/// <returns></returns>
private static ILifestyle LocateContainer(IInjectionScope injectionScope, IInjectionContext injectionContext)
{
ILifestyle returnValue = null;
try
{
IPerRequestLifestyleProvider provider =
injectionScope.Locate<IPerRequestLifestyleProvider>(injectionContext);
if (provider != null)
{
returnValue = provider.ProvideContainer();
}
}
catch (Exception exp)
{
Logger.Error("Exception throw while trying to locate IPerRequestLifestyleProvider", "SingletonPerRequest", exp);
}
return returnValue ?? new SingletonPerInjectionContextLifestyle();
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="injectionScope"></param>
public LazyWrapperStrategy(IInjectionScope injectionScope) : base(typeof(Lazy <>), injectionScope)
{
}
/// <summary>
/// Create expression that calls a delegate
/// </summary>
/// <param name="scope">scope for the request</param>
/// <param name="request">activation request</param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateExpression(IInjectionScope scope,
IActivationExpressionRequest request)
{
return(ExpressionUtilities.CreateExpressionForDelegate(DelegateInstance, ShouldTrackDisposable(scope), scope, request, this));
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="injectionScope"></param>
public FuncOneArgWrapperStrategy(IInjectionScope injectionScope) : base(typeof(Func <,>), injectionScope)
{
}
/// <summary>
/// Default Constructor
/// </summary>
/// <param name="injectionScope"></param>
public InjectionScopeDiagnostics(IExportLocatorScope injectionScope)
{
_injectionScope = injectionScope.GetInjectionScope();
ProcessInjectionDependencies();
}
protected override void ConfigureApplicationContainer(IInjectionScope existingContainer)
{
ApplicationContainerConfigured = true;
base.ConfigureApplicationContainer(existingContainer);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="activationType">type to activate</param>
/// <param name="injectionScope">owning injection scope</param>
protected ConfigurableActivationStrategy(Type activationType, IInjectionScope injectionScope)
{
ActivationConfiguration = new TypeActivationConfiguration(activationType, this);
InjectionScope = injectionScope;
}
/// <summary>
/// Creates decorated expression for activation strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="strategy"></param>
/// <param name="decorators"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateDecoratedActivationStrategy(IInjectionScope scope, IActivationExpressionRequest request, ICompiledExportStrategy strategy, List <ICompiledDecoratorStrategy> decorators)
{
decorators.Sort((x, y) => Comparer <int> .Default.Compare(x.Priority, y.Priority));
var pathNodes = ImmutableLinkedList <IActivationPathNode> .Empty;
if (decorators.All(d => d.ApplyAfterLifestyle))
{
pathNodes = pathNodes.Add(new DecoratorActivationPathNode(strategy, request.ActivationType, strategy.Lifestyle));
foreach (var decorator in decorators)
{
pathNodes = pathNodes.Add(new DecoratorActivationPathNode(decorator, request.ActivationType, null));
}
}
else
{
pathNodes = pathNodes.Add(new DecoratorActivationPathNode(strategy, request.ActivationType, null));
DecoratorActivationPathNode currentNode = null;
foreach (var decorator in decorators.Where(d => !d.ApplyAfterLifestyle))
{
currentNode = new DecoratorActivationPathNode(decorator, request.ActivationType, null);
pathNodes = pathNodes.Add(currentNode);
}
if (currentNode != null)
{
currentNode.Lifestyle = strategy.Lifestyle;
}
foreach (var decorator in decorators.Where(d => d.ApplyAfterLifestyle))
{
pathNodes = pathNodes.Add(new DecoratorActivationPathNode(decorator, request.ActivationType, null));
}
}
request.SetDecoratorPath(pathNodes);
var pathNode = request.PopDecoratorPathNode();
return(pathNode.GetActivationExpression(scope, request));
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="injectionScope"></param>
public TypedActivationStrategyDelegateWrapperStrategy(IInjectionScope injectionScope) : base(typeof(TypedActivationStrategyDelegate <>), injectionScope)
{
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="owningScope"></param>
/// <param name="strategyCreator"></param>
public ExportRegistrationBlock(IInjectionScope owningScope, IActivationStrategyCreator strategyCreator)
{
_strategyCreator = strategyCreator;
OwningScope = owningScope;
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="activationType"></param>
/// <param name="injectionScope"></param>
/// <param name="builder"></param>
public CompiledExportStrategy(Type activationType, IInjectionScope injectionScope, IDefaultStrategyExpressionBuilder builder) : base(activationType, injectionScope)
{
_builder = builder;
}
/// <summary>
/// Get an activation expression for this strategy
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="lifestyle"></param>
/// <returns></returns>
public IActivationExpressionResult GetDecoratorActivationExpression(IInjectionScope scope, IActivationExpressionRequest request, ICompiledLifestyle lifestyle)
{
return(_builder.GetActivationExpression(scope, request, ActivationConfiguration, lifestyle));
}
/// <summary> /// Get an activation expression for this strategy /// </summary> /// <param name="scope"></param> /// <param name="request"></param> /// <returns></returns> public abstract IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request);
/// <summary>
/// Default constructor
/// </summary>
/// <param name="activationType">type being activated</param>
/// <param name="injectionScope">scope for strategy</param>
protected BaseWrapperStrategy(Type activationType, IInjectionScope injectionScope) : base(activationType, injectionScope)
{
}
/// <summary>
/// Get a linq expression to satisfy the request
/// </summary>
/// <param name="scope">scope</param>
/// <param name="request">request</param>
/// <returns></returns>
public virtual IActivationExpressionResult GetActivationExpression(IInjectionScope scope, IActivationExpressionRequest request)
{
var activationExpressionResult = GetValueFromRequest(scope, request, request.ActivationType, null);
if (activationExpressionResult != null)
{
return(activationExpressionResult);
}
activationExpressionResult = GetValueFromInjectionValueProviders(scope, request);
if (activationExpressionResult != null)
{
return(activationExpressionResult);
}
activationExpressionResult = GetActivationExpressionFromStrategies(scope, request);
if (activationExpressionResult != null)
{
return(activationExpressionResult);
}
if (request.ActivationType.IsArray)
{
return(ArrayExpressionCreator.GetArrayExpression(scope, request));
}
if (request.ActivationType.IsConstructedGenericType &&
request.ActivationType.GetGenericTypeDefinition() == typeof(IEnumerable <>))
{
return(EnumerableExpressionCreator.GetEnumerableExpression(scope, request, ArrayExpressionCreator));
}
var wrapperResult = WrapperExpressionCreator.GetActivationExpression(scope, request);
if (wrapperResult != null)
{
return(wrapperResult);
}
if (scope.MissingExportStrategyProviders.Any())
{
lock (scope.GetLockObject(InjectionScope.ActivationStrategyAddLockName))
{
activationExpressionResult = GetActivationExpressionFromStrategies(scope, request);
if (activationExpressionResult != null)
{
return(activationExpressionResult);
}
wrapperResult = WrapperExpressionCreator.GetActivationExpression(scope, request);
if (wrapperResult != null)
{
return(wrapperResult);
}
request.Services.Compiler.ProcessMissingStrategyProviders(scope, request);
activationExpressionResult = GetActivationExpressionFromStrategies(scope, request);
if (activationExpressionResult != null)
{
return(activationExpressionResult);
}
wrapperResult = WrapperExpressionCreator.GetActivationExpression(scope, request);
if (wrapperResult != null)
{
return(wrapperResult);
}
}
}
var parent = scope.Parent as IInjectionScope;
if (parent != null)
{
return(GetActivationExpression(parent, request));
}
return(GetValueFromInjectionContext(scope, request));
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="activationStrategy"></param>
public LazyExpression(IInjectionScope scope, IActivationExpressionRequest request, IActivationStrategy activationStrategy)
{
_scope = scope;
_request = request;
_activationStrategy = activationStrategy;
}
/// <summary>
/// Allow constructor selector to override method
/// </summary>
/// <param name="injectionScope"></param>
/// <param name="configuration"></param>
/// <param name="request"></param>
/// <param name="constructor"></param>
/// <param name="expression"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult OverrideExpression(IInjectionScope injectionScope, TypeActivationConfiguration configuration, IActivationExpressionRequest request, ConstructorInfo constructor, IActivationExpressionResult expression)
{
return(expression);
}
internal static bool IsChild(this IInjectionScope container) => container.Parent != null;
/// <summary>
/// Can the service be located
/// </summary>
/// <param name="injectionScope">injection scope</param>
/// <param name="type">type to be located</param>
/// <param name="filter">filter for locate</param>
/// <param name="key">key to use for locate</param>
/// <param name="includeProviders"></param>
/// <returns></returns>
public bool CanLocate(IInjectionScope injectionScope, Type type, ActivationStrategyFilter filter, object key = null, bool includeProviders = true)
{
if (key != null)
{
var collection = injectionScope.StrategyCollectionContainer.GetActivationStrategyCollection(type);
if (collection?.GetKeyedStrategy(key) != null)
{
return(true);
}
return(injectionScope.Parent?.CanLocate(type, filter, key) ?? false);
}
if (injectionScope.StrategyCollectionContainer.GetActivationStrategyCollection(type) != null)
{
return(true);
}
if (injectionScope.WrapperCollectionContainer.GetActivationStrategyCollection(type) != null)
{
return(true);
}
if (type.IsArray)
{
return(true);
}
if (type.IsConstructedGenericType)
{
var generic = type.GetGenericTypeDefinition();
if (injectionScope.StrategyCollectionContainer.GetActivationStrategyCollection(generic) != null)
{
return(true);
}
var collection = injectionScope.WrapperCollectionContainer.GetActivationStrategyCollection(generic);
if (collection != null)
{
foreach (var strategy in collection.GetStrategies())
{
var wrappedType = strategy.GetWrappedType(type);
if (CanLocate(injectionScope, wrappedType, filter))
{
return(true);
}
}
}
if (generic == typeof(IEnumerable <>))
{
return(true);
}
}
if (type == typeof(ILocatorService) ||
type == typeof(IExportLocatorScope) ||
type == typeof(IInjectionContext) ||
type == typeof(IDisposalScope) ||
type == typeof(StaticInjectionContext) ||
(type == typeof(IDisposable) && injectionScope.ScopeConfiguration.InjectIDisposable))
{
return(true);
}
if (includeProviders)
{
var request = injectionScope.StrategyCompiler.CreateNewRequest(type, 0, injectionScope);
foreach (var provider in injectionScope.InjectionValueProviders)
{
if (provider.CanLocate(injectionScope, request))
{
return(true);
}
}
foreach (var provider in injectionScope.MissingExportStrategyProviders)
{
if (provider.CanLocate(injectionScope, request))
{
return(true);
}
}
}
return(injectionScope.Parent?.CanLocate(type, filter) ?? false);
}
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>
/// This method is called when there are multiple constructors
/// </summary>
/// <param name="injectionScope"></param>
/// <param name="configuration"></param>
/// <param name="request"></param>
/// <param name="constructors"></param>
/// <returns></returns>
protected abstract ConstructorInfo PickConstructor(IInjectionScope injectionScope,
TypeActivationConfiguration configuration, IActivationExpressionRequest request, ConstructorInfo[] constructors);
/// <summary>
/// Default constructor
/// </summary>
/// <param name="activationType"></param>
/// <param name="injectionScope"></param>
public DelegateOneArgWrapperStrategy(Type activationType, IInjectionScope injectionScope) : base(activationType, injectionScope)
{
}
/// <summary>
/// Locate a strategy from collection containers
/// </summary>
/// <param name="scope"></param>
/// <param name="locateType"></param>
/// <param name="consider"></param>
/// <param name="key"></param>
/// <param name="injectionContext"></param>
/// <returns></returns>
protected virtual ActivationStrategyDelegate LocateStrategyFromCollectionContainers(IInjectionScope scope, Type locateType, ActivationStrategyFilter consider, object key, IInjectionContext injectionContext)
{
if (key != null)
{
return(FindKeyedDelegate(scope, locateType, consider, key));
}
var strategyCollection = scope.StrategyCollectionContainer.GetActivationStrategyCollection(locateType);
if (strategyCollection != null)
{
var primary = consider == null?strategyCollection.GetPrimary() : null;
if (primary != null)
{
return(primary.GetActivationStrategyDelegate(scope, this, locateType));
}
var strategy = GetStrategyFromCollection(strategyCollection, scope, consider, locateType, injectionContext);
if (strategy != null)
{
return(strategy.GetActivationStrategyDelegate(scope, this, locateType));
}
}
var isGeneric = locateType.IsConstructedGenericType;
if (isGeneric)
{
var generic = locateType.GetGenericTypeDefinition();
strategyCollection = scope.StrategyCollectionContainer.GetActivationStrategyCollection(generic);
if (strategyCollection != null)
{
var primary = consider == null?strategyCollection.GetPrimary() : null;
if (primary != null)
{
return(primary.GetActivationStrategyDelegate(scope, this, locateType));
}
var strategy = GetStrategyFromCollection(strategyCollection, scope, consider, locateType, injectionContext);
if (strategy != null)
{
return(strategy.GetActivationStrategyDelegate(scope, this, locateType));
}
}
}
var wrapperCollection = scope.WrapperCollectionContainer.GetActivationStrategyCollection(locateType);
if (wrapperCollection != null)
{
var primary = consider == null?wrapperCollection.GetPrimary() : null;
if (primary != null)
{
return(primary.GetActivationStrategyDelegate(scope, this, locateType));
}
var strategy = GetStrategyFromCollection(strategyCollection, scope, consider, locateType, injectionContext);
if (strategy != null)
{
return(strategy.GetActivationStrategyDelegate(scope, this, locateType));
}
}
if (isGeneric)
{
var generic = locateType.GetGenericTypeDefinition();
wrapperCollection = scope.WrapperCollectionContainer.GetActivationStrategyCollection(generic);
if (wrapperCollection != null)
{
var primary = consider == null?wrapperCollection.GetPrimary() : null;
if (primary != null)
{
return(primary.GetActivationStrategyDelegate(scope, this, locateType));
}
var strategy = GetStrategyFromCollection(strategyCollection, scope, consider, locateType, injectionContext);
if (strategy != null)
{
return(strategy.GetActivationStrategyDelegate(scope, this, locateType));
}
}
}
return(null);
}
/// <summary>
/// Create member init expression
/// </summary>
/// <param name="scope">scope for configuration</param>
/// <param name="request">request</param>
/// <param name="activationConfiguration">activation configuration</param>
/// <param name="result">result from instantation</param>
/// <param name="newExpression">instantiation expression</param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateNewMemeberInitExpression(IInjectionScope scope, IActivationExpressionRequest request, TypeActivationConfiguration activationConfiguration, IActivationExpressionResult result, NewExpression newExpression)
{
var bindings = new List <MemberBinding>();
var members = GetMemberInjectionInfoForConfiguration(scope, request, activationConfiguration);
foreach (var memberKVP in members)
{
var expression = memberKVP.Value.CreateExpression;
if (expression == null)
{
var memberType = memberKVP.Key.GetMemeberType();
var newRequest =
request.NewRequest(memberType, activationConfiguration.ActivationStrategy, activationConfiguration.ActivationType, RequestType.Member, memberKVP.Key, false, true);
if (memberKVP.Value.LocateKey == null &&
scope.ScopeConfiguration.Behaviors.KeyedTypeSelector(memberType))
{
newRequest.SetLocateKey(memberKVP.Key.Name);
}
else
{
newRequest.SetLocateKey(memberKVP.Value.LocateKey);
}
newRequest.IsDynamic = memberKVP.Value.IsDynamic;
newRequest.SetIsRequired(memberKVP.Value.IsRequired);
newRequest.SetFilter(memberKVP.Value.Filter);
if (memberKVP.Value.DefaultValue != null)
{
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = memberKVP.Value.DefaultValue
});
}
var memberResult = request.Services.ExpressionBuilder.GetActivationExpression(scope, newRequest);
if (memberResult == null)
{
if (memberKVP.Value.IsRequired)
{
throw new LocateException(newRequest.GetStaticInjectionContext());
}
}
else
{
bindings.Add(Expression.Bind(memberKVP.Key, memberResult.Expression));
result.AddExpressionResult(memberResult);
}
}
else
{
bindings.Add(Expression.Bind(memberKVP.Key, expression));
}
}
if (bindings.Count > 0)
{
result.Expression = Expression.MemberInit(newExpression, bindings);
}
return(result);
}
/// <summary>
/// Creates a new expression request
/// </summary>
/// <param name="activationType">activation type</param>
/// <param name="objectGraphDepth">current object depth</param>
/// <param name="requestingScope">requesting scope</param>
/// <returns>request</returns>
public virtual IActivationExpressionRequest CreateNewRequest(Type activationType, int objectGraphDepth, IInjectionScope requestingScope)
{
if (activationType == null)
{
throw new ArgumentNullException(nameof(activationType));
}
if (requestingScope == null)
{
throw new ArgumentNullException(nameof(requestingScope));
}
return(new ActivationExpressionRequest(activationType,
RequestType.Root,
new ActivationServices(this, _builder, _attributeDiscoveryService, _exportExpressionBuilder, _injectionContextCreator),
_constants,
objectGraphDepth,
requestingScope));
}
/// <summary>
/// Get dictionary of members that need to be injected
/// </summary>
/// <param name="scope">scope</param>
/// <param name="request">expression request</param>
/// <param name="activationConfiguration">activation configuration</param>
/// <returns></returns>
protected virtual Dictionary <MemberInfo, MemberInjectionInfo> GetMemberInjectionInfoForConfiguration(IInjectionScope scope,
IActivationExpressionRequest request, TypeActivationConfiguration activationConfiguration)
{
var members = new Dictionary <MemberInfo, MemberInjectionInfo>();
var currentScope = scope;
while (currentScope != null)
{
ProcessMemberSelectors(scope, request, activationConfiguration.ActivationType, currentScope.MemberInjectionSelectors, members);
currentScope = currentScope.Parent as IInjectionScope;
}
ProcessMemberSelectors(scope, request, activationConfiguration.ActivationType, activationConfiguration.MemberInjectionSelectors, members);
return(members);
}
/// <summary>
/// Get expression for parameter
/// </summary>
/// <param name="parameter"></param>
/// <param name="parameterInfo"></param>
/// <param name="injectionScope"></param>
/// <param name="configuration"></param>
/// <param name="request"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult GetParameterExpression(ParameterInfo parameter, ConstructorParameterInfo parameterInfo, IInjectionScope injectionScope, TypeActivationConfiguration configuration, IActivationExpressionRequest request)
{
if (parameterInfo?.ExportFunc != null)
{
return(CallExportFunc(configuration.ActivationStrategy, parameter, parameterInfo, injectionScope, request, configuration.ExternallyOwned));
}
var newRequest = request.NewRequest(parameterInfo?.UseType ?? parameter.ParameterType,
configuration.ActivationStrategy,
configuration.ActivationType,
RequestType.ConstructorParameter,
parameter,
true,
true);
if (parameterInfo?.LocateWithKey != null)
{
newRequest.SetLocateKey(parameterInfo.LocateWithKey);
}
else if (injectionScope.ScopeConfiguration.Behaviors.KeyedTypeSelector(parameter.ParameterType))
{
newRequest.SetLocateKey(parameter.Name);
}
if (parameterInfo?.DefaultValue != null)
{
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = parameterInfo.DefaultValue
});
}
else if (parameter.HasDefaultValue)
{
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = parameter.DefaultValue
});
}
if (parameterInfo != null)
{
newRequest.IsDynamic = parameterInfo.IsDynamic;
newRequest.SetIsRequired(parameterInfo.IsRequired.GetValueOrDefault(!parameter.IsOptional));
newRequest.SetFilter(parameterInfo.ExportStrategyFilter);
newRequest.SetEnumerableComparer(parameterInfo.EnumerableComparer);
}
else
{
newRequest.SetIsRequired(!parameter.IsOptional);
}
return(newRequest.Services.ExpressionBuilder.GetActivationExpression(injectionScope, newRequest));
}
internal override bool GetIsAlreadyResolved(IInjectionScope scope) => _instancesPerScope.ContainsKey(scope);
private IActivationExpressionResult CallExportFunc(IActivationStrategy strategy, ParameterInfo parameter, ConstructorParameterInfo parameterInfo, IInjectionScope injectionScope, IActivationExpressionRequest request, bool configurationExternallyOwned)
{
var exportDelegate = parameterInfo.ExportFunc as Delegate;
if (exportDelegate == null)
{
throw new ArgumentException($"Parameter Info {parameterInfo.ParameterName} is not delegate", nameof(parameterInfo));
}
var newRequest = request.NewRequest(parameter.ParameterType, strategy, strategy.ActivationType,
RequestType.ConstructorParameter, parameter, false, true);
return(ExpressionUtilities.CreateExpressionForDelegate(exportDelegate, ShouldTrackDisposable(configurationExternallyOwned, injectionScope, strategy), injectionScope, newRequest));
}
/// <summary>
/// Create enumerable expression that is an array
/// </summary>
/// <param name="scope"></param>
/// <param name="request"></param>
/// <param name="arrayExpressionCreator"></param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateEnumerableExpressionUsingArrayExpression(IInjectionScope scope,
IActivationExpressionRequest request, IArrayExpressionCreator arrayExpressionCreator)
{
var enumerableType = request.ActivationType.GenericTypeArguments[0];
var arrayType = enumerableType.MakeArrayType();
var newRequest = request.NewRequest(arrayType, request.RequestingStrategy,
request.RequestingStrategy?.ActivationType, request.RequestType, request.Info, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
newRequest.SetLocateKey(request.LocateKey);
var arrayExpression = arrayExpressionCreator.GetArrayExpression(scope, newRequest);
return(arrayExpression);
}
public void ConfigureContainer(IInjectionScope scope)
{
scope.SetupMvc();
}
/// <summary>
/// Method used to invoke an activation delegate
/// </summary>
/// <param name="exportStrategyScope"></param>
/// <param name="activationDelegate"></param>
/// <param name="injectionContext"></param>
/// <returns></returns>
public static object InvokeActivationDelegate(ExportActivationDelegate activationDelegate,
IInjectionScope exportStrategyScope,
IInjectionContext injectionContext)
{
return activationDelegate(exportStrategyScope, injectionContext);
}
/// <summary>
/// Create enumerable expression using a custom creator
/// </summary>
/// <param name="scope">injection scope</param>
/// <param name="request">expression request</param>
/// <param name="arrayExpressionCreator">array creator</param>
/// <param name="enumerableCreator">custom enumerable creator</param>
/// <returns></returns>
protected virtual IActivationExpressionResult CreateEnumerableExpressionUsingCustomCreator(IInjectionScope scope,
IActivationExpressionRequest request, IArrayExpressionCreator arrayExpressionCreator,
IEnumerableCreator enumerableCreator)
{
var enumerableType = request.ActivationType.GenericTypeArguments[0];
var arrayType = enumerableType.MakeArrayType();
var newRequest =
request.NewRequest(arrayType, request.RequestingStrategy,
request.RequestingStrategy?.ActivationType, request.RequestType, request.Info, true, true);
newRequest.SetFilter(request.Filter);
newRequest.SetEnumerableComparer(request.EnumerableComparer);
var arrayExpression = arrayExpressionCreator.GetArrayExpression(scope, newRequest);
var enumerableExpression =
Expression.Call(Expression.Constant(enumerableCreator),
CreateEnumerableMethod.MakeGenericMethod(enumerableType),
request.ScopeParameter,
arrayExpression.Expression);
var returnResult = request.Services.Compiler.CreateNewResult(request, enumerableExpression);
returnResult.AddExpressionResult(returnResult);
return(returnResult);
}
