泛型类列表的泛型方法

Question

我有问题。 例如，考虑这 4 个类。

public abstract ParentContainer<T> where T: Parentfoo
{
    public List<T> fooList; 
}

//Let there be many different ChildContainers with different types.
public class ChildContainer : ParentContainer<ChildFoo>
{
}

public abstract class ParentFoo
{
    public string name; 
}

public class ChildFoo : ParentFoo
{
}

我如何编写一个接受任意 ChildContainer 列表作为参数的方法， 哪些对他们的 fooLists 进行操作？ 有没有可能？

补充说明，ParentContainer有很多不同的children， 每个都有一个 foo 的不同子项的列表。

public class ChildContainerB : ParentContainer<ChildFooB>{}
public class ChildContainerC : ParentCOntainer<ChildFooC>{}
...

public class ChildFooB : ParentFoo;
public class ChildFooC : ParentFoo;

那我需要一个类似这样的方法

//X means it can be any arbitrary ChildContainer
public void method(List<ChilContainerX> list) 
{
    foreach(ChildContainerX x in list)
    {
        print(x.fooList.Last().name);
    }
}

Answer 1

所以您的要求是不可能的，因为您需要List<> 的具体类型。不过有几个解决方法。

1. 使用List<object>。这显然不是很好，因为这意味着您完全失去了类型检查，并且最终可能会将任何内容添加到列表中。所以出于这个原因，我不会推荐这种方法。

2. 使ParentContainer<> 实现一个标记接口。例如：

   public interface IParentContainer
   {
   }
   
   public abstract class ParentContainer<T> : IParentContainer
       where T: ParentFoo
   {
       //snip
   }
   

   现在您可以拥有这样的列表：

   var containers = new List<IParentContainer>
   {
       new ChildContainer(),
       new ChildContainer2()
   };
   

Answer 2

除非我误解了这个问题，否则你想要这样的东西......

public void DoStuffWith<T>(List<ParentContainer<T>> containers) where T : Parentfoo
{
     //TODO: implement
}

这适用于 ... 类型的对象

List<ParentContainer<ParentFoo>>
List<ParentContainer<ChildFoo>>

在哪里 ChildFoo : ParentFoo

并解决了“List<ParentContainer<ParentFoo>> 未实现IEnumerable<ParentContainer<ChuldFoo>>”的问题，我怀疑这是您看到的编译器。

更进一步，例如 ....

public void DoStuffWith<ContainerT,ElementT>(List<ContainerT<ElementT>> containers) 
  where ContainerT : ParentContainer 
  where ElementT : Parentfoo
{
     //TODO: implement
}

... 可能会使问题过于复杂，但我怀疑这是您想要实现的目标。

在这一点上，我会质疑您拥有的数据结构并给它们一些共同的父级，例如...

public class ParentContainer<T> : IEnumerable<T> { ... }
public class ChildContainer<T> : ParentContainer<T>, IEnumerable<T> { ... } 

由于两者都实现了 IEnumerable，您现在可以这样做...

public void DoStuffWith<T>(IEnumerable<T> containers) where T : ParentFoo
{
     //TODO: implement
}

这完全避免了关注集合类型的需要。

Answer 3

class Program
{
    static void Main(string[] args)
    {

        List<ParentContainer<ChildFoo>> ca = new List<ParentContainer<ChildFoo>>();

        ProcessContainers processor = new ProcessContainers();

        ca.Add(new ChildContainerA { fooList = new List<ChildFoo>() });
        ca.Add(new ChildContainerA { fooList = new List<ChildFoo>() });
        ca.Add(new ChildContainerA { fooList = new List<ChildFoo>() });
        ca.Add(new ChildContainerB { fooList = new List<ChildFoo>() });

        processor.Process(ca);
    }
}


public abstract class ParentContainer<T> where T: ParentFoo
{
    public List<T> fooList;
}

//Let there be many different ChildContainers with different types.
public class ChildContainerA : ParentContainer<ChildFoo>
{
}
public class ChildContainerB : ParentContainer<ChildFoo>
{
}

public class ProcessContainers
{
    public void Process<T>(List<ParentContainer<T>> childContainers) where T : ParentFoo
    {
        foreach(var item in childContainers)
        {
            foreach(var foo in item.fooList)
            {
                foo.Porcess();
            }
        }
    }
}

public abstract class ParentFoo
{
    public string name;

    public abstract void Porcess();
}

public class ChildFoo : ParentFoo
{
    public override void Porcess()
    {
        //Do some processing
    }
}