/// <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 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; }