/// <summary> /// </summary> /// <param name="scope"></param> /// <param name="includeParent"></param> /// <param name="consider"></param> /// <returns></returns> public static string WhatDoIHave(this IExportLocatorScope scope, bool includeParent = true, ActivationStrategyFilter consider = null) { var builder = new StringBuilder(); var locator = scope.GetInjectionScope(); builder.AppendLine(new string('-', 80)); builder.AppendFormat("Exports for scope '{0}' with id {1}{2}", locator.ScopeName, locator.ScopeId, Environment.NewLine); foreach (var exportStrategy in locator.StrategyCollectionContainer.GetAllStrategies()) { ProcessExportStrategy(builder, exportStrategy); } if (includeParent && locator.Parent != null) { builder.Append(WhatDoIHave(scope.Parent, true, consider)); } return(builder.ToString()); }
/// <summary> /// Try to locate an export by type /// </summary> /// <param name="type">locate type</param> /// <param name="value">out value</param> /// <param name="extraData">extra data to use during locate</param> /// <param name="consider">filter out exports you don't want</param> /// <param name="withKey">key to use during locate</param> /// <param name="isDynamic">skip cache and look at all exports</param> /// <returns>returns tue if export found</returns> public bool TryLocate(Type type, out object value, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { var context = CreateInjectionContextFromExtraData(type, extraData); value = InternalLocate(this, this, type, consider, withKey, context, true, isDynamic); return(value != null); }
/// <summary> /// Locate all by specific name /// </summary> /// <param name="name"></param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <returns></returns> public List <object> LocateAllByName(string name, object extraData = null, ActivationStrategyFilter consider = null) { return(((IInjectionScope)this).InternalLocateAllByName(this, DisposalScope ?? DisposalScopeProvider.ProvideDisposalScope(this), name, extraData, consider)); }
public void FluentDecoratorWithCtor_Consider([Freeze] ConstructorParameterInfo constructorParameterInfo, FluentDecoratorWithCtorConfiguration <int> configuration) { ActivationStrategyFilter filter = strategy => true; configuration.Consider(filter); Assert.Same(filter, constructorParameterInfo.ExportStrategyFilter); }
/// <summary> /// Locate specific type using extra data or key /// </summary> /// <param name="type">type to locate</param> /// <param name="extraData">extra data to be used during construction</param> /// <param name="consider"></param> /// <param name="withKey">key to use for locating type</param> /// <param name="isDynamic"></param> /// <returns>located instance</returns> // ReSharper disable once MethodOverloadWithOptionalParameter public override object Locate(Type type, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { if (isDynamic || withKey != null || consider != null) { return(LocateFromParent(type, extraData, consider, withKey, false, isDynamic)); } return(DelegateCache.ExecuteActivationStrategyDelegateWithContext(type, this, false, extraData != null ? CreateContext(extraData) : null)); }
/// <summary> /// /// </summary> /// <param name="childScope"></param> /// <param name="disposalScope"></param> /// <param name="name"></param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <param name="allowNull"></param> /// <returns></returns> object IInjectionScope.LocateByNameFromChildScope(IExportLocatorScope childScope, IDisposalScope disposalScope, string name, object extraData, ActivationStrategyFilter consider, bool allowNull) { var collection = StrategyCollectionContainer.GetActivationStrategyCollectionByName(name); ICompiledExportStrategy strategy = null; if (collection != null) { if (consider != null) { var context = new StaticInjectionContext(typeof(object)); strategy = collection.GetStrategies() .FirstOrDefault( s => (!s.HasConditions || s.Conditions.All(con => con.MeetsCondition(s, context))) && consider(s)); } else { strategy = collection.GetPrimary(); if (strategy == null) { var context = new StaticInjectionContext(typeof(object)); strategy = collection.GetStrategies() .FirstOrDefault( s => !s.HasConditions || s.Conditions.All(con => con.MeetsCondition(s, context))); } } } if (strategy != null) { var strategyDelegate = strategy.GetActivationStrategyDelegate(this, InternalFieldStorage.ActivationStrategyCompiler, typeof(object)); return(strategyDelegate(childScope, disposalScope, CreateContext(extraData))); } if (Parent != null) { return(((IInjectionScope)Parent).LocateByNameFromChildScope(childScope, disposalScope, name, extraData, consider, allowNull)); } if (!allowNull) { throw new LocateException(new StaticInjectionContext(typeof(object))); } return(null); }
/// <summary> /// Applies a filter to be used when resolving a parameter constructor /// It will be called each time the parameter is resolved /// </summary> /// <param name="filter">filter delegate to be used when resolving parameter</param> /// <returns>configuration object</returns> public IFluentWithCtorConfiguration <TParam> Consider(ActivationStrategyFilter filter) { if (filter == null) { throw new ArgumentNullException(nameof(filter)); } _constructorParameterInfo.ExportStrategyFilter = filter; return(this); }
/// <summary> /// Locate specific type using extra data or key /// </summary> /// <param name="type">type to locate</param> /// <param name="extraData">extra data to be used during construction</param> /// <param name="consider">filter out exports you don't want to consider</param> /// <param name="withKey">key to use for locating type</param> /// <param name="isDynamic">skip cache and look through exports</param> /// <returns>located instance</returns> // ReSharper disable once MethodOverloadWithOptionalParameter public override object Locate(Type type, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { IInjectionContext context = extraData == null ? null : CreateInjectionContextFromExtraData(type, extraData); if (withKey == null && consider == null && !isDynamic) { return(DelegateCache.ExecuteActivationStrategyDelegateWithContext(type, this, false, context)); } return(InternalLocate(this, this, type, consider, withKey, context, false, isDynamic)); }
/// <summary> /// Locate specific type using extra data or key /// </summary> /// <param name="type">type to locate</param> /// <param name="extraData">extra data to be used during construction</param> /// <param name="consider"></param> /// <param name="withKey">key to use for locating type</param> /// <param name="isDynamic"></param> /// <returns>located instance</returns> // ReSharper disable once MethodOverloadWithOptionalParameter public object Locate(Type type, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { if (isDynamic || withKey != null || consider != null) { return(LocateFromParent(type, extraData, consider, withKey, false, isDynamic)); } var hashCode = type.GetHashCode(); var func = ActivationDelegates[hashCode & ArrayLengthMinusOne].GetValueOrDefault(type, hashCode); return(func != null? func(this, this, extraData == null?null : CreateContext(extraData)) : LocateFromParent(type, null, null, null, allowNull: false, isDynamic: false)); }
/// <summary> /// Try to locate an export by type /// </summary> /// <typeparam name="T">locate type</typeparam> /// <param name="value">out value</param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <param name="withKey"></param> /// <param name="isDynamic"></param> /// <returns></returns> public override bool TryLocate <T>(out T value, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { object outValue; if (TryLocate(typeof(T), out outValue, extraData, consider, withKey, isDynamic)) { value = (T)outValue; return(true); } value = default(T); return(false); }
/// <summary> /// Locate specific type using extra data or key /// </summary> /// <param name="type">type to locate</param> /// <param name="extraData">extra data to be used during construction</param> /// <param name="consider">filter out exports you don't want to consider</param> /// <param name="withKey">key to use for locating type</param> /// <param name="isDynamic">skip cache and look through exports</param> /// <returns>located instance</returns> // ReSharper disable once MethodOverloadWithOptionalParameter public object Locate(Type type, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { var context = CreateInjectionContextFromExtraData(type, extraData); if (withKey == null && consider == null && !isDynamic) { var hash = type.GetHashCode(); var func = ActivationDelegates[hash & ArrayLengthMinusOne].GetValueOrDefault(type, hash); if (func != null) { return(func(this, DisposalScope ?? DisposalScopeProvider.ProvideDisposalScope(this), context)); } } return(InternalLocate(this, DisposalScope ?? DisposalScopeProvider.ProvideDisposalScope(this), type, consider, withKey, context, false, isDynamic)); }
/// <summary> /// try to locate a specific type /// </summary> /// <param name="type">type to locate</param> /// <param name="value">located value</param> /// <param name="extraData">extra data to be used during locate</param> /// <param name="consider">filter to use during location</param> /// <param name="withKey">key to use during locate</param> /// <param name="isDynamic">is the request dynamic</param> /// <returns>true if export could be located</returns> public bool TryLocate(Type type, out object value, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { if (!isDynamic && withKey == null && consider == null) { var hashCode = type.GetHashCode(); var func = ActivationDelegates[hashCode & ArrayLengthMinusOne].GetValueOrDefault(type, hashCode); if (func != null) { value = func(this, this, extraData == null ? null : CreateContext(extraData)); return(value != null); } } value = LocateFromParent(type, extraData, consider, withKey, true, isDynamic); return(value != null); }
/// <summary> /// Try to locate a specific type /// </summary> /// <typeparam name="T"></typeparam> /// <param name="value">located value</param> /// <param name="extraData">extra data to be used during construction</param> /// <param name="consider">filter out exports you don't want</param> /// <param name="withKey">key to use while locating</param> /// <param name="isDynamic">skip cache and look at all exports</param> /// <returns></returns> public bool TryLocate <T>(out T value, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { var context = CreateInjectionContextFromExtraData(typeof(T), extraData); var newValue = InternalLocate(this, this, typeof(T), consider, withKey, context, true, isDynamic); var returnValue = false; if (newValue != null) { returnValue = true; value = (T)newValue; } else { value = default(T); } return(returnValue); }
private object InternalLocate(IExportLocatorScope scope, IDisposalScope disposalScope, Type type, ActivationStrategyFilter consider, object key, IInjectionContext injectionContext, bool allowNull, bool isDynamic) { if (type == typeof(ILocatorService) || type == typeof(IExportLocatorScope)) { return(scope); } if (isDynamic) { if (type.IsArray) { return(DynamicArray(scope, disposalScope, type, consider, injectionContext)); } if (type.IsConstructedGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { return(DynamicIEnumerable(scope, disposalScope, type, consider, injectionContext)); } } var compiledDelegate = InternalFieldStorage.ActivationStrategyCompiler.FindDelegate(this, type, consider, key, injectionContext, InternalFieldStorage.MissingExportStrategyProviders != ImmutableLinkedList <IMissingExportStrategyProvider> .Empty); if (compiledDelegate != null) { if (key == null && consider == null) { compiledDelegate = AddObjectFactory(type, compiledDelegate); } return(compiledDelegate(scope, disposalScope ?? (DisposalScope ?? DisposalScopeProvider.ProvideDisposalScope(scope)), injectionContext)); } if (Parent != null) { var injectionScopeParent = (IInjectionScope)Parent; return(injectionScopeParent.LocateFromChildScope(this, disposalScope, type, injectionContext, consider, key, allowNull, isDynamic)); } if (!allowNull) { throw new LocateException(new StaticInjectionContext(type)); } return(null); }
/// <summary> /// /// </summary> /// <param name="scope"></param> /// <param name="disposalScope"></param> /// <param name="exportName"></param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <returns></returns> List <object> IInjectionScope.InternalLocateAllByName(IExportLocatorScope scope, IDisposalScope disposalScope, string exportName, object extraData, ActivationStrategyFilter consider) { var context = CreateContext(extraData); var returnList = new List <object>(); var collection = StrategyCollectionContainer.GetActivationStrategyCollectionByName(exportName); foreach (var strategy in collection.GetStrategies()) { if (consider == null || consider(strategy)) { var activation = strategy.GetActivationStrategyDelegate(this, InternalFieldStorage.ActivationStrategyCompiler, typeof(object)); returnList.Add(activation(scope, disposalScope, context.Clone())); } } var injectionScopeParent = Parent as IInjectionScope; if (injectionScopeParent != null) { returnList.AddRange(injectionScopeParent.InternalLocateAllByName(scope, disposalScope, exportName, context, consider)); } return(returnList); }
/// <summary> /// Internal locate all method /// </summary> /// <typeparam name="T"></typeparam> /// <param name="scope"></param> /// <param name="disposalScope"></param> /// <param name="type"></param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <param name="comparer"></param> /// <returns></returns> List <T> IInjectionScope.InternalLocateAll <T>(IExportLocatorScope scope, IDisposalScope disposalScope, Type type, object extraData, ActivationStrategyFilter consider, IComparer <T> comparer) { var returnList = new List <T>(); var context = CreateInjectionContextFromExtraData(typeof(T), extraData); var collection = StrategyCollectionContainer.GetActivationStrategyCollection(type); if (collection != null) { LocateEnumerablesFromStrategyCollection(collection, scope, disposalScope, type, context, consider, returnList); } if (type.IsConstructedGenericType) { var genericType = type.GetGenericTypeDefinition(); collection = StrategyCollectionContainer.GetActivationStrategyCollection(genericType); if (collection != null) { LocateEnumerablesFromStrategyCollection(collection, scope, disposalScope, type, context, consider, returnList); } } var injectionParent = Parent as IInjectionScope; if (injectionParent != null) { returnList.AddRange(injectionParent.InternalLocateAll <T>(scope, disposalScope, type, context, consider, null)); } if (comparer != null) { returnList.Sort(comparer); } return(returnList); }
/// <summary> /// Locate an export from a child scope /// </summary> /// <param name="childScope">scope where the locate originated</param> /// <param name="disposalScope"></param> /// <param name="type">type to locate</param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <param name="key"></param> /// <param name="allowNull"></param> /// <param name="isDynamic"></param> /// <returns>configuration object</returns> object IInjectionScope.LocateFromChildScope(IExportLocatorScope childScope, IDisposalScope disposalScope, Type type, object extraData, ActivationStrategyFilter consider, object key, bool allowNull, bool isDynamic) { return(InternalLocate(childScope, disposalScope, type, consider, key, CreateInjectionContextFromExtraData(type, extraData), allowNull, isDynamic)); }
/// <summary> /// Try to locate by name /// </summary> /// <param name="name"></param> /// <param name="value"></param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <returns></returns> public bool TryLocateByName(string name, out object value, object extraData = null, ActivationStrategyFilter consider = null) { value = ((IInjectionScope)this).LocateByNameFromChildScope(this, DisposalScope ?? DisposalScopeProvider.ProvideDisposalScope(this), name, extraData, consider, true); return(value != null); }
public List <T> LocateAll <T>(Type type = null, object extraData = null, ActivationStrategyFilter consider = null, IComparer <T> comparer = null) { throw new NotImplementedException(); }
/// <summary> /// Locate by name /// </summary> /// <param name="name"></param> /// <param name="extraData"></param> /// <param name="consider"></param> /// <returns></returns> public object LocateByName(string name, object extraData = null, ActivationStrategyFilter consider = null) { return(((IInjectionScope)this).LocateByNameFromChildScope(this, DisposalScope ?? DisposalScopeProvider.ProvideDisposalScope(this), name, extraData, consider, false)); }
public bool TryLocate(Type type, out object value, object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { throw new NotImplementedException(); }
public List <object> LocateAllByName(string name, object extraData = null, ActivationStrategyFilter consider = null) { throw new NotImplementedException(); }
public bool TryLocateByName(string name, out object value, object extraData = null, ActivationStrategyFilter consider = null) { throw new NotImplementedException(); }
private object DynamicArray(IExportLocatorScope scope, IDisposalScope disposalScope, Type type, ActivationStrategyFilter consider, IInjectionContext injectionContext) { if (InternalFieldStorage.DynamicArrayLocator == null) { Interlocked.CompareExchange(ref InternalFieldStorage.DynamicArrayLocator, ScopeConfiguration.Implementation.Locate <IDynamicArrayLocator>(), null); } return(InternalFieldStorage.DynamicArrayLocator.Locate(this, scope, disposalScope, type, consider, injectionContext)); }
/// <summary> /// Can Locator type /// </summary> /// <param name="type">type to locate</param> /// <param name="consider"></param> /// <param name="key">key to use while locating</param> /// <returns></returns> public bool CanLocate(Type type, ActivationStrategyFilter consider = null, object key = null) { return(InternalFieldStorage.CanLocateTypeService.CanLocate(this, type, consider, key)); }
public bool CanLocate(Type type, ActivationStrategyFilter consider = null, object key = null) { throw new NotImplementedException(); }
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())); } } }
/// <summary> /// Locate specific type using extra data or key /// </summary> /// <typeparam name="T">type to locate</typeparam> /// <param name="extraData">extra data</param> /// <param name="consider">filter out exports you don't want to consider</param> /// <param name="withKey">key to use during construction</param> /// <param name="isDynamic">skip cache and look at all strategies</param> /// <returns>located instance</returns> // ReSharper disable once MethodOverloadWithOptionalParameter public T Locate <T>(object extraData = null, ActivationStrategyFilter consider = null, object withKey = null, bool isDynamic = false) { return((T)Locate(typeof(T), extraData, consider, withKey, isDynamic)); }
/// <summary> /// Applies a filter to be used when resolving a parameter constructor /// It will be called each time the parameter is resolved /// </summary> /// <param name="filter">filter delegate to be used when resolving parameter</param> /// <returns>configuration object</returns> public IFluentWithCtorConfiguration Consider(ActivationStrategyFilter filter) { _constructorParameterInfo.ExportStrategyFilter = filter; return(this); }
/// <summary> /// Locate all of a specific type /// </summary> /// <typeparam name="T">type to locate</typeparam> /// <param name="type">type to locate</param> /// <param name="extraData">extra data to use during construction</param> /// <param name="consider">provide method to filter out exports</param> /// <param name="comparer">comparer to use for sorting</param> /// <returns>list of all located</returns> public List <T> LocateAll <T>(Type type = null, object extraData = null, ActivationStrategyFilter consider = null, IComparer <T> comparer = null) { return(((IInjectionScope)this).InternalLocateAll(this, DisposalScope ?? DisposalScopeProvider.ProvideDisposalScope(this), type ?? typeof(T), extraData, consider, comparer)); }