13

我需要在我的应用程序中使用对象到对象映射器。我已经尝试了一些，但无法找到适合我需要的任何东西，所以我正在编写自己的。目前我有一个如下界面：

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

然后我实现了一个将客户映射到帐户的 AccountMapper：

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

到目前为止，这工作正常，但是我有几个映射到同一目标实体的源实体。例如，我有一个付款和一个发票，它们都映射到 BillHistory。为了上面的支持，我需要制作两个单独的映射器（即 BillHistoryPaymentMapper 和 BillHistoryInvoiceMapper），这很好。但是，我希望能够像下面这样稍微不同地实现它。唯一的问题是我不知道这是否可能，如果可能，我不知道正确的语法。

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

虽然第一个实现工作正常，但第二个会稍微优雅一些​​。这可能吗？如果可以，正确的语法会是什么样子？

编辑 - - - -

我讨厌人们这样做，但我当然忘了提一个小细节。我们在映射器和接口之间有一个抽象类，用于在所有映射器中实现一些通用逻辑。所以我的映射器签名实际上是：

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

其中 Mapper 包含：

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));
    }
}
4

4 回答 4

4

You'll have to use your first interface and implement the interface multiple times on your object:

public class BillHistoryMapper : IMapper<Account, Invoice>, 
                                 IMapper<Account, Payment> {     
   ...
}

I would serious consider taking a look at AutoMapper instead of writing your own. There are a lot of nuances in mapping that it has already solved, not to mention it has been through plenty of performance testing, bug fixes, etc.

于 2010-05-13T19:27:24.153 回答
1

关于您的抽象类，请考虑摆脱它并用扩展方法替换它。这将允许您使用该MapAll函数，无论您是实现接口还是使用某种继承链。

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

现在，这将使您在尝试解决上述问题时更容易，因为您不再需要从基类继承，您现在可以为要映射的类型实现映射接口。

public class BillHistoryMapper :
    IMapper<Invoice, BillHistory>, IMapper<Payment, BillHistory>
{
    public BillHistory Map<Invoice>(Invoice obj) {}
    public BillHistory Map<Payment>(Payment obj) {}
}

还可以考虑将您的IMapper通用参数更改为相反的方式（我在前面的示例中冒昧）：

public interface IMapper<in TInput, out TOutput>
{
    TOutput Map(TInput input);
}

这样做的原因是它直接映射到System.Converter<T>委托，您可以执行以下操作：

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 ，这将使您的生活更轻松。但是，如果您想保持映射抽象并使您的代码与映射策略无关，那么使用上述接口在 AutoMapper 周围注入包装器非常容易。这也意味着您可以继续使用上述MapAll扩展方法。

public class AutoMapperWrapper<in TInput, out TOutput> : IMapper<TInput, TOutput>
{
    public TOutput Map(TInput input)
    {
        return Mapper.Map<TOutput>(input);
    }
}

最后一句话

另外请记住，您并不总是会发现您的映射策略将全面发挥作用，因此不要试图与您的域抗争并强迫它适合您的映射策略。一个特定的示例是您可能必须将两个输入项映射为一个。您显然可以使这适合您的策略，但您可能会发现它变得混乱。在此特定示例中，将其视为合并。

于 2010-06-29T00:39:41.823 回答
0

If there is a limited number of types you want to map from, then I would use the first method of declaring the input and output types in the interface definition. Then a mapper can implement interfaces for each input type it supports, so your BillHistoryMapper would be declared as:

public class BillHistoryMapper : IMapper<BillHistory, Invoice>, IMapper<BillHistory, Payment>
{
   ...
}
于 2010-05-13T19:25:43.240 回答
0

您的第二个示例将仅进行一些更改：

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

不过，我不确定这是否真的能让你比现有模式有所收获。

于 2010-05-13T19:23:03.080 回答