Question

我需要一个列表，其中所有项都扩展了A类并实现了接口I.此外，A类可能是层次结构中的多个父项。

如果所有类都是A类的直接后代，我可以使用一个抽象类来实现我作为泛型并使用它，但我的用例并不允许这样做。

有没有办法告诉List它的元素必须扩展A类并实现接口I？ List<A,I>？如果没有，还有另一种解决方法吗？

示例代码：

public class A
{
    // Class belongs to a third party library
}

public class B : A
{
    // Class belongs to a third party library
    public string Text{ get; set; }
}

public class C : A
{
    // Class belongs to a third party library
    public string Other{ get; set; }
}

interface I
{
    // Belongs to me
    bool shouldSend();
    string getName();
    string getValue();
}

public class MyClass : B, I 
{
      public string Name{ get; set; }

      public function myClass(ObjectWithName obj)
      {
           Name = obj.Name;
      }

      public string getValue()
      {
          return Text;
      }

      public bool shouldSend()
      {
          return true;
      }
}

public class MyClass2 : C, I 
{
      public string Name{ get; set; }

      public function myClass(ObjectWithName obj)
      {
           Name = obj.Name;
      }

      public string getValue()
      {
          return Other;
      }

      public bool shouldSend()
      {
          return true;
      }
}

public class mainActions
{
    // Here is where I need the list to use both restrictions
    public List<A,I> myList;
    // The class I need to use these things in
    public function mainActions(List<ObjectWithName> elements)
    {
        ThirdPartyCollection TPC = new ThirdPartyCollection();
        foreach(var el in elements)
        {
            MyList.Add(new MyClass(el));
            MyList.Add(new MyClass2(el));
            // TPC.Add accepts implementations of A here
            TPC.Add(MyList.ElementAt(MyList.Count - 1));
            TPC.Add(MyList.ElementAt(MyList.Count - 2));
        }


    }

    public function doThisLater()
    {
        foreach(var el in myList)
        {
            if(el.shouldSend())
            {
                // I need an implementation of I here
                doSomethingElse(el.getName(), el.getValue());
            }
        }
    }
}

编辑：对于今后在这里寻找答案的人来说，它似乎无法实现。相反，我使用@servys回答并创建了一个新列表来保存我的子类对象：

public class MyList<T> : List<T> where T : A, I
{
}

然后我为每个子类保留了不同的列表：

protected MyList<MyClass> MCList = new MyList<MyClass>();
protected MyList<MyClass2> MCList2 = new MyList<MyClass2>();

Answer 1

当您指定通用约束时，您可以指定任意数量的约束，并且必须满足所有，因此您只需添加A和{{1的通用约束对于你的类型，类型必须满足这两个约束才能成为有效的泛型参数。

指定通用类型和接口

1 个答案: