/// <summary> /// Create a new delegate for a given type /// </summary> /// <param name="scope">scope to use for creating</param> /// <param name="locateType">type to inject</param> /// <param name="request"></param> /// <param name="objectParameter"></param> /// <returns></returns> public IActivationExpressionResult CreateInjectionDelegate(IInjectionScope scope, Type locateType, IActivationExpressionRequest request, ParameterExpression objectParameter) { var strategy = new InjectionStrategy(locateType, scope); var result = scope.StrategyCompiler.CreateNewResult(request); var instanceValue = Expression.Variable(locateType); result.AddExtraParameter(instanceValue); result.AddExtraExpression(Expression.Assign(instanceValue, Expression.Convert(objectParameter, locateType))); var injectPropertyExpressions = CreatePropertyInjectionExpressions(scope, locateType, instanceValue, strategy, request); var injectMethodExpressions = CreateMethodInjectionExpressions(scope, locateType, instanceValue, strategy, request); foreach (var activationExpressionResult in injectPropertyExpressions) { result.AddExpressionResult(activationExpressionResult); } foreach (var activationExpressionResult in injectMethodExpressions) { result.AddExpressionResult(activationExpressionResult); } return(result); }
private GameObject InjectDependencies([NotNull] GameObject obj) { if (obj == null) { throw new ArgumentNullException(nameof(obj)); } InjectionStrategy.InjectDependencies <MonoBehaviour>(InjecteeLocator <MonoBehaviour> .Create(obj), ResolverService); return(obj); }
public GameObject Create([NotNull] GameObject prefab, Vector3 position, Quaternion rotation) { if (prefab == null) { throw new ArgumentNullException(nameof(prefab)); } GameObject obj = GameObject.Instantiate(prefab, position, rotation) as GameObject; //Decorate the current resolver with one that uses the contextual services IResolver resolver = new ContextualDependencyResolverDecorator(ResolverService, ServiceMap); //Inject using the decorated resolver InjectionStrategy.InjectDependencies <MonoBehaviour>(InjecteeLocator <MonoBehaviour> .Create(obj), resolver); return(obj); }
public TComponentType AddTo <TComponentType>([NotNull] GameObject gameObject) where TComponentType : MonoBehaviour { if (gameObject == null) { throw new ArgumentNullException(nameof(gameObject)); } TComponentType component = gameObject.AddComponent <TComponentType>(); //Decorate the current resolver with one that uses the contextual services IResolver resolver = new ContextualDependencyResolverDecorator(this.ResolverService, ServiceMap); //Inject using the decorated resolver InjectionStrategy.InjectDependencies <MonoBehaviour>(component, resolver); return(component); }
internal void SetInjectionStrategy(Type type, InjectionStrategy strategy) { injectionStrategyMap[type] = strategy; }
/// <summary> /// Sets the injection strategy for the aggregation function factory /// </summary> /// <param name="strategy">strategy</param> /// <returns>itself</returns> public AggregationFunctionModeManaged SetInjectionStrategyAggregationFunctionFactory(InjectionStrategy strategy) { InjectionStrategyAggregationFunctionFactory = strategy; return this; }
public AggregationMultiFunctionAgentModeManaged(InjectionStrategy injectionStrategyAggregationAgentFactory) { _injectionStrategyAggregationAgentFactory = injectionStrategyAggregationAgentFactory; }
/// <summary> /// Sets the injection strategy for the aggregation function factory /// </summary> /// <param name="strategy">strategy</param> /// <returns>itself</returns> public AggregationFunctionModeMultiParam SetInjectionStrategyAggregationFunctionFactory( InjectionStrategy strategy) { InjectionStrategyAggregationFunctionFactory = strategy; return this; }
public AggregationMultiFunctionAggregationMethodModeManaged(InjectionStrategy injectionStrategyAggregationMethodFactory) { this._injectionStrategyAggregationMethodFactory = injectionStrategyAggregationMethodFactory; }
public AggregationMultiFunctionStateModeManaged(InjectionStrategy injectionStrategyAggregationStateFactory) { InjectionStrategyAggregationStateFactory = injectionStrategyAggregationStateFactory; }
/// <summary> /// /// </summary> /// <param name="scope"></param> /// <param name="locateType"></param> /// <param name="instanceValue"></param> /// <param name="strategy"></param> /// <param name="request"></param> /// <returns></returns> protected virtual IEnumerable <IActivationExpressionResult> CreatePropertyInjectionExpressions(IInjectionScope scope, Type locateType, ParameterExpression instanceValue, InjectionStrategy strategy, IActivationExpressionRequest request) { var properties = new Dictionary <string, bool>(); foreach (var property in locateType.GetRuntimeProperties()) { if (!property.CanWrite || !property.SetMethod.IsPublic || property.SetMethod.IsStatic) { continue; } var attribute = property.GetCustomAttributes(true).FirstOrDefault(a => a is IImportAttribute) as IImportAttribute; var importInfo = attribute?.ProvideImportInfo(property.PropertyType, property.Name); if (importInfo == null) { continue; } yield return(CreatePropertyImportStatement(scope, locateType, instanceValue, strategy, request, property, importInfo)); properties[property.Name] = true; } var currentScope = scope; while (currentScope != null) { foreach (var selector in currentScope.MemberInjectionSelectors) { foreach (var propertyMember in selector.GetPropertiesAndFields(locateType, scope, request)) { if (properties.ContainsKey(propertyMember.MemberInfo.Name)) { continue; } properties[propertyMember.MemberInfo.Name] = true; } } currentScope = currentScope.Parent as IInjectionScope; } }
/// <summary> /// /// </summary> /// <param name="scope"></param> /// <param name="locateType"></param> /// <param name="instanceValue"></param> /// <param name="strategy"></param> /// <param name="request"></param> /// <param name="method"></param> /// <param name="importInfo"></param> /// <returns></returns> protected virtual IActivationExpressionResult CreateMethodInjectionExpression(IInjectionScope scope, Type locateType, ParameterExpression instanceValue, InjectionStrategy strategy, IActivationExpressionRequest request, MethodInfo method, ImportAttributeInfo importInfo) { var expressionResult = scope.StrategyCompiler.CreateNewResult(request); var list = new List <IActivationExpressionResult>(); foreach (var parameter in method.GetParameters()) { var parameterRequest = request.NewRequest(parameter.ParameterType, strategy, locateType, RequestType.MethodParameter, parameter, false, true); if (scope.ScopeConfiguration.Behaviors.KeyedTypeSelector(parameter.ParameterType)) { parameterRequest.SetLocateKey(parameter.Name); } var result = request.Services.ExpressionBuilder.GetActivationExpression(scope, parameterRequest); list.Add(result); expressionResult.AddExpressionResult(result); } var callExpression = Expression.Call(instanceValue, method, list.Select(result => result.Expression)); expressionResult.AddExtraExpression(callExpression); return(expressionResult); }
/// <summary> /// /// </summary> /// <param name="scope"></param> /// <param name="locateType"></param> /// <param name="instanceValue"></param> /// <param name="strategy"></param> /// <param name="request"></param> /// <returns></returns> protected virtual IEnumerable <IActivationExpressionResult> CreateMethodInjectionExpressions(IInjectionScope scope, Type locateType, ParameterExpression instanceValue, InjectionStrategy strategy, IActivationExpressionRequest request) { foreach (var method in locateType.GetRuntimeMethods()) { if (!method.IsPublic || method.IsStatic) { continue; } var importAttribute = method.GetCustomAttributes(true).FirstOrDefault(a => a is IImportAttribute) as IImportAttribute; var importInfo = importAttribute?.ProvideImportInfo(null, method.Name); if (importInfo != null) { yield return (CreateMethodInjectionExpression(scope, locateType, instanceValue, strategy, request, method, importInfo)); } } }
private static IActivationExpressionResult CreatePropertyImportStatement(IInjectionScope scope, Type locateType, ParameterExpression instanceValue, InjectionStrategy strategy, IActivationExpressionRequest request, PropertyInfo property, ImportAttributeInfo importInfo) { var propertyRequest = request.NewRequest(property.PropertyType, strategy, locateType, RequestType.Member, property, false, true); propertyRequest.SetIsRequired(importInfo.IsRequired); propertyRequest.SetEnumerableComparer(importInfo.Comparer); if (importInfo.ImportKey != null) { propertyRequest.SetLocateKey(importInfo.ImportKey); } else if (scope.ScopeConfiguration.Behaviors.KeyedTypeSelector(property.PropertyType)) { propertyRequest.SetLocateKey(property.Name); } var result = request.Services.ExpressionBuilder.GetActivationExpression(scope, propertyRequest); var setExpression = Expression.Assign(Expression.Property(instanceValue, property.SetMethod), result.Expression); result.AddExtraExpression(setExpression); result.Expression = null; return(result); }
public AggregationFunctionModeManaged(InjectionStrategy injectionStrategyAggregationFunctionFactory) { InjectionStrategyAggregationFunctionFactory = injectionStrategyAggregationFunctionFactory; }
public AggregationMultiFunctionAccessorModeManaged(InjectionStrategy injectionStrategyAggregationAccessorFactory) { this._injectionStrategyAggregationAccessorFactory = injectionStrategyAggregationAccessorFactory; }