private void ProcessClassAttributes(IConfigurableActivationStrategy strategy)
{
foreach (var attribute in strategy.ActivationType.GetTypeInfo().GetCustomAttributes())
{
var exportAttribute = attribute as IExportAttribute;
var types = exportAttribute?.ProvideExportTypes(strategy.ActivationType);
if (types != null)
{
foreach (var type in types)
{
strategy.AddExportAs(type);
}
}
var conditionAttribute = attribute as IExportConditionAttribute;
var condition = conditionAttribute?.ProvideCondition(strategy.ActivationType);
if (condition != null)
{
strategy.AddCondition(condition);
}
var keyedTypeAttribute = attribute as IExportKeyedTypeAttribute;
var tuple = keyedTypeAttribute?.ProvideKey(strategy.ActivationType);
if (tuple != null)
{
strategy.AddExportAsKeyed(tuple.Item1, tuple.Item2);
}
}
}
public void ConfigurableActivationStrategyDebuggerView_HasConditions(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy)
{
strategy.HasConditions.Returns(true);
Assert.True(debuggerView.HasConditions);
}
private void ProcessProperties(IConfigurableActivationStrategy strategy)
{
foreach (var propertyInfo in strategy.ActivationType.GetRuntimeProperties())
{
if (!propertyInfo.CanWrite ||
!propertyInfo.SetMethod.IsPublic ||
propertyInfo.SetMethod.IsStatic)
{
continue;
}
foreach (var attribute in propertyInfo.GetCustomAttributes())
{
var importAttr = attribute as IImportAttribute;
var importInfo = importAttr?.ProvideImportInfo(strategy.ActivationType, propertyInfo.Name);
if (importInfo != null)
{
var name = propertyInfo.Name;
strategy.MemberInjectionSelector(new PropertyFieldInjectionSelector(propertyInfo.PropertyType, m => m.Name == name, false)
{
IsRequired = importInfo.IsRequired, LocateKey = importInfo.ImportKey
});
}
}
}
}
public void ConfigurableActivationStrategyDebuggerView_Priority(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy)
{
strategy.Priority.Returns(10);
Assert.Equal(10, debuggerView.Priority);
}
private void ProcessFields(IConfigurableActivationStrategy strategy)
{
foreach (var fieldInfo in strategy.ActivationType.GetRuntimeFields())
{
if (!fieldInfo.IsPublic || fieldInfo.IsStatic)
{
continue;
}
foreach (var attribute in fieldInfo.GetCustomAttributes())
{
var importAttr = attribute as IImportAttribute;
var importInfo = importAttr?.ProvideImportInfo(strategy.ActivationType, fieldInfo.Name);
if (importInfo != null)
{
var name = fieldInfo.Name;
strategy.MemberInjectionSelector(new PropertyFieldInjectionSelector(fieldInfo.FieldType, info => info.Name == name, false)
{
IsRequired = importInfo.IsRequired, LocateKey = importInfo.ImportKey
});
}
}
}
}
public void ConfigurableActivationStrategyDebuggerView_ExternallyOwned(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy)
{
strategy.ExternallyOwned.Returns(true);
Assert.True(debuggerView.ExternallyOwned);
}
public void ConfigurableActivationStrategyDebuggerView_ActivationType(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy)
{
strategy.ActivationType.Returns(typeof(IBasicService));
Assert.Equal(typeof(IBasicService), debuggerView.ActivationType);
}
public void ConfigurableActivationStrategyDebuggerView_Dependencies(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy)
{
strategy.GetDependencies().Returns(new List <ActivationStrategyDependency> {
});
Assert.False(debuggerView.Dependencies.Any());
}
public void ConfigurableActivationStrategyDebuggerView_Metadata(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy,
IActivationStrategyMetadata metadata)
{
strategy.Metadata.Returns(metadata);
Assert.Same(metadata, debuggerView.Metadata);
}
public void ConfigurableActivationStrategyDebuggerView_Lifestyle(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy,
ICompiledLifestyle lifestyle)
{
strategy.Lifestyle.Returns(lifestyle);
Assert.Same(lifestyle, debuggerView.Lifestyle);
}
/// <summary>
/// Process attribute on strategy
/// </summary>
/// <param name="strategy">activation strategy</param>
public void ProcessAttributeForConfigurableActivationStrategy(IConfigurableActivationStrategy strategy)
{
ProcessClassAttributes(strategy);
ProcessFields(strategy);
ProcessProperties(strategy);
ProcessMethods(strategy);
}
public void ConfigurableActivationStrategyDebuggerView_ExportAs(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy)
{
strategy.ExportAs.Returns(new[] { typeof(ISimpleObject), typeof(IBasicService) });
var exports = debuggerView.ExportAs.ToArray();
Assert.Equal(2, exports.Length);
Assert.Equal(typeof(IBasicService), exports[0]);
Assert.Equal(typeof(ISimpleObject), exports[1]);
}
public void ConfigurableActivationStrategyDebuggerView_ExportAsKeyed(ConfigurableActivationStrategyDebuggerView debuggerView,
IConfigurableActivationStrategy strategy)
{
strategy.ExportAsKeyed.Returns(new[]
{
new KeyValuePair <Type, object>(typeof(ISimpleObject), "Hello"),
new KeyValuePair <Type, object>(typeof(IBasicService), "World")
});
var exports = debuggerView.ExportAsKeyed.ToArray();
Assert.Equal(2, exports.Length);
Assert.Equal(typeof(IBasicService), exports[0].Key);
Assert.Equal(typeof(ISimpleObject), exports[1].Key);
}
private void ProcessMethods(IConfigurableActivationStrategy strategy)
{
foreach (var methodInfo in strategy.ActivationType.GetRuntimeMethods())
{
if (!methodInfo.IsPublic || methodInfo.IsStatic)
{
continue;
}
foreach (var attribute in methodInfo.GetCustomAttributes())
{
var importAttribute = attribute as IImportAttribute;
var importInfo = importAttribute?.ProvideImportInfo(strategy.ActivationType, methodInfo.Name);
if (importInfo != null)
{
strategy.MethodInjectionInfo(new MethodInjectionInfo {
Method = methodInfo
});
}
}
}
}
private void ProcessConstructors(IConfigurableActivationStrategy strategy)
{
foreach (var constructorInfo in strategy.ActivationType.GetTypeInfo().DeclaredConstructors)
{
if (constructorInfo.IsPublic)
{
foreach (var customAttribute in constructorInfo.GetCustomAttributes())
{
if (customAttribute is IImportAttribute importAttribute)
{
var importInfo = importAttribute.ProvideImportInfo(strategy.ActivationType,
strategy.ActivationType.Name);
if (importInfo != null)
{
strategy.SelectedConstructor = constructorInfo;
break;
}
}
}
}
}
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="configurableActivationStrategy"></param>
public ConfigurableActivationStrategyDebuggerView(IConfigurableActivationStrategy configurableActivationStrategy)
{
_configurableActivationStrategy = configurableActivationStrategy;
}
/// <summary>
/// Process attributes on type and configure strategy based on attributes
/// </summary>
/// <param name="strategy">strategy</param>
/// <returns></returns>
public static IConfigurableActivationStrategy ProcessAttributeForStrategy(this IConfigurableActivationStrategy strategy)
{
strategy.InjectionScope.ScopeConfiguration.Implementation.Locate <IActivationStrategyAttributeProcessor>().ProcessAttributeForConfigurableActivationStrategy(strategy);
return(strategy);
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="exportConfiguration"></param>
public FluentExportStrategyConfiguration(IConfigurableActivationStrategy exportConfiguration)
{
_exportConfiguration = exportConfiguration;
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="exportConfiguration"></param>
public FluentExportStrategyConfiguration(IConfigurableActivationStrategy exportConfiguration, IExportRegistrationBlock registrationBlock)
{
_exportConfiguration = exportConfiguration;
_registrationBlock = registrationBlock;
}
