垫片和通用方法

Question

我想为通用方法创建一个 Shim。但在那种情况下，我对 Generic 有点麻烦。

这是我的例子：

class BaseRepository <T> where T: Entity
{
    public T[] FindAll()
    {
        return Method<T>.FindAll()
    }
}

class ClassA : base<A>
{
}

class A : Entity
{
}

class ClassB : base<B>
{
}

class B : Entity
{
}

现在我想为 ClassA 和 ClassB 创建一个 ShimMethod

ShimBaseRepository<A>.AllInstances.FindAll = (repo) => MethodA();
ShimBaseRepository<B>.AllInstances.FindAll = (repo) => MethodB();

public A MethodA()
{
    //Make the Same as MethodB
}

public B MethodB()
{
    //Make the Same as MethodA
}

但是如果我有超过 20 个“基础”类怎么办？我不想为每个基类创建一个委托/方法。我尝试过这样的事情：

List<Type> allEntityClasses = (from x in Assembly.GetAssembly(typeof(Entity)).GetTypes()
                                    where !x.IsAbstract && !x.IsInterface
                                    select x).ToList();

foreach(Type type in allEntityClasses=
{
    ShimBaseRepository<type????>.AllInstances.FindAll = (repo) => Method();
}

public Entity????? Method()
{
}

在我的单元测试中，我将使用以下方法：

ClassA.FindAll()
ClassB.FindAll()

而不是：

Base.FindAll()

编辑： 我使用 Microsoft Fakes，因此无法更改 ShimClass 中的任何内容。这是 Shim 生成的源代码。

  public class ShimBaseRepository<T> : ShimBase<BaseRepository<T>> where T : Entity
  {
    public static class AllInstances
    {
        public static FakesDelegates.Func<BaseRepository<T>, T[]> FindAll { [ShimMethod("FindAll", 20)] set; }
    }
  }

我的意图是，我不想为每个实体创建一个委托，我只想遍历我的所有 EntityClasses 并动态创建委托。但我不知道如何在

中添加我的 Type 对象

ShimBase<T>

Answer 1

好的，让我们稍微讨论一下。 首先，这是一个使用虚拟方法的直接解决方案：

public class Base<T> where T : Entity
{
    public virtual T[] FindAll()
    {
        return null;
    }
}

然后在具体类中覆盖FindAll 或者，如果可以的话，将Base 抽象化，并将InnerFindAll 抽象化。

但是，如果您需要在运行时指定委托（我可以看到您有一个特定的 Helper，但我不明白，为什么您在 Base 中调用 helper，然后您有一些未定义的问题 AllInstances Func) 这种方法无济于事。您需要使用 Base 中分配的一些默认策略来实现 Strategy pattern。然后，您将有 3 种方法来“解决”具体类中的策略：

1. 在具体类的构造函数中硬编码策略
2. 通过 DI 容器向具体类构造函数注入策略
3. 实现某种映射器，它将为您返回适当的 EntityType 策略 (T)

另外，我认为您在设计方面遇到了一些问题。我看不出有任何理由需要将 FindAll 实现为注入到 Func<T> 类型的静态属性的 lambda（是的，我认为您可以只用 static FindAll 替换 AllInstances.FindAll）。所以如果我是你，我会使用抽象方法..

编辑

现在我遇到了你的问题，只能通过反射给你一个相当丑陋的解决方案......我非常不建议你使用它，因为它真的很严格

public class Program
{
    static void Main(string[] args)
    {
        List<Type> allEntityClasses = (from x in Assembly.GetAssembly(typeof(Entity))
                                           .GetTypes().Where(t=>typeof(Entity).IsAssignableFrom(t))
                                       where !x.IsAbstract && !x.IsInterface
                                       select x).ToList();
        foreach (var type in allEntityClasses)
        {
            var genericType = typeof(BaseGeneric<>).MakeGenericType(type);
            var helper = new DelegateHelper();
            var myLambda = helper.GetLambdaForType(type);
            var allInst = genericType.GetProperty("AllInstances").GetValue(null);
            if (allInst == null)
            {
                allInst = Activator.CreateInstance(genericType.GetProperty("AllInstances").PropertyType);
            }
            allInst.GetType().GetProperty("FindAll").SetValue(allInst,myLambda);
        }
    }


}

public static class BaseGeneric<T>
{
    public static AllInstances<T> AllInstances { get; set; }
}

public class AllInstances<T>
{
    public Func<T[]> FindAll { get; set; }
}

public class DelegateHelper
{
    public Delegate GetLambdaForType(Type type)
    {
        var funcType = typeof(Func<>).MakeGenericType(type.MakeArrayType());
        var methodInfo = typeof(DelegateHelper).GetMethods().FirstOrDefault(t => t.Name == "FunctionMethod")
                                               .MakeGenericMethod(type);
        var @delegate = methodInfo.CreateDelegate(funcType, this);
        return @delegate;
    }

    public T[] FunctionMethod<T>()
    {   
        return new T[10];
    }
}

public  class Entity
{
}

public class EntityFirst
{

}

public class EntitySecond
{

}