C# 减少代码重复

目前，我有相当多的类（5），它们只有2个属性，但有不同的名称用于不同的目的：

public class Class1
{
    public Class1()
    {

    }

    public string Id { get; set; }
    public string Value { get; set; }
}

public class Class2
{
    public Class2()
    {

    }

    public string Id { get; set; }
    public string Value { get; set; }
}


........

  public class Class5
 {
    public Class5()
    {

    }

    public string Id { get; set; }
    public string Value { get; set; }
}

然后，对于这些类，我都有一个方法，它将返回

List

公共静态列表GetClass1（）
{
字典s=GetSomeResults1（）；
列表_s=新列表（）；
foreach（s中的var项目）
{
Class1 c=新的Class1（）；
c、 Id=项。键；
c、 价值=项目价值；
_s、 添加（c）；
}
返回;；
}
公共静态列表GetClass2（）
{
字典s=GetSomeResults2（）；
列表_s=新列表（）；
foreach（s中的var项目）
{
Class2 c=新的Class2（）；
c、 Id=项。键；
c、 价值=项目价值；
_s、 添加（c）；
}
返回;；
}
......
公共静态列表GetClass5（）
{
字典s=GetSomeResults5（）；
列表_s=新列表（）；
foreach（s中的var项目）
{
Class5 c=新的Class5（）；
c、 Id=项。键；
c、 价值=项目价值；
_s、 添加（c）；
}
返回;；
}

---

有没有建议如何更好地生成此代码？

使用基类将共享属性和函数放入：

public class BaseClass
{
    public string Id { get; set; }
    public string Value { get; set; }

    // shared properties and methods
}

public class Class1 :  BaseClass
{
    // own properties and methods
}

public class Class2 :  BaseClass
{
    // own properties and methods
}

---

我将建议为您创建一个单独的类

public string Id { get; set; }
public string Value { get; set; }

---

并在类内调用。

您可以使用基类：

public abstract class BaseClass{
   public string Id { get; set; }
   public string Value { get; set; }
}
public class Class1 : BaseClass
{
    public Class1()
    {
    }
}

public class Class2: BaseClass
{
    public Class2()
    {
    }
}

现在您可以创建一个泛型方法，它返回

List

的接口，其中T是BaseClass类型

public static List<T> GetClass<T>(Func<Dictionary<string, string> func) where T : BaseClass, new()
{
    Dictionary<string, string> s = func();

    List<T> _s = new List<T>();

    foreach (var item in s)
    {
        T c = new T();
        c.Id = item.Key;
        c.Value = item.Value;

        _s.Add(c);
    }

    return _s;
}

---

publicstaticlist GetClass（Func您可以使用类继承并将代码的公共部分放入基类，如下所示：

/// <summary>
/// Base class
/// </summary>
public class BaseClass
{
  public BaseClass()
  {
  }

  public string Id { get; set; }
  public string Value { get; set; }

  public virtual List<BaseClass> GetClass();

  protected List<TClass> GetList<TClass> (Dictionary<string, string> s) where TClass : BaseClass, new() {
    List<TClass> _s = new List<TClass>();

    foreach (var item in s)
    {
        TClass c = new TClass();
        c.Id = item.Key;
        c.Value = item.Value;

        _s.Add(c);
    }

    return _s;
  }
}

public class Class1 : BaseClass
  {
    public override List<Class1> GetClass() {
       Dictionary<string, string> s = GetSomeResults1();
       return GetList<Class1>(s);
  }
}

//
///基类
/// 
公共类基类
{
公共基类（）
{
}
公共字符串Id{get；set；}
公共字符串值{get；set；}
公共虚拟列表GetClass（）；
受保护的列表GetList（字典），其中TClass:BaseClass，new（）{
列表_s=新列表（）；
foreach（s中的var项目）
{
TClass c=新的TClass（）；
c、 Id=项。键；
c、 价值=项目价值；
_s、 添加（c）；
}
返回;；
}
}
公共类1：基类
{
公共覆盖列表GetClass（）{
字典s=GetSomeResults1（）；
返回获取列表；
}
}
Patrick Hofman的答案是正确的，但我还要补充一点，使用
基类可以减少类中的代码量

public static List<T> GetClassList() where T:BaseClass
{
    Dictionary<string, string> s = GetSomeResults<T>();

    List<T> _s = new List<T>();

    foreach (var item in s)
    {
        T c = new T();
        c.Id = item.Key;
        c.Value = item.Value;

        _s.Add(c);
    }

    return _s;
}

代码为域建模。也许这不是一个如何改进代码的问题，而是如何更好地为域建模的问题。因此，我们需要知道应用程序是什么来回答这个问题。这个问题似乎离题了，因为它是关于“代码审查”的，并且可能使基类抽象化，这将是一个确实可以防止使用的选项它本身，但就我们现在所知，它不是必需的。我遵循了你的示例，只是使用了基类。我删除了所有的Class1-Class5，只创建了一个类，根据Enum参数，我将结果作为字典，然后创建一个列表并返回它。
/// <summary>
/// Base class
/// </summary>
public class BaseClass
{
  public BaseClass()
  {
  }

  public string Id { get; set; }
  public string Value { get; set; }

  public virtual List<BaseClass> GetClass();

  protected List<TClass> GetList<TClass> (Dictionary<string, string> s) where TClass : BaseClass, new() {
    List<TClass> _s = new List<TClass>();

    foreach (var item in s)
    {
        TClass c = new TClass();
        c.Id = item.Key;
        c.Value = item.Value;

        _s.Add(c);
    }

    return _s;
  }
}

public class Class1 : BaseClass
  {
    public override List<Class1> GetClass() {
       Dictionary<string, string> s = GetSomeResults1();
       return GetList<Class1>(s);
  }
}

public static List<T> GetClassList() where T:BaseClass
{
    Dictionary<string, string> s = GetSomeResults<T>();

    List<T> _s = new List<T>();

    foreach (var item in s)
    {
        T c = new T();
        c.Id = item.Key;
        c.Value = item.Value;

        _s.Add(c);
    }

    return _s;
}

public static Dictionary<string, string> GetSomeResults<T>() where T : BaseClass
{
    if (T == typeof(Class1))
    {
        return GetSomeResults1();
    }
    else if (T == typeof(Class2))
    {
    //You got it..
    }
}