根据另一个指定的通用类型推断通用类型并使用它

Question

首先，我想指出的是，我已经有了一个可行的解决方案，但是我试图看看是否有一种方法可以使代码更简洁，更省力。

这是我的情况。 实际上，我已经简化了情况，并创建了一个伪造的示例以使插图清楚。 我将要提出一个具体的示例，说明我已经完成的工作，并且它可以工作。

假设我们有这些类：

public abstract class Shape{ //...elided... }
public class Square : Shape { //...elided... }
public class Circle : Shape { //...elided... }

并假设有一种类可以像这样对他们进行处理：

public class ShapeThingy
{
     public static void MakeSquaresDance(List<Squares> squares){ //...elided... }
     public static void RollCircles(List<Circles> circles){ //...elided... }
}

现在假设我要测试ShapeThingy类。 假设对于某些测试，我想将MockSquares和MockCircles替换为列表，以代替Squares和Circles。 另外，假设设置MockCircles和MockSquares非常相似，因此我想要一种方法来创建模拟形状的列表，然后告诉该方法我需要的形状类型。 这是我的实现方式：

public class Tests
{
      [Test]
      public void TestDancingSquares()
      {
          List<Squares> mockSquares = GetMockShapes<Square, MockSquare>();
          ShapeThingy.MakeSquaresDance(mockSquares);

          Assert.Something();
      }

      [Test]
      public void TestRollingCircles()
      {
          List<Circles> mockCircles = GetMockShapes<Circle, MockCircle>();
          ShapeThingy.RollCircles(mockCircles );

          Assert.Something();
      }


      private List<TBase> GetMockShapes<TBase, TMock>()
         where TBase : Shape
         where TMock : TBase, new()
      {
         List<TBase> mockShapes = new List<TBase>();

         for (int i = 0; i < 5; i++)
         {
            mockShapes.Add(MockShapeFactory.CreateMockShape<TMock>());
         }
      }

}

public class MockSquare : Square { //...elided... }
public class MockCircle : Circle { //...elided... }

public class MockShapeFactory
{
    public static T CreateMockShape<T>()
        where T : Shape, new()
    {
        T mockShape = new T();
        //do some kind of set up
        return mockShape;
    }
}

现在可以正常工作了。 我遇到的问题是，您已经为GetMockShapes（）指定了列表的期望输出类型和实际上希望列表包含的模拟类型。 实际上，我已经知道，如果我向GetMockShapes（）请求List <Square>，则实际上应该用MockSquare填充它。 必须一遍又一遍地指定事物，这有点麻烦。

我想做的是这样的：

      private List<TBase> GetMockShapes<TBase>()
         where TBase : Shape
      {
         List<TBase> mockShapes = new List<TBase>();

         Type mockType = getAppropriateMockType<TBase>();

         for (int i = 0; i < 5; i++)
         {
            //compiler error: typeof(mockType) doesn't work here
            mockShapes.Add(MockShapeFactory.CreateMockShape<typeof(mockType)>());
         }
      }

      private Type getAppropriateMockType<TBase>()
      {
         if(typeof(TBase).Equals(typeof(Square)))
         {
            return typeof(MockSquare);
         }

         if(typeof(TBase).Equals(typeof(Circle)))
         {
            return typeof(MockCircle);
         }

         //else
         throw new ArgumentException(typeof(TBase).ToString() + " cannot be converted to a mock shape type.");
      }

      //add then a test would look like this
      //(one less word, one less chance to screw up)
      [Test]
      public void TestDancingSquares()
      {
          List<Squares> mockSquares = GetMockShapes<Square>();
          ShapeThingy.MakeSquaresDance(mockSquares);

          Assert.Something();
      }

问题在于该版本无法编译，我无法找到解决该问题的方法。 也许我想做的事是不可能的。

现在，您可能会想，“如果他只是使用IEnumerable <T>而不是List <T>，那么他可以利用C＃4.0中的协方差，而不必进行任何此类废话，”是正确的，但是在我们的实际代码中，我们没有使用List <T>，而是使用了自定义的具体类型Something <T>（并且它不是IEnumerable样式的集合），而我没有能力更改Something <T>的用法并立即引入协变接口ISomething <out T>。

无论如何，我想我想做的就是设法避免每次调用GetMockShapes（）时都必须键入一个额外的单词，所以这没什么大不了的，而且我不知道，也许两者都很好指定了类型，因此很容易看到。 我只是认为，如果我能找到某种方法可以做到这一点，那就太好了，而且我也会学到新的东西。 我主要想知道这是否可以满足我的好奇心。 我认为就代码质量而言，它并不那么重要。

Answer 1

我不确定这是做事的好方法，但是我得到了GetMockShapes方法，可以按照您想要的方式工作。 这个想法是从MockShapeFactory开始，获取其CreateMockShape方法，将其转换为适当的通用版本，然后调用它以创建正确类型的对象。

不过，这会获得一个object ，并且mockShapes的Add方法仅接受正确键入的Shape 。 我不知道如何将新的mockShape动态mockShape为适当的类型。 我认为，那样可以避免通过反射调用构建器的需要。

我绕过了类型检查系统（就像我说的，“不确定这是做事的好方法”）。 我从mockShapes列表开始， mockShapes其运行时类型，获取其Add方法，然后使用新创建的对象对其进行调用。 编译器期望该方法使用对象，并允许该对象。 反射在运行时强制进行正确的键入。 如果GetAppropriateMockType返回错误的类型，则可能会发生不好的事情。

using System.Collections.Generic;
using System.Reflection;
using System;

private List<TBase> GetMockShapes<TBase>()
     where TBase : Shape
{
    Type TMock = getAppropriateMockType<TBase>();

    // Sanity check -- if this fails, bad things might happen.
    Assert(typeof(TBase).IsAssignableFrom(TMock));

    List<TBase> mockShapes = new List<TBase>();

    // Find MockShapeFactory.CreateMockShape() method
    MethodInfo shapeCreator = typeof(MockShapeFactory).GetMethod("CreateMockShape");

    // Convert to CreateMockShape<TMock>() method
    shapeCreator = shapeCreator.MakeGenericMethod(new Type[] { TMock });

    for (int i = 0; i < 5; i++)
    {
        // Invoke the method to get a generic object
        // The object to invoke on is null because the method is static
        // The parameter array is null because the method expects no parameters
        object mockShape = shapeCreator.Invoke(null, null);

        mockShapes.GetType()                 // Get the type of mockShapes
            .GetMethod("Add")                // Get its Add method
            .Invoke(                         // Invoke the method
                mockShapes,                  // on mockShapes list
                new object[] { mockShape }); // with mockShape as argument.
    }

    return mockShapes;
}

更好（但因情况而异）的方法

经过一番思考后，我意识到这里有一个不确定的假设，您可以滥用。 您试图制作一个List<TBase>并用TMock填充它。 TMock的全部TMock是模拟TBase ，因此TMock 是 TBase 。 实际上， List甚至使用TBase作为其类型参数。

这很重要，因为这意味着您不必将通用对象转换为TMock ，只需将其转换为TBase 。 由于TBase在编译时是已知的，因此您可以使用简单的静态TBase ，而不用规避键入系统来将泛型对象传递给类型化方法。 我认为，如果可以使用这种方式会更好。

using System.Collections.Generic;
using System.Reflection;
using System;

private List<TBase> GetMockShapes<TBase>()
     where TBase : Shape
{
    Type TMock = getAppropriateMockType<TBase>();

    // Sanity check -- if this fails, bad things might happen.
    Assert(typeof(TBase).IsAssignableFrom(TMock));

    List<TBase> mockShapes = new List<TBase>();

    // Find MockShapeFactory.CreateMockShape() method
    MethodInfo shapeCreator = typeof(MockShapeFactory).GetMethod("CreateMockShape");

    // Convert to CreateMockShape<mockType>() method
    shapeCreator = shapeCreator.MakeGenericMethod(new Type[] { TMock });

    for (int i = 0; i < 5; i++)
    {
        // Invoke the method to get a generic object
        // The object to invoke on is null because the method is static
        // The parameter array is null because the method expects no parameters
        object mockShape = shapeCreator.Invoke(null, null);

        //
        // Changes start here
        //

        // Static cast the mock shape to the type it's impersonating
        TBase mockBase = (TBase)mockShape;

        // Now this works because typeof(mockBase) is known at compile time.
        mockShapes.Add(mockBase);
    }

    return mockShapes;
}

Answer 2

好了，现在的问题是您不能使用Type实例调用泛型，为此需要一个编译时类型句柄。

要解决此问题，您可以：

• 修改MockShapeFactory.CreateMockShape<T>方法以采用Type实例，而不是将其写为泛型-但实际上很难创建实例。

• 使用反射动态绑定到CreateMockShape方法的“正确”版本（基于从getAppropriateMockType返回的类型）。

第二，该测试代码可能会有所帮助：

#region some stubs (replaced with your types)

public class Shape { }
public class MockSquare : Shape { }
public class MockCircle : Shape { }

public class MockShapeFactory
{
  //I've added a constraint so I can new the instance
  public static T CreateMockShape<T>()
    where T : Shape, new()
  {
    Console.WriteLine("Creating instance of {0}", typeof(T).FullName);
    return new T();
  }
}

#endregion

//you can cache the reflected generic method
System.Reflection.MethodInfo CreateMethodBase =
  typeof(MockShapeFactory).GetMethod(
    "CreateMockShape", 
    System.Reflection.BindingFlags.Public 
    | System.Reflection.BindingFlags.Static
  );

[TestMethod]
public void TestDynamicGenericBind()
{
  //the DynamicBindAndInvoke method becomes your replacement for the 
  //MockShapeFactory.CreateMockShape<typeof(mockType)>() call
  //And you would pass the 'mockType' parameter that you get from
  //getAppropriateMockType<TBase>();
  Assert.IsInstanceOfType
    (DynamicBindAndInvoke(typeof(MockCircle)), typeof(MockCircle));

  Assert.IsInstanceOfType
    (DynamicBindAndInvoke(typeof(MockSquare)), typeof(MockSquare));
}
//can change the base type here according to your generic
//but you will need to do a cast e.g. <
public Shape DynamicBindAndInvoke(Type runtimeType)
{
  //make a version of the generic, strongly typed for runtimeType
  var toInvoke = CreateMethodBase.MakeGenericMethod(runtimeType);
  //should actually throw an exception here.
  return (Shape)toInvoke.Invoke(null, null);
}

看起来比实际情况糟-目标是用接受Type实例的方法代替对工厂通用方法的调用-这是DynamicBindAndInvoke(Type)在此示例中所做的。 在此测试中看似毫无意义-但这仅仅是因为我要提供编译时已知的类型-在您的情况下，要传递的类型将是从getAppropriateMockType方法检索的getAppropriateMockType 。

请注意，这里我假设您的工厂方法在MockShapeFactory上是静态的。 如果不是，则必须更改反射和调用代码以搜索实例方法，并将工厂实例作为第一个参数传递给Invoke 。

可以将这种模式扩展为编译委托，从而加快处理速度，但是对于测试环境而言，这种优化可能毫无意义。