Question

我有一个我想要映射到另一种类型列表的派生类型列表。每种派生类型都以不同的方式映射到新类型。

是否有任何模式可以在不转换每种类型的情况下执行此操作，并且将映射的逻辑保持在类型之外（在工厂中）。

这是一个例子，我想找到GetFlatSwitch的替代品，比如GetFlat：

class Program
  {
    static void Main(string[] args)
    {
      List<Base> list = new List<Base>() { new DerivedA() { A = "A" }, new DerivedB() { B = "B" }};

      List<Flat> flatList = list.Select(x => Factory.GetFlat(x)).ToList(); // not working
      List<Flat> switchFlatList = list.Select(x => Factory.GetFlatSwitch(x)).ToList(); // works, but casting each element
    }

    static class Factory
    {
      public static Flat GetFlat(Base baseObj)
      {
        return new Flat();
      }

      public static Flat GetFlat(DerivedA a)
      {
        return new Flat() { A = a.A };
      }

      public static Flat GetFlat(DerivedB b)
      {
        return new Flat() { B = b.B };
      }

      public static Flat GetFlatSwitch(Base baseObj)
      {
        switch (baseObj.MyType)
        {
          case MyTypeEnum.A:
            DerivedA a = baseObj as DerivedA;
            return new Flat() { A = a.A };
          case MyTypeEnum.B:
            DerivedB b = baseObj as DerivedB;
            return new Flat() { B = b.B };
          default:
            return new Flat();
        }
      }
    }

    enum MyTypeEnum
    {
      A, B
    }

    abstract class Base
    {
      public abstract MyTypeEnum MyType { get; }
    }

    class DerivedA : Base
    {
      public override MyTypeEnum MyType
      {
        get
        {
          return MyTypeEnum.A;
        }
      }
      public string A { get; set; }
    }

    class DerivedB : Base
    {
      public override MyTypeEnum MyType
      {
        get
        {
          return MyTypeEnum.B;
        }
      }
      public string B { get; set; }
    }

    class Flat
    {
      public string A { get; set; }

      public string B { get; set; }
    }
  }

Answer 1

而不是设计模式，似乎你需要像AutoMapper这样的东西：

AutoMapper是一个简单的小型库，用于欺骗性地解决问题复杂的问题 - 摆脱映射一个对象的代码另一个。这种类型的代码相当沉闷，写起来很无聊，所以为什么不为我们发明一个工具？

使用该库配置类型到类型的映射，以便调用方法将类型映射到其他类型（例如mapper.Map<A, B>(a, b)）。

设计模式将派生类型映射到新类型列表

1 个答案: