C# 在抽象类中使用泛型

我正在处理一个抽象类，其中实现类需要实现一个T列表。问题是这不起作用：

public class AbstractClass
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Container : AbstractClass
{
    public List<Widgets> Items { get; set; }
}

公共类抽象类
{
公共int Id{get；set；}
公共int名称{get；set；}
公共抽象列表项{get；set；}
}
公共类容器：AbstractClass
{
公共列表项{get；set；}
}

---

我确信有一个明显的答案我没有找到，我知道我可以构建一个抽象基类型来放入列表中，但是当我使用Linq命令来构建列表时，抽象类型（ItemBase）与.ToList（）方法不能很好地配合。我想做的是独一无二的吗？

您还需要类上的声明，才能知道

T

是什么类型：

public abstract class AbstractClass<T>
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Container : AbstractClass<Widgets>
{
    public override List<Widgets> Items { get; set; }
}

---

您需要将

AbstractClass

设置为泛型

public class AbstractClass<T> {
  ...
}

public class Container : AbstractClass<Widgets> { ...
}

公共类抽象类{
...
}
公共类容器：抽象类{。。。
}

您需要在抽象类中指定类型：

public class AbstractClass<T>
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Container : AbstractClass<Widgets>
{
    public List<Widgets> Items { get; set; }
}

公共类抽象类
{
公共int Id{get；set；}
公共int名称{get；set；}
公共抽象列表项{get；set；}
}
公共类容器：AbstractClass
{
公共列表项{get；set；}
}

您需要这样定义T

public class AbstractClass<T>
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Container : AbstractClass<Widget>
{
    public List<Widgets> Items { get; set; }
}

公共类抽象类
{
公共int Id{get；set；}
公共int名称{get；set；}
公共抽象列表项{get；set；}
}
公共类容器：AbstractClass
{
公共列表项{get；set；}
}

• 您需要声明类型T
• 您需要将类AbstractClass声明为抽象类
• 您需要使用override关键字

试试这个：

public class Widgets { }

public abstract class AbstractClass<T>
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Container : AbstractClass<Widgets>
{
    public override List<Widgets> Items { get; set; }
}

公共类小部件{}
公共抽象类AbstractClass
{
公共int Id{get；set；}
公共int名称{get；set；}
公共抽象列表项{get；set；}
}
公共类容器：AbstractClass
{
公共重写列表项{get；set；}
}

您需要标记AbstractClass

abstract

，因为它包含抽象属性

在

抽象类

声明中指定泛型类型

通过重写实现抽象属性

公共抽象类AbstractClass
{
公共int Id{get；set；}
公共int名称{get；set；}
公共抽象列表项{get；set；}
}
公共类容器：AbstractClass
{
公共重写列表项{get；set；}
}

---

您缺少为AbstractClass类定义抽象关键字，还需要为Container class Items属性添加override关键字。我给出的示例代码肯定会运行

namespace AbstractGeneric
{

public abstract class AbstractClass<T>
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Widgets
{
    public int ID { get; set; }
    public string Name { get; set; }
}

public class Container : AbstractClass<Widgets>
{
    public override List<Widgets> Items { get; set; }
    public Container()
    {
        Items = new List<Widgets>();
    }

}


class Program
{
    static void Main(string[] args)
    {
        Container c = new Container();
        c.Items.Add(new Widgets() { ID = 1, Name = "Sample Widget 1" });
        c.Items.Add(new Widgets() { ID = 2, Name = "Sample Widget 2" });

        foreach (Widgets item in c.Items)
        {
            Console.WriteLine(item.ID + " : " + item.Name);
        }

        Console.ReadLine();
    }
}
}

namespace抽象泛型
{
公共抽象类AbstractClass
{
公共int Id{get；set；}
公共int名称{get；set；}
公共抽象列表项{get；set；}
}
公共类小部件
{
公共int ID{get；set；}
公共字符串名称{get；set；}
}
公共类容器：AbstractClass
{
公共重写列表项{get；set；}
公共容器（）
{
项目=新列表（）；
}
}
班级计划
{
静态void Main（字符串[]参数）
{
容器c=新容器（）；
c、 添加（newwidgets（）{ID=1，Name=“Sample Widget 1”}）；
c、 添加（新小部件（）{ID=2，Name=“示例小部件2”}）；
foreach（c.Items中的Widgets项）
{
Console.WriteLine（item.ID+“：”+item.Name）；
}
Console.ReadLine（）；
}
}
}

别忘了在类声明行中添加

abstract

关键字，而不仅仅是属性。事实证明，我需要学会更好地研究。对所有没有打勾的答案表示歉意。我根据它的完整性和它是最上面的事实选择了最上面的一个。你真的希望

项目
是抽象的吗？（即覆盖get或set属性？）如果像大多数人建议的那样从
抽象类
扩展，
容器。项
将隐式地成为
列表
，您甚至不需要覆盖它。我想保留稍后覆盖getter和setter方法的可能性。理论上我不需要，但在实践中，试图消除这种混乱会导致一个充满伤害的世界。

public abstract class AbstractClass<T>
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Container : AbstractClass<Widgets>
{
    public override List<Widgets> Items { get; set; }
}

namespace AbstractGeneric
{

public abstract class AbstractClass<T>
{
    public int Id { get; set; }
    public int Name { get; set; }

    public abstract List<T> Items { get; set; }
}

public class Widgets
{
    public int ID { get; set; }
    public string Name { get; set; }
}

public class Container : AbstractClass<Widgets>
{
    public override List<Widgets> Items { get; set; }
    public Container()
    {
        Items = new List<Widgets>();
    }

}


class Program
{
    static void Main(string[] args)
    {
        Container c = new Container();
        c.Items.Add(new Widgets() { ID = 1, Name = "Sample Widget 1" });
        c.Items.Add(new Widgets() { ID = 2, Name = "Sample Widget 2" });

        foreach (Widgets item in c.Items)
        {
            Console.WriteLine(item.ID + " : " + item.Name);
        }

        Console.ReadLine();
    }
}
}