Question

How can I have a type reference that refers to any object that implements a set of interfaces?

For example, I can have a generic type like this:

Java:

public class Foo<T extends A & B> { }

C#

public class Foo<T> where T : A, B { }

That’s how to have a class-wide generic type. However, I’d like to simply have a data member which references any object that extends a given set of interfaces.

Example:

public class Foo
{
    protected <? extends A, B> object;

    public void setObject(<? extends A, B> object)
    {
        this.object = object;
    }
}

If it’s possible to have this sort of type syntax, how could I do it in both Java and C#?

---

I realize I can just create another interface that extends all desired interfaces. However, I don’t see this as optimal, as it needlessly adds another type whose sole purpose is to get around syntax. Granted this is a very minor issue, but in terms of elegance it’s a bit galling.

Answer 1

In C#, you can use a tuple to store the value in a kind of superposition:

public class Foo {
  private Tuple<IA, IB> junction;
  public void SetValue<T>(T value) where T : IA, IB {
    junction = Tuple.Create<IA, IB>(value, value);
  }
}

You can also have a specialized class to enforce the constraint that both values reference the same object:

public class Junction {
  public IA A { get; private set; }
  public IB B { get; private set; }
  private Junction() { }
  public static Junction Create<T>(T value) where T: IA, IB {
    return new Junction {
      A = value,
      B = value
    };
  }
}

public class Foo {
  private Junction junction;
  public void SetValue<T>(T value) where T : IA, IB {
    junction = Junction.Create(value);
  }
}

In Java, a wildcard would simplify things a little:

class Junction<E extends A & B> {
  private final E value;
  public Junction(E value) {
    this.value = value;
  }
  public E getValue() {
    return value;
  }
}

class Foo {
  private Junction<?> junction;
  public <E extends A & B> void setValue(E value) {
    junction = new Junction<E>(value);
  }
}

Or you can have aliases to the same value (C#, but also applicable to Java):

public class Foo {
  private IA a;
  private IB b;
  public void SetValue<T>(T value) where T : IA, IB {
    a = value;
    b = value;
  }
}