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

由于 2 年不活动，我的 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# 中，您可以使用元组将值存储在 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);
  }
}

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

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

或者您可以将 aliases 设置为相同的值（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 方法处理对象，但如果接口发生更改，它将与智能感知一起工作并引发编译时错误。