Object-to-Object Mapper. Nützlich wenn von einem DTO zu einem ViewModel und zurück gemapped werden müssen. Die beiden bekanntesten unter den reinen Object-to-Object Mappern im Vergleich,

1. Object-Object Mapper

2. Object-Object Mapper
- Nutzen des Object-Object Mapper
- Framework: AutoMapper
- Framework: ValueInjecter
- AutoMapper vs. ValueInjector

3. Nutzen des Object-Object Mapper
• Konvertierung von Objekt zu Objekt oder übertragen
von verschiedenen Objektstrukturen
• Vereinfacht eine Schichtentrennung. Behandlung der
Typenkonvertierung wird nur einmal definiert
• Reduktion von potentiellen Fehlerquellen bei der
Konvertierung von komplexen Objekten durch
Automatisierung
• Einfache und Komplexe Regeln zur Konvertierung
abbildbar
• Wartung, Erweiterung und Testbarkeit verbessern

4. AutoMapper
• Objekt-Objekt Mapping Standart-Konfiguration
• Property Zuordnung über Name
• Zuordnung Ziel Property Name = Quell Methode
• sClass.ZylinderCount() => tClass.ZylinderCount;
• SourceClass.GetXXX() => TargetClass.XXX;
• Zuordnung des Property durch PascalCase bei Complex-
Types:
• sClass.Engine.ModelNumber =>
tClass.EngineModelNumber;
• sClass.EngineModelNumber =>
tClass.Engine.ModelNumber
• Profile zur zentralen Verwaltung von Konfiguration
Mapper.Initialize<c => c.AddProfile<SampleProfile>())
• Behandlung von eigenen Transformationslogik
Mapping.Map<Employee,EmployeeService>().ForMember(d =>
d.Years, o => o.MapFrom(s => (DateTime.Now –
s.HireDate).TotalDays/365));
• Unterstützt Property-Ignorance configuration
Mapper.CreateMap<Employee, EmployeeStats>().ForMember(d
=> d.SickDaysUsed, o => o.Ignore());
Mapper.AsserConfigurationIsValid();
• Explizite Konfigurations-Fehlerbehandlung zur
Fehlerbehandlung/Debugging
Mapper.AssertConfigurationIsValid();
• Benutzung von eigenen Resolver zur Transformation von
Werten („Custom value resolver“)
Mapper.CreateMap<Employee, EmployeeService>().ForMember(d =>
d.Years, o => o.ResolveUsing<>earsOfServiceResolver>();
class YearsOfServiceResolver : ValueResolver<Employee, int>
{
protected override int ResolveCore(Employee source)
{
…
return (int) anyValue;
}
}
• Benutzung von eigenen Typen-Konvertern („Custom
type converters“) durch die Implementierung von
ITypeConverter<Tsource,Ttarget>
Mapper.CreateMap<double,DateTime().ConvertUsing<MyCustom
Converter>
• Pre- und Post Mapping Actions
Mapper.CreateMap<SelectedJob, Job().BeforeMap((s, d,)=>
..);
Mapper.CreateMap<SelectedJob, Job().AfterMap((s, d,)=>
..);
• Kontrolle ober die Instanziierung des Zielobjekts durch
Lambda oder Konfiguration
Mapper.CreateMap<Foo,Fighter>().ConstructUsing(s =>
factory.GetFighter()).ForMember(d => d.Id, o =>
o.Ignore()).ForMember(d => d.Type, o => o.MapFrom(s =>
„NINJA“));

5. ValueInjecter
• Statische Methode zum Mappen von und zu
einem Type
.InjectFrom<ConventionType>() oder .InjectFrom()
• Im einfachsten Fall mapped ValueInject den Property
des Zielobjektes mit dem gleichen Namen und Type.
Bsp.: string sClass.PropertyName => string
tClass.PropertyName
• Automatisches Mappen ohne Konfiguration
targetObject.InjectFrom(sourceObject);
• Gleichzeitiges Mapping mehrerer Objektinstanzen
targetObject.InjectFrom(source1,source2);
• Erweiterbarkeit der Mapping-Konvention
public class IdToType_Id : ConventionInjection
{
protected override bool Match(ConventionInfo c)
{
return c.SourceProp.Name==„Id“ && c.TargetProp.Name
== c.Source.Type.Name + „_Id“;
}
}
• Bereits vorhandene ConventionTypes
• ValueInjection
• LoopValueInjection
• LoopValueInjection<TSourceProperty, TTargetProperty>
• FlatLoopValueInjection
• FlatLoopValueInjection<TSourceProperty, TTargetProperty>
• UnflatLoopValueInjection
• UnflatLoopValueInjection<TSourceProperty, TTargetProperty>
• KnownSourceValueInjection<TSource>
• KnownTargetValueInjection<TTarget>
• BuiltIn Flattening und Unflattening-Unterstützung
(Auflösung und Erstellen von komplexen
Objektstrukturen)

6. AutoMapper vs. ValueInjecter
AutoMapper
• Eigene Transformationslogik möglich
• Custom Type Konverter
• Custom Value Resolver
• Ausdruck in Linq
• Pre- und Post-Action Methoden zu Vor- und
Nachbehandlung der Transformation
• Explizite Fehlerbehandlung von
Transformationsobjekten (z.B. fehlende Zuordnung von
Properties)
• Explizites ignorieren von Properties notwendig
• Methoden/Property Mapping
• Mapping von ComplexTypes durch PascalCasing
• Unterstützt auch das Mapping von instanziierten
Objekten
ValueInjecter
• Ohne eigene Convention wird nur gemapped wenn
Property Name und Type von Quelle und Ziel
identisch sind
• Erweiterung durch Ableitung von
ConventionInjectionTypes sehr flexibel
• Durch ConventionBased Injection sehr schnell
(teilweise doppelt so schnell als AutoMapper)
• Mapping von anonymous und dynamic types

7. Weiterführende Links zum Thema
• AutoMapper
https://github.com/AutoMapper
• ValueInjecter
http://valueinjecter.codeplex.com/
• Vorteile von ValueInjecter, erklärt vom Author von ValueInjecter
http://stackoverflow.com/questions/4663577/automapper-vs-valueinjecter
• Performance Benchmark AutoMapper
http://lostechies.com/jimmybogard/2009/08/05/analyzing-automapper-performance