如何在一个接口中两次使用具有不同模板参数的相同接口？

Question

我想通过这个例子会更清楚。我们希望在处理器类中看到两个具有不同参数的方法。“ int处理（int值）；” “双重处理（双重价值）；”

但是编译器对IRoot说：'Generics.IRoot'不能同时实现'Generics.IProcess'和'Generics.IProcess'，因为它们可能会为某些类型参数替换统一。

public class Processor : IRoot<int, double, int, double>
{
    // Here we want 2 methods
    public int Process(int item) { }
    public double Process(double item) { }
}

public interface IProcess<TResult, TItem>
{
    TResult Process(TItem item);
}

public interface IRoot<TR1, TR2, TItem1, TItem2> :
    IProcess<TR1, TItem1>,
    IProcess<TR2, TItem2>
{

}

Answer 1

这是我的解决方案。它基于使用差异化，因此您可以清楚地了解您想要哪个界面。您必须添加一个其他未使用的参数，但这就是告诉它您想要哪个参数。

public interface First { }
public interface Second { }

public class Processor : IRoot<int, double, int, double>
{
    // Here we want 2 methods
    public int Process ( int item ) { System.Console.WriteLine ( "int Process" ); return item + 1; }
    public double Process ( double item ) { System.Console.WriteLine ( "double Process" ); return item + 10.748; }
}

public class TestProcessor : IRoot<int, int, int, int>
{
    int IProcessWithDifferentiator<int, int, First>.Process ( int item )
    {
        System.Console.WriteLine ( "int Process" ); return item + 1;
    }
    int IProcessWithDifferentiator<int, int, Second>.Process ( int item )
    {
        System.Console.WriteLine ( "int Process" ); return item + 100302;
    }
}

public interface IProcessWithDifferentiator<TResult, TItem, TDiff>
{
    TResult Process ( TItem item );
}

public interface IRoot<TR1, TR2, TItem1, TItem2> :
    IProcessWithDifferentiator<TR1, TItem1, First>,
    IProcessWithDifferentiator<TR2, TItem2, Second>
{

}

class Program
{
    static void Main ( string [] args )
    {
        Processor p = new Processor ();
        IProcessWithDifferentiator<int, int, First> one = p;
        System.Console.WriteLine ( "one.Process(4) = " + one.Process ( 4 ) );
        IProcessWithDifferentiator<double, double, Second> two = p;
        System.Console.WriteLine ( "two.Process(5.5) = " + two.Process ( 5.5 ) );

        TestProcessor q = new TestProcessor ();
        IProcessWithDifferentiator<int, int, First> q1 = q;
        System.Console.WriteLine ( "q1.Process(4) = " + q1.Process ( 4 ) );
        IProcessWithDifferentiator<int, int, Second> q2 = q;
        System.Console.WriteLine ( "q2.Process(5) = " + q2.Process ( 5 ) );

        System.Console.ReadLine ();
    }
}

这是输出。

int Process
one.Process(4) = 5
double Process
two.Process(5.5) = 16.248
int Process
q1.Process(4) = 5
int Process
q2.Process(5) = 100307

即使您使用IRoot<int,int,int,int>如上所示，这也将起作用；它知道（因为我们告诉它）要使用哪个 IDifferentiatedProcess。

（以防万一，我使用的是 Visual Studio 2012。）

Answer 2

您可能可以使用这种实现。你会失去一些通用参数：

public interface IBase<TM, TPkey> 
    where TM : bType
    where TPkey : new ()        
{
    TM Get(TPkey key);
}

public interface IABase<TPK> : IBase<ConcreteTmA, TPK> {}
public interface IBBase<TPK> : IBase<ConcreteTmB, TPK> {}

public class Root <TPK> :
    IABase<TPK>,
    IBBase<TPK> 
    where TM : MType 
    where TPM : PMType 
    where TPK : new()
{
    ConcreteTmA IABase.Get(TPK key)
    {
    }

    ConcreteTmB IBBase.Get(TPK key)
    {
    }
}