C# - 如何拥有一个引用实现一组接口的任何对象的类型？

Question

如何拥有引用实现一组接口的任何对象的类型引用？

例如，我可以有一个像这样的泛型类型：

Java:

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

C#

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

这就是如何拥有一个类范围的泛型类型。但是，我只想有一个数据成员，它引用扩展给定接口集的任何对象。

示例：

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

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

如果可以使用这种类型语法，我如何在 Java 和 C# 中实现它？

---

我意识到我可以创建另一个扩展所有所需接口的接口。但是，我认为这不是最佳选择，因为它不必要地添加了另一种类型，其唯一目的是绕过语法。诚然，这是一个非常小的问题，但就优雅而言，它有点令人难堪。

Answer 1

由于两年的不活动，我的 Java 已经变得有点生疏了。

这是我的 C# 方法：（有关完整的工作示例，请参阅 https://ideone.com/N20xU）

public class Foo
{
    private IInterface1 _object; // just pick one

    public void setObject<T>(T obj)
        where T : IInterface1, IComparable<T>, IEtcetera
    {
        // you now *know* that object supports all the interfaces
        // you don't need the compiler to remind you
        _object = obj; 
    }

    public void ExerciseObject()
    { 
        // completely safe due to the constraints on setObject<T>
        IEtcetera itf = (IEtcetera) _object;

        // ....
    }

Answer 2

据我所知，您不能创建带有约束的变量，只能创建给定类型的变量。类型有限制。这意味着您必须定义一个具有所需约束的类型，然后使用该类型创建变量。

这对我来说似乎是合乎逻辑的，我不明白为什么你觉得必须为你需要的类型定义一个“令人烦恼”的事情。

Answer 3

在 C# 中，您可以使用元组以某种叠加< /a>：

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);
  }
}

您还可以使用一个专门的类来强制两个值都引用同一对象的约束：

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);
  }
}

在 Java 中，通配符可以稍微简化一些事情：

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);
  }
}

或者您可以使用别名 /em> 为相同的值（C#，但也适用于 Java）：

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

Answer 4

我认为简单地将约束声明为私有接口没有任何问题：

class Foo
{
    interface R : I1, I2 { }
    R _object;

    void setObject(R r) { _object = r; }
}

Answer 5

这是我能想到的最好的解决方案（但仍然不是最佳解决方案）

public class Foo
{
    private TypeWrapper<IInterface1,IInterface2> _object;
    public void setObject<T>(T obj)
        where T : IInterface1, IInterface2
    {
        _object = new TypeWrapper<IInterface1, IInterface2>();
        _object.SetObject(obj);

        var val = _object.Get(h => h.c);
        Console.WriteLine(val);
        _object.Do(h => h.c = 25);
        val = _object.Get(h => h.c);
        Console.WriteLine(val);
        _object.Do(h => h.someF());
    }
}

public class TypeWrapper<TType, TTypeTwo>
{
    private Object m_Obj;
    public void SetObject<T>(T obj) where T : TType, TTypeTwo
    {
        m_Obj = obj;
    }

    public T Get<T>(Func<TType, T> action)
    {
        return (T)action((TType)m_Obj);
    }
    public T Get<T>(Func<TTypeTwo, T> action)
    {
        return (T)action((TTypeTwo)m_Obj);
    }

    public void Do(Action<TTypeTwo> action)
    {
        action((TTypeTwo)m_Obj);
    }

    public void Do(Action<TType> action)
    {
        action((TType)m_Obj);
    }
}

public class myClass : IInterface1, IInterface2 {
    public int t {get;set;}
    public int c {get;set;}
    public void someF() { Console.WriteLine("Fired"); }
    }
public interface IInterface1 {
    int t { get;set;} 
    void someF();
}
public interface IInterface2 { 
    int c { get;set; }
}

您将必须通过 Get 和 Do 方法来处理对象，但它将与智能感知一起工作，并在接口发生更改时抛出编译时错误。