C# - Generika-basierten Objekt-zu-Objekt-mapper Frage

Habe ich die Notwendigkeit einer Objekt-zu-Objekt-mapper in meiner Anwendung. Ich habe versucht ein paar, aber nicht in der Lage, etwas zu finden, das passt zu meinen Bedürfnissen, also Schreibe ich meine eigenen. Derzeit habe ich eine Schnittstelle wie unten:

public interface IMapper<T, R> {
    T Map(R obj);
}

Ich dann implementieren eine AccountMapper, dass die Karten ein Kunde auf ein Konto wie:

public class AccountMapper : IMapper<Account, Customer> {
    Account Map(Customer obj) {
        //mapping code
    }
}

Dieser funktioniert so weit, aber ich habe mehrere Quell-Entitäten, die Karte, um die gleiche Ziel-Entität. Zum Beispiel habe ich eine Zahlung und eine Rechnung, dass beide anzeigen zu BillHistory. Für die oben genannten, um diese Unterstützung, die ich brauche, um zwei separate Mappern (zB. BillHistoryPaymentMapper und BillHistoryInvoiceMapper), was in Ordnung ist. Allerdings, ich würde lieben im Stande zu sein es zu implementieren, etwas anders wie unten. Problem ist nur ich weiß nicht, ob es möglich ist und wenn ja, weiß ich nicht die korrekte syntax.

public interface IMapper<T> {
    T Map<R>(R obj);
}

public class BillHistoryMapper : IMapper<Account> {
    public BillHistory Map<Invoice>(Invoice obj) {
        //mapping code
    }
    public BillHistory Map<Payment>(Payment obj) {
        //mapping code
    }
}

Während der ersten Umsetzung funktioniert gut, die zweite wäre etwas eleganter. Ist das möglich und wenn ja, was wäre die richtige syntax Aussehen?

Bearbeiten-------

Ich hasse es, wenn Menschen dies tun, aber natürlich habe ich vergessen zu erwähnen, ein kleines detail. Wir haben eine abstrakte Klasse, die zwischen dem mapper und die Schnittstelle zu implementieren, die einige gemeinsame Logik für alle Mapper. Also mein mapper Signatur ist eigentlich:

public class BillHistoryMapper : Mapper<BillHistory, Invoice> {
}

wo Mapper enthält:

public abstract class Mapper<T, R> : IMapper<T, R> {
    public IList<T> Map(IList<R> objList) {
        return objList.ToList<R>().ConvertAll<T>(new Converter<T, R>(Map));
    }
}

InformationsquelleAutor Brian | 2010-05-13

c#generics mapper

4

Müssen Sie Ihre erste Schnittstelle und die Schnittstelle implementieren, mehrere Male auf das Objekt:
```
public class BillHistoryMapper : IMapper<Account, Invoice>, 
                                 IMapper<Account, Payment> {     
   ...
}
```
Ich würde ernsthaft erwägen Sie einen Blick auf AutoMapper statt zu schreiben Ihre eigenen. Es gibt eine Menge von Nuancen in der Zuordnung, dass es bereits gelöst, nicht zu erwähnen, es wurde durch zahlreiche performance-Tests, bug-fixes, etc.
- siehe edit oben, - code nicht korrekt im Kommentar
- Sie code implementieren, die Ihre Map-Methode als eine Erweiterung der Methode auf die IMapper-Schnittstelle. So dass Sie nicht haben, um die Verwendung einer abstrakten Basisklasse.
- Ich habe markiert diese als die Antwort b/c, es beantwortet meine ursprüngliche Frage. Ich war auch in der Lage, dies zu erreichen, ohne eine abstrakte Klasse mit Eric ' s Vorschlag. Danke!!!
InformationsquelleAutor Eric Hauser
1

