如何表达一个参数需要在 C# 中实现多个接口

Question

类似于这个问题：How can I require a method argument to implement multiple interfaces? 我想要一个方法参数来实现多个接口。

接口应该可以任意组合，我不想为每个有效的组合创建一个接口。

想想一个文件。可以是：

1. 可读 => IReadable
2. 可写 => IWriteable
3. 存档 => IArchive
4. 自动生成 => IGenerated

...

如果我想表达一个参数需要是一个可写的生成存档，我不想生成IWritableGeneratedArchive，因为组合太多，我想将它与一些我无法修改的现有类一起使用。

伪代码：

void WriteTo( IWritable + IGenerated + IArchive file)
{
   //...
}

Answer 1

我在这里找到的解决方案：How can I require a method argument to implement multiple interfaces? 针对 C# 进行了调整。

学分转到Michael Myers

internal interface IF1
{
    void M1();
}

internal interface IF2
{
    void M2();
}

internal class ClassImplementingIF1IF2 : IF1, IF2
{

    public void M1()
    {
        throw new NotImplementedException();
    }

    public void M2()
    {
        throw new NotImplementedException();
    }

}

internal static class Test
{

    public static void doIT<T>(T t) where T:IF1,IF2
    {
        t.M1();
        t.M2();
    }

    public static void test()
    {
        var c = new ClassImplementingIF1IF2();
        doIT(c);
    }
}

Answer 2

可能是一个通用的 + 约束？

void WriteTo<T>( T file) where T : IWritable,IGenerated,IArchive
{
   //...
}

Answer 3

使用通用约束：

void WriteTo<T>(T file) where T: IWritable, IGenerated, IArchive
{
   //...
}

见Constraints on Type Parameters (C# Programming Guide)

Answer 4

我不想生成 IWritableGeneratedArchive，因为组合太多

怎么组合太多了？无论有多少潜在组合，您只需要为实际用作方法参数的组合创建一个组合接口，然后无论如何都要写出来。换句话说，实际上并没有那么多工作。

我想将它与一些我无法修改的现有类一起使用。

可以将 IWritableGeneratedArchive 类型传递给只需要 IArchive 或 IWritable 的对象。这仍然适用于您已有的任何其他东西。

---

但既然您已经决定不这样做，而且看起来您已经在这个架构上投入了大量资金，我想知道您是否见过 Code Contracts。它们看起来可以满足您的需求。

Answer 5

此解决方案试图将 supercat 的想法与存储此类“多界面”对象结合起来。

我通过将它们存储在一个Holder 类中来实现这一点，该类公开对象的声明接口。

Holder 对象可以被存储并且是预期的参数。缺点是您必须首先创建Holder，并且Holder 的类型参数的顺序很重要。

从好的方面来说，您也可以动态创建Holders，当然还可以存储“多接口”对象。

启用holder.Get<T>() 方法（比 holder.t1 更好）会很好，但它不会编译。 也许有人知道如何解决它？我认为它需要添加约束 T1 is not T2 ，反之亦然。此接缝与C# generic does *not* implement something 相关，但他们没有找到解决方案。

internal interface IF1
{
    void M1();
}

internal interface IF1_extension : IF1
{
}

internal interface IF2
{
    void M2();
}

internal class ClassImplementingIF1IF2 : IF1_extension, IF2
{

    public void M1()
    {
        throw new NotImplementedException();
    }

    public void M2()
    {
        throw new NotImplementedException();
    }

}

internal interface Getter<T> where T : class
{
    T Get();
}

internal class Holder<T1, T2> //: Getter<T1>, Getter<T2> // not possible since T1 and T2 may be the same => won't compile!
    where T1 : class
    where T2 : class
{
    private Holder(T1 t1, T2 t2)
    {
        Debug.Assert(t1 != null, "Argument is no " + typeof(T1).Name);
        Debug.Assert(t2 != null, "Argument is no " + typeof(T2).Name);
        this.t1 = t1;
        this.t2 = t2;
    }

    public static Holder<T1, T2> CreateFrom<T>(T t) where T : T1, T2
    {
        return new Holder<T1, T2>(t, t);
    }
    public static Holder<T1, T2> CreateDynamicallyFrom(object t)
    {
        return new Holder<T1, T2>(t as T1, t as T2);
    }

    public readonly T1 t1;
    public readonly T2 t2;

    //T1 Getter<T1>.Get()
    //{
    //    return t1;
    //}
    //T2 Getter<T2>.Get()
    //{
    //    return t2;
    //}
}

internal class Holder<T1, T2, T3>  // Holder<T1,T2,T3,T4> etc. are defined in a similar way
    where T1 : class
    where T2 : class
    where T3 : class
{
    private Holder(T1 t1, T2 t2, T3 t3)
    {
        Debug.Assert(t1 != null, "Argument is no " + typeof(T1).Name);
        Debug.Assert(t2 != null, "Argument is no " + typeof(T2).Name);
        Debug.Assert(t3 != null, "Argument is no " + typeof(T3).Name);
        this.t1 = t1;
        this.t2 = t2;
        this.t3 = t3;
    }

    public static Holder<T1, T2,T3> CreateFrom<T>(T t) where T : T1, T2, T3
    {
        return new Holder<T1, T2, T3>(t, t, t);
    }
    public static Holder<T1, T2, T3> CreateDynamicallyFrom(object t)
    {
        return new Holder<T1, T2, T3>(t as T1, t as T2, t as T3);
    }

    public readonly T1 t1;
    public readonly T2 t2;
    public readonly T3 t3;

}


internal static class Test
{

    public static void doIt<T>(T t) where T : IF1, IF2
    {
        t.M1();
        t.M2();
    }

    public static void doIt(Holder<IF1, IF2> t) // Interfaces should be mentioned in alpahbetical order since Holder<IF1,IF2> != Holder<IF2,IF1>
    {
        t.t1.M1();
        t.t2.M2();
    }


    public static void doIt_extended<T1, T2>(Holder<T1, T2> t) // handles conversions from Holder<T1,T2> to Holder<T1 or base of T1, T2 or base of T2>
        where T1 : class, IF1
        where T2 : class, IF2
    {
        t.t1.M1();
        t.t2.M2();
    }

    public static void test()
    {
        var c = new ClassImplementingIF1IF2();
        doIt(c);
        var c_holder = Holder<IF1, IF2>.CreateFrom(c);
        doIt(c_holder);

        var another_c_holder = Holder<IF1_extension, IF2>.CreateFrom(c);
        doIt_extended(another_c_holder);


        object diguised_c = c;
        var disguised_c_holder = Holder<IF1, IF2>.CreateDynamicallyFrom(diguised_c);
        doIt(disguised_c_holder);

    }
}