Question

Is there any type-safe, compile-time checked possibilty of referring to values that implement multiple interfaces?

Given

interface A {
    void DoA();
}

interface B {
    void DoB();
}

I’m able to write code for objects implementing A or B, but not both. So I’ve to come up with ugly wrappers:

class ABCollection {
    private class ABWrapper : A, B {
        private readonly A a;
        private readonly B b;

        public static ABWrapper Create<T>(T x) where T : A, B {
            return new ABWrapper { a = x, b = x };
        }

        public void DoA() {
            a.DoA();
        }

        public void DoB() {
            b.DoB();
        }
    }

    private List<ABWrapper> data = new List<ABWrapper>();

    public void Add<T>(T val) where T : A, B {
        data.Add(ABWrapper.Create(val));
    }
}

Is there a trick to write this code more intuitively without losing type-safety (runtime-casts etc.)?

E.g.

private List<A and B> ...

Edit: This is not about having a list in particular – I just wanted to give a “complete” example with the issue of storing such values. My problem is just how to type a combination of both interfaces (like A & B or A and B).

Another more useful example: List<IDrawable & IMovable> …

Answer 1

You can do parametric polymorphism like that in C#, but not subtype polymorphism. That is, you can create a polymorphic method like:

void Foo<T>(T t) where T : IFoo, IBar
{
  t.Foo();
  t.Bar();
}

and then you must pass an object whose type is known at compile time to implement both IFoo and IBar.

But there is no way to say

void Foo(IFoo-and-IBar t) 
{
  t.Foo();
  t.Bar();
}

and then pass in a value that is both an IFoo and an IBar. Neat feature, but not one we support.