/// <summary>
/// Registers types found in the supplied assemblies into the Unity container.
/// </summary>
/// <param name="assemblyNames">The list of assembly names to register types from.</param>
/// <param name="behaviors">The behaviors to use to guide auto-mapping.</param>
public void RegisterAssemblies(MappingBehaviors behaviors, params String[] assemblyNames)
{
var types = assemblyNames.SelectMany(assemblyName => Assembly.Load(assemblyName).GetTypes())
.ToArray();
RegisterTypes(behaviors, types);
}
public RegistrationNameFactory(AutomapperConfig configurationDetails, IEnumerable <TypeMapping> typeMappings, MappingBehaviors mappingBehaviors)
{
this.mappingBehaviors = mappingBehaviors;
this.configurationDetails = configurationDetails;
multimapTypes = typeMappings
.GroupBy(t => t.From)
.Where(t => t.Count() > 1)
.Select(group => group.Key)
.ToArray();
}
public RegistrationNameFactory(AutomapperConfig configurationDetails, IEnumerable<TypeMapping> typeMappings, MappingBehaviors mappingBehaviors)
{
this.mappingBehaviors = mappingBehaviors;
this.configurationDetails = configurationDetails;
multimapTypes = typeMappings
.GroupBy(t => t.From)
.Where(t => t.Count() > 1)
.Select(group => group.Key)
.ToArray();
}
/// <summary>
/// Registers types into the Unity container.
/// </summary>
/// <param name="types">The array of interfaces and concretes to map up and register.</param>
/// <param name="behaviors">The behaviors to use to guide auto-mapping.</param>
public IEnumerable<ContainerRegistration> RegisterTypes(MappingBehaviors behaviors, params Type[] types)
{
var configurationDetails = GetConfigurationDetails(types);
var mappings = mappingFactory.CreateMappings(behaviors, configurationDetails, types);
var configParameter = new DependencyOverride<AutomapperConfig>(configurationDetails);
var mappingParameter = new DependencyOverride<IEnumerable<TypeMapping>>(mappings);
var behaviorParameter = new DependencyOverride<MappingBehaviors>(behaviors);
var containerParameter = new DependencyOverride<IUnityContainer>(target);
var mappingHandler = internalContainer.Resolve<ITypeMappingHandler>(configParameter, mappingParameter, behaviorParameter, containerParameter);
return mappingHandler.PerformRegistrations(target, mappings);
}
private static void PerformSmokeTest(MappingBehaviors behaviors)
{
Console.WriteLine();
using (var container = new UnityContainer())
{
using (new ColorSwitch(ConsoleColor.Yellow).AsDisposable())
using (new DisposableAdapter <InvertedColourSwitch>())
Console.WriteLine("Smoke testing using the following behaviors: {0}.", behaviors.ToString());
try
{
container.AutomapAssemblies(new MappingOptions {
Behaviors = behaviors
}, Assembly.GetExecutingAssembly().FullName, "ConfigProviderAssembly", "Lydian.Unity.Automapper.Test.TestAssembly", "Lydian.Unity.Automapper.Test.TestAssemblyTwo");
}
catch (Exception ex)
{
using (new ColorSwitch(ConsoleColor.Red).AsDisposable())
using (new DisposableAdapter <InvertedColourSwitch>())
{
Console.WriteLine("Failed during automapping phase: {0}.", ex.Message);
Console.WriteLine();
}
}
TestRegistration <ISimpleInterface>(container, "Non generic mapping");
TestRegistration <IMyGenericClass <Boolean, String> >(container, "Open generic mapping");
TestRegistration <IMyGenericClass <String, Int32> >(container, "First closed generic mapping");
TestRegistration <IMyGenericClass <Boolean, Object> >(container, "Second closed generic mapping");
TestRegistration <IMultimap>(container, "Multiple mappings", false);
if (behaviors.HasFlag(MappingBehaviors.CollectionRegistration))
{
TestRegistration <IEnumerable <IMultimap> >(container, "Multiple mappings ACR");
}
TestRegistration <ISingleMultimap>(container, "Single-instance multimaps", singleMapping: false);
if (behaviors.HasFlag(MappingBehaviors.CollectionRegistration))
{
TestRegistration <IEnumerable <ISingleMultimap> >(container, "Single-instance mappings ACR");
}
TestRegistration <INamedInterface>(container, "Named mapping", mappingName: "Test");
TestRegistration <SingletonInterface>(container, "Provider-based singleton mapping");
TestRegistration <MultimappingInterface>(container, "Provider-based multi-mapping", singleMapping: false);
TestRegistration <IDependencyInversionPrinciple>(container, "Decoupled DIP mapping");
TestPolicyRegistration(container);
}
}
/// <summary>
/// Registers types into the Unity container.
/// </summary>
/// <param name="types">The array of interfaces and concretes to map up and register.</param>
/// <param name="behaviors">The behaviors to use to guide auto-mapping.</param>
public IEnumerable <ContainerRegistration> RegisterTypes(MappingBehaviors behaviors, params Type[] types)
{
var configurationDetails = GetConfigurationDetails(types);
var mappings = mappingFactory.CreateMappings(behaviors, configurationDetails, types);
var configParameter = new DependencyOverride <AutomapperConfig>(configurationDetails);
var mappingParameter = new DependencyOverride <IEnumerable <TypeMapping> >(mappings);
var behaviorParameter = new DependencyOverride <MappingBehaviors>(behaviors);
var containerParameter = new DependencyOverride <IUnityContainer>(target);
var mappingHandler = internalContainer.Resolve <ITypeMappingHandler>(configParameter, mappingParameter, behaviorParameter, containerParameter);
return(mappingHandler.PerformRegistrations(target, mappings));
}
public IEnumerable<TypeMapping> CreateMappings(MappingBehaviors behaviors, AutomapperConfig configurationDetails, params Type[] types)
{
var results = from availableInterface in types.Where(type => type.IsInterface)
.Where(configurationDetails.IsMappable)
from concrete in types.Where(type => !type.IsInterface)
.Where(configurationDetails.IsMappable)
from concreteInterface in concrete.GetGenericallyOpenInterfaces()
.Where(ci => ci.Item1 == availableInterface)
let matchingPair = new { concrete, concreteInterface }
group matchingPair by matchingPair.concreteInterface.Item2 into mappingsForAnInterface
from mapping in mappingsForAnInterface
select new TypeMapping(mapping.concreteInterface.Item2, mapping.concrete);
if (!behaviors.HasFlag(MappingBehaviors.CollectionRegistration))
return results.ToArray();
return CreateAcrMappings(results, configurationDetails)
.Union(results)
.ToArray();
}
public IEnumerable <TypeMapping> CreateMappings(MappingBehaviors behaviors, AutomapperConfig configurationDetails, params Type[] types)
{
var results = from availableInterface in types.Where(type => type.IsInterface)
.Where(configurationDetails.IsMappable)
from concrete in types.Where(type => !type.IsInterface)
.Where(configurationDetails.IsMappable)
from concreteInterface in concrete.GetGenericallyOpenInterfaces()
.Where(ci => ci.Item1 == availableInterface)
let matchingPair = new { concrete, concreteInterface }
group matchingPair by matchingPair.concreteInterface.Item2 into mappingsForAnInterface
from mapping in mappingsForAnInterface
select new TypeMapping(mapping.concreteInterface.Item2, mapping.concrete);
if (!behaviors.HasFlag(MappingBehaviors.CollectionRegistration))
{
return(results.ToArray());
}
return(CreateAcrMappings(results, configurationDetails)
.Union(results)
.ToArray());
}
/// <summary>
/// Initializes a new instance of the MappingOptions class.
/// <param name="behaviors">Any custom behaviours to use when mapping.</param>
/// </summary>
public MappingOptions(MappingBehaviors behaviors)
{
Behaviors = behaviors;
}
/// <summary>
/// Initializes a new instance of the MappingOptions class.
/// <param name="behaviors">Any custom behaviours to use when mapping.</param>
/// </summary>
public MappingOptions(MappingBehaviors behaviors)
{
Behaviors = behaviors;
}
/// <summary>
/// Initializes a new instance of the TypeMappingValidator class.
/// </summary>
/// <param name="configurationDetails"></param>
/// <param name="target"></param>
/// <param name="behaviors"></param>
public TypeMappingValidator(AutomapperConfig configurationDetails, IUnityContainer target, MappingBehaviors behaviors)
{
this.target = target;
this.configurationDetails = configurationDetails;
this.mappingBehaviors = behaviors;
}
/// <summary>
/// Registers types found in the supplied assemblies into the Unity container.
/// </summary>
/// <param name="assemblyNames">The list of assembly names to register types from.</param>
/// <param name="behaviors">The behaviors to use to guide auto-mapping.</param>
public void RegisterAssemblies(MappingBehaviors behaviors, params String[] assemblyNames)
{
var types = assemblyNames.SelectMany(assemblyName => Assembly.Load(assemblyName).GetTypes())
.ToArray();
RegisterTypes(behaviors, types);
}
/// <summary>
/// Initializes a new instance of the TypeMappingValidator class.
/// </summary>
/// <param name="configurationDetails"></param>
/// <param name="target"></param>
/// <param name="behaviors"></param>
public TypeMappingValidator(AutomapperConfig configurationDetails, IUnityContainer target, MappingBehaviors behaviors)
{
this.target = target;
this.configurationDetails = configurationDetails;
this.mappingBehaviors = behaviors;
}
