public void FluentDecoratorWithCtor_IsDynamic([Freeze] ConstructorParameterInfo constructorParameterInfo,
FluentDecoratorWithCtorConfiguration <int> configuration)
{
configuration.IsDynamic();
Assert.True(constructorParameterInfo.IsDynamic);
}
public void FluentDecoratorWithCtor_Named([Freeze] ConstructorParameterInfo constructorParameterInfo,
FluentDecoratorWithCtorConfiguration <int> configuration)
{
configuration.Named("Test");
Assert.Equal("Test", constructorParameterInfo.ParameterName);
}
/// <summary>
/// Get a list of expressions for the parameters in a constructor
/// </summary>
/// <param name="injectionScope">injection scope</param>
/// <param name="configuration">configuration for strategy</param>
/// <param name="request">request</param>
/// <param name="constructor">constructor</param>
/// <returns></returns>
protected virtual List <IActivationExpressionResult> GetParameterExpressionsForConstructor(
IInjectionScope injectionScope, TypeActivationConfiguration configuration, IActivationExpressionRequest request,
ConstructorInfo constructor)
{
var returnList = new List <IActivationExpressionResult>();
foreach (var parameter in constructor.GetParameters())
{
ConstructorParameterInfo parameterInfo = null;
if (!ReferenceEquals(configuration.ConstructorParameters, ImmutableLinkedList <ConstructorParameterInfo> .Empty))
{
parameterInfo = FindParameterInfoExpression(parameter, configuration);
}
if (parameterInfo == null &&
injectionScope.ScopeConfiguration.Behaviors.ProcessImportAttributeForParameters)
{
parameterInfo = ProcessImportAttributes(parameter);
}
var expression = GetParameterExpression(parameter, parameterInfo, injectionScope, configuration, request, out var newRequest);
expression = OverrideExpression(injectionScope, configuration, newRequest, constructor, expression);
returnList.Add(expression);
}
return(returnList);
}
private static void SetDefaultValue(ParameterInfo parameter, ConstructorParameterInfo parameterInfo,
IActivationExpressionRequest newRequest)
{
try
{
if (parameterInfo?.DefaultValue != null)
{
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = parameterInfo.DefaultValue
});
}
else if (parameter.HasDefaultValue)
{
var defaultValue = parameter.DefaultValue;
if (defaultValue == null &&
parameter.ParameterType.GetTypeInfo().IsValueType)
{
defaultValue = Activator.CreateInstance(parameter.ParameterType);
}
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = defaultValue
});
}
}
catch (FormatException) when(parameter.ParameterType == typeof(DateTime))
{
newRequest.SetDefaultValue(new DefaultValueInformation {
DefaultValue = default(DateTime)
});
}
}
public void FluentDecoratorWithCtor_When([Freeze] ConstructorParameterInfo constructorParameterInfo,
[Freeze] IFluentDecoratorStrategyConfiguration strategyConfiguration,
FluentDecoratorWithCtorConfiguration <int> configuration)
{
configuration.When.InjectedInto <BasicService>();
strategyConfiguration.Received().When.InjectedInto <BasicService>();
}
public void FluentDecoratorWithCtor_IsRequired([Freeze] ConstructorParameterInfo constructorParameterInfo,
FluentDecoratorWithCtorConfiguration <int> configuration)
{
configuration.IsRequired(false);
Assert.True(constructorParameterInfo.IsRequired.HasValue);
Assert.False(constructorParameterInfo.IsRequired.GetValueOrDefault(true));
}
public void FluentDecoratorWithCtor_Use([Freeze] ConstructorParameterInfo constructorParameterInfo,
FluentDecoratorWithCtorConfiguration <int> configuration)
{
constructorParameterInfo.UseType = null;
configuration.Use(typeof(int));
Assert.Equal(typeof(int), constructorParameterInfo.UseType);
}
public void FluentDecoratorWithCtor_Consider([Freeze] ConstructorParameterInfo constructorParameterInfo,
FluentDecoratorWithCtorConfiguration <int> configuration)
{
ActivationStrategyFilter filter = strategy => true;
configuration.Consider(filter);
Assert.Same(filter, constructorParameterInfo.ExportStrategyFilter);
}
private void InitParameters(ConstructorInfo constructor)
{
var originals = constructor.GetParameters();
var prms = new List <ConstructorParameterInfo>(originals.Length);
foreach (var original in originals)
{
var prm = new ConstructorParameterInfo(this, original);
prms.Add(prm);
}
this.Parameters = prms;
}
/// <summary>
/// Get a list of expressions for the parameters in a constructor
/// </summary>
/// <param name="injectionScope">injection scope</param>
/// <param name="configuration">configuration for strategy</param>
/// <param name="request">request</param>
/// <param name="constructor">constructor</param>
/// <returns></returns>
protected virtual List <IActivationExpressionResult> GetParameterExpressionsForConstructor(
IInjectionScope injectionScope, TypeActivationConfiguration configuration, IActivationExpressionRequest request,
ConstructorInfo constructor)
{
var returnList = new List <IActivationExpressionResult>();
foreach (var parameter in constructor.GetParameters())
{
ConstructorParameterInfo parameterInfo = null;
if (!ReferenceEquals(configuration.ConstructorParameters, ImmutableLinkedList <ConstructorParameterInfo> .Empty))
{
parameterInfo = FindParameterInfoExpression(parameter, configuration);
}
var expression = GetParameterExpression(parameter, parameterInfo, injectionScope, configuration, request);
returnList.Add(expression);
}
return(returnList);
}
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>
/// 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));
}
/// <summary>
/// Constructor parameter
/// </summary>
/// <param name="info"></param>
public void ConstructorParameter(ConstructorParameterInfo info)
{
ActivationConfiguration.ConstructorParameter(info);
}
