C# 如何强制实现抽象方法和返回接口 使用系统； 使用System.Collections.Generic； 使用System.Linq； 公共接口IValue { int Id{get；} } 公共类特定值：IValue { 公共int Id{get{return 3；}} 公共字符串Val{get；set；} } 公共抽象类必须实现 { 公共抽象IEnumerable GetValues（整数）； } 公共类SpecificClass:MustImplement { 公共覆盖IEnumerable GetValues（整数） { var rv=新列表（）； rv.添加（新的SpecificValue（） {Val=number+“Test”}）； 返回rv； } } 公共课程 { 公共静态void Main（） { var测试=新的SpecificClass（）； var values=test.GetValues（1.Single（）； Console.WriteLine（values.Id）； //Console.WriteLine（values.Val）；//这不起作用 var values2=test.GetValues（1）.Single（）作为SpecificValue； Console.WriteLine（values2.Id）； Console.WriteLine（values2.Val）；//这可以工作，但我不想强制转换。values2现在也可能为null，这很烦人 } }

小提琴：

例如，这是一个人为简化的示例。使用

SpecificClass

时，我想自动获取

SpecificValue

，而不必强制转换它

抽象类/接口只是用来强制契约的。我不想实际获取接口作为返回，但是

GetValues（）

返回的内容并不具体，取决于每个实现（只要它们遵守约定）

我试图用泛型重写它，这样您就可以

---

test.GetValues（1）.Single（）

但我仍然相信有一种方法可以返回SpecificValue，而不必在Main（）中键入SpecificValue（）

您可以将抽象类定义为如下所示的泛型类：

using System;
using System.Collections.Generic;
using System.Linq;

public interface IValue
{
    int Id { get;}
}

public class SpecificValue : IValue
{
    public int Id { get { return 3; } }
    public string Val { get; set; } 
}

public abstract class MustImplement
{
    public abstract IEnumerable<IValue> GetValues(int number);
}

public class SpecificClass : MustImplement
{
    public override IEnumerable<IValue> GetValues(int number)
    {
        var rv = new List<SpecificValue>();
        rv.Add(new SpecificValue()
        {Val = number + "Test"});
        return rv;
    }
}

public class Program
{
    public static void Main()
    {
        var test = new SpecificClass();
        var values = test.GetValues(1).Single();
        Console.WriteLine(values.Id);
        //Console.WriteLine(values.Val); // This doesnt work

        var values2 = test.GetValues(1).Single() as SpecificValue;
        Console.WriteLine(values2.Id);
        Console.WriteLine(values2.Val); // This works but I dont want to have to cast. values2 is also potentially null now and that's annoying
    }
}

公共抽象类必须实现其中T:IValue
{
公共抽象IEnumerable GetValues（整数）；
}
公共类SpecificClass:MustImplement
{
公共覆盖IEnumerable GetValues（整数）
{
var rv=新列表（）；
rv.添加（新的SpecificValue（）
{Val=number+“Test”}）；
返回rv；
}
}

您可以将抽象类定义为泛型类，如下所示：

using System;
using System.Collections.Generic;
using System.Linq;

public interface IValue
{
    int Id { get;}
}

public class SpecificValue : IValue
{
    public int Id { get { return 3; } }
    public string Val { get; set; } 
}

public abstract class MustImplement
{
    public abstract IEnumerable<IValue> GetValues(int number);
}

public class SpecificClass : MustImplement
{
    public override IEnumerable<IValue> GetValues(int number)
    {
        var rv = new List<SpecificValue>();
        rv.Add(new SpecificValue()
        {Val = number + "Test"});
        return rv;
    }
}

public class Program
{
    public static void Main()
    {
        var test = new SpecificClass();
        var values = test.GetValues(1).Single();
        Console.WriteLine(values.Id);
        //Console.WriteLine(values.Val); // This doesnt work

        var values2 = test.GetValues(1).Single() as SpecificValue;
        Console.WriteLine(values2.Id);
        Console.WriteLine(values2.Val); // This works but I dont want to have to cast. values2 is also potentially null now and that's annoying
    }
}

公共抽象类必须实现其中T:IValue
{
公共抽象IEnumerable GetValues（整数）；
}
公共类SpecificClass:MustImplement
{
公共覆盖IEnumerable GetValues（整数）
{
var rv=新列表（）；
rv.添加（新的SpecificValue（）
{Val=number+“Test”}）；
返回rv；
}
}