Question

请参阅以下两个类：

public class Person
    {
        int ID;
        string Name;
        string Address;
    }

    public class PersonModel
    {
        int ID;
        string Name;
        string Address;
    }

我正在尝试创建一个函数，该函数将根据传递给类的参数返回PersonModel列表或Person列表：

这是客户端功能：

public static List<T> BuildList<T>()
        {
            //Populate list of T where T is wither a Person or PersonModel.
            //Return List of T
        }

可以这样做吗？

Answer 1

在有人询问的条件下回答问题。是的，这是可能的，你几乎自己给出了答案。您只需要使用模板类型在函数中初始化列表，然后以您需要的方式填充它。

public static List<T> BuildList<T>() where T : new()
{
    List<T> ownList = new List<T>();

    // Populate your list the way you want.

    return ownList;
}

要填充列表，您可以创建默认的类objets并将它们添加到列表中，如下所示：

T myObject = new T();
ownList.Add(myObject);

或者，如果您想根据T的类型以特定方式填充列表，可以使用typeof。

if(typeof(T) == typeof(Person))
{
    // Initialize your Person objets in a specific way.
}

但我会避免选择此选项。我要么为每个类的某个特定的函数声明，要么使用一个接口来重新组合每个类的元素，让这些类实现这个接口，并通过你的接口初始化你的对象。 Evk的回答是这种实现的一个很好的例子。

Answer 2

您可以引入一个接口，该接口将共享这两个类的公共属性，然后将T参数限制为此接口：

public interface IPerson {
    int ID { get; set; }
    string Name { get; set; }
    string Address { get; set; }
}

public class Person : IPerson {
    public int ID { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
}

public class PersonModel : IPerson {
    public int ID { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
}

public static List<T> BuildList<T>() where T : IPerson, new() {
    var result = new List<T>();
    for (int i = 0; i < 10; i++) {
        result.Add(new T() {
            ID = i,
            Address = "address" + i
        });
    }
    return result;
}

Answer 3

在你的特殊情况下，我会说你的问题闻起来，我的意思是你看起来只是朝着错误的方向看。

所以我同意@Jamiec评论：

如果您有单独的类（模型，数据库实体），那么不清楚为什么需要一个通用方法来“构建列表”。

要回答标题中的问题，这里是代码（但这样做很奇怪）：

public interface IPerson 
{
    public int Id {get;}
    public string Name {get;}
}

public GoodPerson : IPerson
{
    public int Id {get; set;}
    public string Name {get; set;}
    public int GoodDeedCount {get; set;}


    void SayGoodDay(IPerson toPerson)
    {
        GoodDeedCount++;
        return $"Good day, {toPerson.Name}! :)"
    }
}

public BadPerson : IPerson
{
    public int Id {get; set;}
    public string Name {get; set;}
    public int Badness {get; set;}

    void SayShutUp(IPerson toPerson)
    {
        Badness++;
        return $"Shut up, {toPerson.Name}!"
    }
}

public UglyPerson : IPerson
{
    public int Id {get; set;}
    public string Name {get; set;}

    void SayNothing() { }
}

public static List<T> BuildList<T>()
    where T: new()
{
    var result = new List<T>();
    if (T is GoodPeson)
    {
         result.Add(new GoodPerson{Id = 1, Name = "Pinky", GoodDeedCount = 0});
         result.Add(new GoodPerson{Id = 2, Name = "Brain", GoodDeedCount = 0});
    }
    else if (T is BadPerson)
    {
         result.Add(new BadPerson{Id = 1, Name = "Sunshine", Badness = 0});
    }
    else if (T is UglyPerson)
    {
         result.Add(new UglyPerson{Id = 1, Name = "No", Badness = 0});
    }
    return result;
}

Answer 4

使用Interface并在两个类中实现，然后在泛型方法中使用该接口

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

    }

    public static List<T> BuildList<T>() where T : IPersonModel, new()
    {
        //Populate list of T where T is wither a Person or PersonModel.
        //Return List of T
        // Implement here with any loop
        return null;// you need to return any value
    }
}


public interface IPersonModel
{
    int ID { get; set; }
    string Name { get; set; }
    string Address { get; set; }
}
public class Person : IPersonModel
{
    public int ID { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
}

public class PersonModel : IPersonModel
{
    public int ID { get; set; }
    public string Name { get; set; }
    public string Address { get; set; }
}

返回T的列表，其中T是x类之一（其中x大于零）

4 个答案: