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

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，那么它实际上应该填充 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而不是 List，那么他就可以利用 C# 4.0 中的协方差，而不必做任何这些废话。”是的，但是在我们的实际代码中，我们没有使用 List，而是使用自定义具体类型 Something。 （而且它不是 IEnumerable 风格的集合），并且我没有能力更改 Something的用法。并引入协变接口 ISomething现在。

不管怎样，我想，我想做的就是试图让自己不必在每次调用 GetMockShapes() 时额外输入一个单词，所以这并不是什么大不了的事，而且我不知道，也许两者都很好类型已指定，以便一目了然。我只是觉得如果我能找到一些方法来做到这一点那就太酷了，而且我也能学到一些新东西。我主要想知道是否可以这样做来满足我的好奇心。我认为就代码质量而言这并不是那么重要。

Answer 1

好吧，现在的问题是您无法使用 Type 实例调用泛型，您需要一个编译时类型句柄。

要解决这个问题，您可以：

• 修改 MockShapeFactory.CreateMockShape 方法以获取 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 方法中检索到的类型。

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

这种模式可以扩展到编译委托，从而加快速度，但对于测试环境来说，这种优化可能毫无意义。

Answer 2

我不确定这是一种很好的方法，但我得到了 GetMockShapes 方法，按照您所寻找的方式工作。这个想法是从 MockShapeFactory 开始，获取其 CreateMockShape 方法，将其转换为适当的通用版本并调用它来创建正确类型的对象。

不过，它会获取一个 object，而 mockShapes 的 Add 方法仅接受正确键入的 Shape。我不知道如何动态地将新的 mockShape 转换为其适当的类型。我认为，无论如何，这都可以避免通过反射调用构建器的需要。

相反，我绕过了类型检查系统（就像我说的，“不确定这是一种很好的做事方式”）。我从 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 并用 TMock 填充它。 TMock 的全部意义在于模拟 TBase，因此 TMock 是一个 TBase 。事实上，List 甚至使用 TBase 作为其类型参数。

这很重要，因为这意味着您不必将通用对象转换为 TMock，只需将其转换为 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;
}