Question

请先阅读第2版。

假设我们有两个依赖的通用接口：

interface ITemplate1<T1, T2>
    where T1 : ITemplate1<T1, T2>
    where T2 : ITemplate2<T1, T2>
{
    T2 t2 { get; set; }
}

interface ITemplate2<T1, T2>
    where T1 : ITemplate1<T1, T2>
    where T2 : ITemplate2<T1, T2>
{
    T1 t1 { get; set; }
}

从他们两人中都实现了两个不同的类别：

class Class1_1 : ITemplate1<Class1_1, Class2_1>
{
    public Class2_1 t2
    {
        get;
        set;
    }
}

class Class1_2 : ITemplate1<Class1_2, Class2_2>
{
    public Class2_2 t2
    {
        get;
        set;
    }
}

class Class2_1 : ITemplate2<Class1_1, Class2_1>
{
    public Class1_1 t1
    {
        get;
        set;
    }
}

class Class2_2 : ITemplate2<Class1_2, Class2_2>
{
    public Class1_2 t1
    {
        get;
        set;
    }
}

现在，我想定义一个实现ITemplate1的类，无论其所需的类型如何......

class MyClass<T> where T : ITemplate1< ? , ? >
{
    ...
}

..以防止将多个类声明为：

class MyClass1<T> where T : ITemplate1<Class1_1, Class2_1>
{
    ...
}


class MyClass2<T> where T : ITemplate1<Class1_2, Class2_2>
{
    ...
}

我怎样才能实现这一目标？（即真正的问题可能涉及两个以上的课程！）提前谢谢。

第1版： Class1_1＆amp; Class2_1以及Class1_2＆amp; Class2_2必须一起使用。换句话说，我正在寻找一种方法：

class MyClass<T>
    where T : ITemplate1<Class1_1, Class2_1>
    or
    where T : ITemplate1<Class1_2, Class2_2>
{
    ...
}

第2版： 我想我可以更简单地问这个问题，以避免给亲爱的读者带来不便。如果我和你混在一起，我会道歉。提出这样一个令人困惑的问题的原因是真正的问题是完全复杂的。无论如何，这是一个简单的形式：

名称： 如何控制接口的实现？

说明： 我有一个实现两个依赖接口的类。我需要控制给定的类型，因为只有一对类型彼此一致。 - ＆GT; 第1版

Answer 1

我不知道你是否正在寻找这个，但你可以使你的ClassX_y更通用，例如：

    class Class1_x<T2> : ITemplate1<Class1_x<T2>, T2>
        where T2 : ITemplate2<Class1_x<T2>, T2>
    {
        public T2 t2
        {
            get; set;
        }
    }

    class Class2_x<T1> : ITemplate2<T1, Class2_x<T1>>
        where T1 : ITemplate1<T1, Class2_x<T1>>
    {
        public T1 t1
        {
            get;
            set;
        }
    }

或类似的东西：

class Class1_xy<T1,T2> : ITemplate1<T1,T2>
    where T2 : ITemplate2<T1,T2>
    where T1 : ITemplate1<T1,T2>
{
    public T2 t2
    {
        get; set; }
}

class Class2_xy<T1, T2> : ITemplate2<T1, T2>
    where T2 : ITemplate2<T1, T2>
    where T1 : ITemplate1<T1, T2>
{
    public T1 t1
    { get; set; }
}

class ClassBoth_xy<T1, T2> : ITemplate1<T1,T2>, ITemplate2<T1, T2>
    where T2 : ITemplate2<T1, T2>
    where T1 : ITemplate1<T1, T2>
{
    public T1 t1
    { get; set; }

    public T2 t2
    { get; set; }
}

但是我没有看到这一点 - 也许你可以启发我们？

Answer 2

使用ClassBoth_xy<T1, T2>是一个非常好的主意，但不能通过错误的MyClass对来限制<T1, T2>。我解决了这个问题：

class MyClass<T1, T2>
    where T1 : ITemplate1<T1, T2>, new()
    where T2 : ITemplate2<T1, T2>, new()
{
    public MyClass()
    {
        T1 _t1 = new T1();
        T2 _t2 = new T2();

        bool isValid = (_t1 is Class1_1 && _t2 is Class2_1) ||
                       (_t1 is Class1_2 && _t2 is Class2_2);

        if( !isValid )
            throw new Exception("Inconsistent types have been used to instantiate MyClass.");
    }

    ...
}

如何控制[依赖通用接口]的实现

2 个答案: