C# 如何创建列表<；T>；包含一个开放的通用接口？

我有一个必须包含

IInteract

对象的列表。但是，

IInteract

是一个需要两个类型参数的通用接口

我的主要想法是遍历对象列表，如果它们还没有交互，就彼此“交互”。 所以我有这个物体

List<IObject> WorldObjects = new List<IObject>();

List WorldObjects=new List（）；

还有这个：

private List<IInteract> = new List<IInteract>();

private List=new List（）；

但我无法编译最后一行，因为

IInteract

需要两个类型参数。但我不知道这些论点是什么，直到我把它们加起来。我可以在类型A和类型A的对象之间添加交互。。。或类型B和C的对象

我想创建“交互”类，这些类可以处理“代理”对象和“目标”对象，但我希望它们独立于对象。。。所以我可以添加一个交互，例如“超级类”和。。。一个“整数”

---

我是否使用了错误的方法？

我不确定我是否完全理解您想要实现的目标。您需要做的是创建一个实现接口的具体类，然后在列表中使用它。像这样：

public interface IInteract
{
   Type A { get; set; }
   Type B { get; set; }
}


public class Interact : IInteract
{
    public Type A
    {
        get { return a; }
    }

    public Type B
    {
        get { return b; }
    }

}

然后在列表中使用具体类：

private List<Interact> = new List<Interact>();  

private List=new List（）；

假设IInteract的定义如下

interface IInteract<T1, T2>

接口接口接口

您正在将其用于类Foo的字段：

class Foo
{
  List<IInteract...> field;
}

class-Foo
{
列表字段；
}

然后，如果要推迟决定将哪些类型绑定到IInteract类型参数，则需要参数化容器类：

class Foo<T1, T2>
{
   List<IInteract<T1, T2>> field;
}

class-Foo
{
列表字段；
}

当您定义容器类的具体实例化时，这里IInteract的类型参数将被绑定，例如：

var x=new Foo（）。

这将导致IInteract字段的类型为该Foo泛型类型的特定实例化的

IInteract

。

您可以执行以下操作：

private List<IInteract<SomeType, SomeOtherType>> = new List<IInteract<SomeType, SomeOtherType>>();

2：在类中使用泛型：

class Foo<T1, T2> {
    private List<IInteract<T1, T2>> ...
}

...

Foo<string, int> bar = new Foo<string, int>();

class-Foo{
私人名单。。。
}
...
Foo-bar=新的Foo（）；

---

在第二个示例中，您被锁定为只向列表中添加字符串和int（或创建Foo对象的任何内容）。在第一个示例中，您可以混合和匹配，但您必须进行运行时类型检查，以确定要从列表中提取什么。

我认为接口层次结构可能会使事情变得更简单。顶层可以是非泛型接口，只包含需要调用的方法，而不包含任何类型信息。第二个级别是那些需要一些类型的…当然，只需要实现类而不是第二个级别的接口就足够了

public interface IInteract
{
    void Interact();
}

public interface IInteract<TActor,TTarget> : IInteract
{
    TActor Actor { get; set; }
    TTarget Target { get; set; }
}

公共接口界面界面
{
无效交互（）；
}
公共接口界面：界面
{
机智演员{get；set；}
t目标目标{get；set；}
}

---

然后，您可以创建

IInteract

对象列表，其中可以包含任何强类型的

IInteract

对象，尽管只有非泛型界面上的那些方法可用。重要的是具体的实现——这将决定执行什么代码。

最好使用字典，其中键是正在交互的两种类型的元组，值是Interact，因此每个Interact实现都必须进行一些转换

private Dictionary<Tuple<Type, Type>, IInteract<Object, Object>> interactions = new Dictionary<Tuple<Type, Type>, IInteract<Object, Object>>();

private Dictionary interactions=new Dictionary（）；

这有点乱，但你可以加上：

IInteract<Object, Object> superClassIntInteraction = someInteractionClass;
interactions.Add(new Tuple<Type, Type>(typeof(SuperClass),typeof(int)), superClassIntInteraction);

IInteract超类Interaction=someInteractionClass；
Add（新元组（typeof（SuperClass）、typeof（int））、superclassininteraction）；

我假设您希望能够搜索列表/字典，以便以后能够找到特定的交互，这就是字典方便使用的地方

我认为您应该使用容器（我过去使用过）。然后你可以这样做：

void Interact<TA, TB>(TA objectA, TB objectB)
{
    var interact = Container.Resolve<IInteract<TA, TB>>();
    interact.Interact(objectA, objectB);
}

void交互（TA对象A、TB对象B）
{
var interact=Container.Resolve（）；
交互。交互（objectA，objectB）；
}

您能告诉我们您的接口的定义吗？我不确定我是否真的理解这个问题。我试图做的是在我自己的“虚拟世界”中模拟互动。我希望他们能像我说的那样通过包括我自己的一系列“互动”来互动。每个对象都有自己的线程，世界也是如此。这只是一个测试，我希望每个对象都能以一定的速度工作，并且每次更新都会在每个“世界”周期内发生。问题是：只要我觉得有必要，我就想“包括”对象类型之间的交互。所以我可以增加两个“奥林匹克跑步者”课程，让他们参加比赛。或者我可以添加一个“OlympicRunner”和一个“Waitress”，让他们交谈。选项1只在T1和T2I的交互是协变的情况下才有效。选项1似乎是我所需要的，但它既不适用于对象，也不适用于动态。我应该如何强制转换呢？但是当我实例化这个类时，我会绑定到这两种类型，对吗？我希望该列表存储不同类型的IInteract。是的，IInteract接口将绑定到这两种类型，但仅限于容器类的特定实例化。如果您有另一对类型T3和T4，那么可以实例化容器类的另一个实例，该实例的IInteract将绑定到T3和T4。您可以实例化容器类，从而将IInteract接口绑定到几乎无限数量的类型。如果您的意思是希望能够在运行时将T1、T2放入IInteract对象实例中，然后切换到将T3、T4放入同一IInteract实例中，那么泛型就帮不了您。泛型提供了一种延迟类型决策的方法，但最终结果仍然是绑定到特定T1、T2类型的具体类型。您可以有多个相同泛型类型boun的具体实例化

void Interact<TA, TB>(TA objectA, TB objectB)
{
    var interact = Container.Resolve<IInteract<TA, TB>>();
    interact.Interact(objectA, objectB);
}