如何为 List创建新的通用项？

Question

给定一个可能包含 5 个项目的列表，下面的方法将返回一个恰好包含 5 个项目的新列表（如果原始列表少于 5 个项目，则添加更多项目）。这工作正常，但现在我需要重构它，以便它可以处理通用 T 列表（具有相同的年份和 Cnt 属性）。如何转换此方法以接受 List 并让它返回一个包含 5 个元素的新 List？

    private static List<FiveYearComplex> CreateFiveYearTemplate(int startYear, 
        int endYear, ObjectResult<FiveYearComplex> result)
    {
        var list = new List<FiveYearComplex>(5);

        for (int year = startYear; year < endYear; ++year)
        {
            list.Add(new FiveYearComplex() { Year = year, Cnt = 0 });
        }
        FiveYearComplex tmpItem;
        foreach (var item in result)
        {
            tmpItem = list.Find(w => w.Year == item.Year);
            if (tmpItem == null)
            {
                tmpItem = new FiveYearComplex() { Cnt = 0, Year = item.Year };
            }
            else
            {
                tmpItem.Cnt = item.Cnt;
            }
        }
        return list;
    }

当我尝试使用 List 时，我最终遇到了此部分：

for (int year = startYear; year < endYear; ++year)
{
    list.Add(new T() { Year = year, Cnt = 0 });
}

并且出现错误...

谢谢！

为了完整起见：

    public interface IYearTemplate
    {
        int? Year { get; set; }
        decimal? Cnt { get; set; }
    }

    private static List<T> CreateFiveYearTemplate <T> (
        int startYear, int endYear, 
        ObjectResult<FiveYearAttendanceComplex> result) 
        where T : IYearTemplate, new()
    {
        var list = new List<T>(5);

        for (int year = startYear; year < endYear; ++year)
        {
            list.Add(new T() { Year = year, Cnt = 0 });
        }
        T tmpItem;
        foreach (var item in result)
        {
            tmpItem = list.Find(w => w.Year == item.Year);
            if (tmpItem == null)
            {
                tmpItem = new T() { Cnt = 0, Year = item.Year };
            }
            else
            {
                tmpItem.Cnt = item.Cnt;
            }
        }
        return list;
    }

谢谢。

Answer 1

为了使其适用于任意 T，您有两种选择：

• 添加 where T : SomeType 约束，其中 SomeType 是基类或者（更有可能且更通用）声明您需要切换到的属性的接口
• ，使用动态（或4.0之前的反射）来访问属性

第一个为您提供编译时安全性，但需要一些通用性在T之间；第二个不需要通用性，但完全是运行时的——没有静态分析检查。

例如：

interface IRenameThis {
    int Year {get;set;}
    int Cnt {get;set;}
}

并将 where T : IRenameThis 添加到方法签名中（在参数的结束 ） 和方法主体的开始 { 之间）

Answer 2

static List<T> CreateFiveYearTemplate( int startYear 
                                      ,int endYear
                                      ,ObjectResult<T> result)
      where T : FiveYearComplex, new()
{
  ...
}

Answer 3

您无法轻松地将您的方法转换为处理通用列表，因为您的方法不是通用的。它要求列表中的每个项目都具有属性 Cnt 和 Year，为了使您的方法具有通用性，您必须添加此约束。

public interface IYearTemplate
{
   int Cnt {get;set;}
   int Year {get;set;}
}

另外，您的方法需要一个默认构造函数，它表示为约束 new() - 所以它可能看起来像这样：

private static List<T> CreateFiveYearTemplate<T>(int startYear,
    int endYear, ObjectResult<T> result) where T: IYearTemplate, new()
{
    var list = new List<T>(5);

    for (int year = startYear; year < endYear; ++year)
    {
        list.Add(new T() { Year = year, Cnt = 0 });
    }
    T tmpItem;
    foreach (var item in result)
    {
        tmpItem = list.Find(w => w.Year == item.Year);
        if (tmpItem == null)
        {
            tmpItem = new T() { Cnt = 0, Year = item.Year };
        }
        else
        {
            tmpItem.Cnt = item.Cnt;
        }
    }
    return list;
}

话虽如此，这个方法看起来不太通用，因为约束是 非常具体。为什么您想要使其通用？