Hinblick auf Ihre abstrakte Klasse erwägen, entfernen Sie es und ersetzen Sie es mit einer extension-Methode. Dies ermöglicht Ihnen die Nutzung der MapAll Funktion, unabhängig davon, ob Sie die Schnittstelle implementieren, oder verwenden Sie eine Art von Vererbung Kette.
```
public static class MapperExtensions
{
    public static IEnumerable<TOutput> MapAll<TInput, TOutput>
        (this IMapper<TInput, TOutput> mapper, IEnumerable<TInput> input)
    {
        return input.Select(x => mapper.Map(x));
    }
}
```
Dieser wird nun machen es einfacher, wenn Sie versuchen, Ihr problem zu lösen über, da Sie nicht mehr zu Erben von einer Basisklasse können Sie nun die Umsetzung der mapping-Schnittstelle für die Typen, die Sie zuordnen möchten.
```
public class BillHistoryMapper :
    IMapper<Invoice, BillHistory>, IMapper<Payment, BillHistory>
{
    public BillHistory Map<Invoice>(Invoice obj) {}
    public BillHistory Map<Payment>(Payment obj) {}
}
```
Auch in Erwägung ziehen, Ihren IMapper generischen Parameter, die für den anderen Weg (ich nahm mir die Freiheit in den vorherigen Beispielen):
```
public interface IMapper<in TInput, out TOutput>
{
    TOutput Map(TInput input);
}
```
Der Grund dafür ist, dass es direkt Karten für die System.Konverter<T> delegieren und Sie können etwas tun:
```
IMapper<ObjectA, ObjectB> myAToBMapper = new MyAToBMapper();

ObjectA[] aArray = { new ObjectA(), new ObjectA() };
ObjectB[] bArray = Array.ConvertAll<ObjectA, ObjectB>(aArray, myAToBMapper.Map);

List<ObjectA> aList = new List<ObjectA> { new ObjectA(), new ObjectA() };
List<ObjectB> bList = aList.ConvertAll<ObjectB>(myAToBMapper.Map);

//Or

var aToBConverter = new Converter<ObjectA, ObjectB>(myAToBMapper.Map);
bArray = Array.ConvertAll(aArray, aToBConverter);
bList = aList.ConvertAll(aToBConverter);
```
AutoMapper wurde auch vorgeschlagen, die Ihr Leben einfacher machen wird. Allerdings, wenn Sie wollen, um halten Sie Ihre mapping Abstraktion und haben Ihren code Agnostiker zu Ihren mapping-Strategie, dann ist es sehr einfach, um die obige Schnittstelle zu Spritzen, ein wrapper um AutoMapper. Es wird auch bedeuten Sie können weiterhin verwenden, die MapAll extension-Methode (siehe oben).
```
public class AutoMapperWrapper<in TInput, out TOutput> : IMapper<TInput, TOutput>
{
    public TOutput Map(TInput input)
    {
        return Mapper.Map<TOutput>(input);
    }
}
```
Letzte Wort

Halten Sie auch im Verstand, den Sie sind nicht immer zu finden, die zu Ihren mapping-Strategie wird die Arbeit auf dem Brett, so versuchen Sie nicht zu kämpfen Ihre domain und Kraft, um fit in Ihrer mapping-Strategie. Ein besonderes Beispiel ist Sie haben könnten, um anzeigen von zwei input-Elemente in einem. Sie können offensichtlich machen diese passen Ihre Strategie aber Sie können finden, wird es chaotisch. In diesem bestimmten Beispiel betrachten Sie es als eine Zusammenführen.

InformationsquelleAutor Bronumski

Ihrem zweiten Beispiel wird die Arbeit mit nur ein paar änderungen:

//you have to include the R type in the declaration of the Mapper interface
public interface IMapper<T, R> {
    T Map<R>(R obj);
}

//You have to specify both IMapper implementations in the declaration
public class BillHistoryMapper : IMapper<Account, Invoice>, IMapper<Account, Payment> {
    public BillHistory Map<Invoice>(Invoice obj) {
        //mapping code
    }
    public BillHistory Map<Payment>(Payment obj) {
        //mapping code
    }
}

Ich bin mir nicht sicher, ob dies tatsächlich gewinnt Sie nichts über das vorhandene Muster.

InformationsquelleAutor JSBձոգչ

0

Wenn es nur eine begrenzte Anzahl von Typen, die Sie zuordnen möchten, aus, dann würde ich die erste Methode verwenden, deklarieren Sie die input-und output-Arten in der interface-definition. Dann ein mapper können Schnittstellen implementieren, die für jede Eingabe, geben Sie Sie unterstützt, so Ihre BillHistoryMapper würde deklariert werden als:
```
public class BillHistoryMapper : IMapper<BillHistory, Invoice>, IMapper<BillHistory, Payment>
{
   ...
}
```
InformationsquelleAutor Lee

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.