Réduire le code duplique

Question

Actuellement, j'ai assez de classes (5) qui ont seulement deux propriétés, mais ont des noms différents à des fins différentes:

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; } 
} 

J'ai pour chacune de ces classes une méthode qui renverra un List<Class> .

public static List<Class1> GetClass1() 
    { 
     Dictionary<string, string> s = GetSomeResults1(); 

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

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

      _s.Add(c); 
     } 

     return _s; 
    } 


    public static List<Class2> GetClass2() 
    { 
     Dictionary<string, string> s = GetSomeResults2(); 

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

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

      _s.Add(c); 
     } 

     return _s; 
    } 

    ...... 

    public static List<Class5> GetClass5() 
    { 
     Dictionary<string, string> s = GetSomeResults5(); 

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

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

      _s.Add(c); 
     } 

     return _s; 
    } 

Tout conseil comment puis-je mieux faire ce code?

Answer 1

Utilisez une classe de base pour mettre les propriétés partagées et fonctions:

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 
} 

Answer 2

Je proposerai de créer une classe séparée pour

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

et appellent à l'intérieur de la classe.

Answer 3

Vous pouvez utiliser une classe de base:

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() 
    { 
    } 
} 

Vous pouvez maintenant faire une méthode générique qui renvoie l'interface de List<T> où T est de type 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; 
} 

appeler ensuite:

List<Class2> class2list = GetClass<Class2>(GetSomeResults2); 

Answer 4

Vous pouvez utiliser l'héritage de classe et mettre des parties communes de code à une classe de base comme t son:

/// <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); 
    } 
} 

Answer 5

Réponse de Patrick Hofman est juste, mais je voudrais aussi ajouter que l'utilisation d'un BaseClass vous permettra de réduire la quantité de code de travail avec vos classes.

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; 
} 

Changer simplement cette fonction ne suffit pas cependant, vous aussi besoin d'un moyen de mettre en œuvre les méthodes GetSomeResults(). Je ne sais pas vraiment à quoi ressemble votre logique et à quel point ces méthodes sont différentes, mais cela peut aider dans le pire des cas lorsque les méthodes sont complètement différentes.

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