Refactor dwie metody, które generują SelectList w jedną metodę

Question

Mam dwie następujące metody, które pobierają dane z mojej bazy danych i zwracają wypełniony obiekt SelectList (w tym wartość opcji "Wszystkie"), które następnie przekazuję do mojego widoku. Problem polega na tym, że są prawie identyczne, z wyjątkiem tego, że oba mają dostęp do różnych obiektów repozytorium i mają różne nazwy identyfikatorów (StatusId i TeamId). Wydaje mi się, że istnieje sposobność, aby je przekształcić w jedną metodę, która akceptuje repozytorium jako parametr i w jakiś sposób określa, jaka powinna być nazwa identyfikatora, być może za pomocą refleksji lub pewnego rodzaju wyrażenia lambda, ale nie wiem jak aby to osiągnąć.

private SelectList GetStatusSelectList(int selectedStatusId) 
{ 
    List<MemberStatus> statusList = _memberStatusRepository.All().ToList(); 
    statusList.Insert(0, new MemberStatus {StatusId = 0, Name = "All"}); 
    var statusSelectList = new SelectList(statusList, "StatusId", "Name", selectedStatusId); 
    return statusSelectList; 
} 

private SelectList GetTeamSelectList(int selectedTeamId) 
{ 
    List<MemberTeam> teamList = _memberTeamRepository.All().ToList(); 
    teamList.Insert(0, new MemberTeam { TeamId = 0, Name = "All" }); 
    var teamSelectList = new SelectList(teamList, "TeamId", "Name", selectedTeamId); 
    return teamSelectList; 
} 

Czy ktoś może pomóc w ustaleniu, w jaki sposób można je przekształcić w jedną metodę?

Answer 1

można spróbować wykonać następujące czynności:

private SelectList GetStatusSelectList(int selectedStatusId) 
{ 
    return GetGenericSelectList<MemberStatus>(selectedStatusId, _memberStatusRepository.All().ToList(), "StatusId"); 
} 

private SelectList GetTeamSelectList(int selectedTeamId) 
{ 
    return GetGenericSelectList<MemberTeam>(selectedTeamId, _memberTeamRepository.All().ToList(), "TeamId"); 
} 

private SelectList GetGenericSelectList<T>(int selectedTeamId, List<T> list, string idFieldName) where T : new() 
{ 
    var firstItem = new T(); 
    (firstItem as dynamic).Name = "All"; 
    var l = new List<T>(list); 
    l.Insert(0, firstItem); 
    return new SelectList(l, idFieldName, "Name", selectedTeamId); 
} 

To rozwiązanie nie jest idealne i opiera się na pewnych konwencji (na przykład wszystkie elementy powinny mieć Name właściwość). Jednak wydaje się, że nie jest to zły sposób na początek. Można go jeszcze ulepszyć, używając wyrażeń zamiast nazw właściwości - co pozwoliłoby na zmianę nazw właściwości podczas sprawdzania czasu kompilacji.

Answer 2

Cóż, jest to najbardziej ogólna może wymyślić, ale będzie to wymagało, że MemberStatus i MemberTeam wdrożyć IIdentifiable, które nie wiem, czy można zastosować do sprawy. Jeśli tak, to byłaby to droga.

private SelectList GetList<T>(IRepository repository, int id, string name) 
    where T : IIdentifiable, new() 
{ 
    List<IIdentifiable> list = repository.All().ToList(); 
    list.Insert(0, new T() { Name = name, Id = id }); 
    var statusSelectList = new SelectList(list, "Id", "Name", id); 
} 

I kod interfejsu

interface IIdentifiable 
{ 
    int Id { get; set; } 
    string Name { get; set; } 
} 

Answer 3

Z tego co widzę, główne przeszkody na drodze refactoring to do jednej metody są new MemberStatus i zaproszeń new MemberTeam, oprócz ustalenia prawa repozytorium do użycia.

Aby wymyślić eleganckie rozwiązanie, potrzebowałbyś trochę więcej skonfigurowanej infrastruktury - w zasadzie musisz rozwiązać właściwe repozytorium na podstawie typu i chciałbyś mieć jakąś fabrykę budującą instancję obiektu.

Następujące będzie byłaby kodu do jednej metody, ale nie jest (moim zdaniem) lepiej niż odrębnych metod masz już:

private SelectList GetSelectList<T>(int selectedId, Func<List<T>> repoAllFunc, Func<T> typeNewFunc, string idName) 
{ 
    List<T> list = repoAllFunc(); 
    list.Insert(0, typeNewFunc()); 
    var selectList = new SelectList(list, idName, "Name", selectedId); 
    return selectList; 
} 

Mogłeś wtedy nazwać tak:

var memberStatusSelectList = 
    GetSelectList<MemberStatus>(
     id, 
     () => _memberStatusRepository.All().ToList(), 
     () => new MemberStatus {StatusId = 0, Name = "All"}); 

Answer 4

Jeśli IRepository doda kilka "funkcji", otrzymasz czystszy kod.

Zamiast All() stosuje się metodę SingleRecordsWithAllRecord(), która obsługuje pierwsze dwa wiersze. Następnie repozytorium określ swoje własne DataValueField i DataTextField.

private SelectList GetSelectList(IRepository repo, int selectedId) 
{ 
    var selectListAll = repo.SingleRecordsWithAllRecord().ToList(); 

    return new SelectList(selectListAll, 
         repo.DataValueField, 
         repo.DataTextField, 
         selectedId); 
} 

Answer 5

Można pójść trochę szalona interfejs i wykonaj następujące czynności:

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

namespace ConsoleApplication3 
{ 

    public class MemberStatus : IDefault<MemberStatus> 
    { 
     public int StatusId { get; set; } 
     public string Name { get; set; } 

     public MemberStatus Default 
     { 
      get { return new MemberStatus() { StatusId = 0, Name = "All" }; } 
     } 

     public string IdName 
     { 
      get { return "StatusId"; } 
     } 
    } 

    public class MemberTeam : IDefault<MemberTeam> 
    { 
     public int TeamId { get; set; } 
     public string Name { get; set; } 

     public MemberTeam Default 
     { 
      get { return new MemberTeam() { TeamId = 0, Name = "All" }; } 
     } 

     public string IdName 
     { 
      get { return "TeamId"; } 
     } 
    } 

    public interface IDefault<T> 
    { 
     T Default { get; } 
     string IdName { get; } 
    } 

    public interface IRepository<T> 
    { 
     IEnumerable<T> All(); 
    } 

    public class MemberStatusRepository : IRepository<MemberStatus> 
    { 
     public IEnumerable<MemberStatus> All() 
     { 
      return new[] { 
       new MemberStatus(), 
       new MemberStatus() 
      }; 
     } 
    } 
    public class MemberTeamRepository : IRepository<MemberTeam> 
    { 
     public IEnumerable<MemberTeam> All() 
     { 
      return new[] { 
       new MemberTeam(), 
       new MemberTeam() 
      }; 
     } 
    } 

    public class DataAccessLayer 
    { 
     IRepository<MemberStatus> _memberStatusRepository; 
     IRepository<MemberTeam> _memberTeamRepository; 
     public DataAccessLayer() 
     { 
      _memberStatusRepository = new MemberStatusRepository(); 
      _memberTeamRepository = new MemberTeamRepository(); 
     } 


     public SelectList<TResult> GetTeamSelectList<TRepository, TResult>(TRepository repo, int selectedTeamId) 
      where TRepository : IRepository<TResult> 
      where TResult : IDefault<TResult>, new() 
     { 
      List<TResult> teamList = repo.All().ToList(); 
      var dummyobj = new TResult(); 
      teamList.Insert(0, dummyobj.Default); 
      var teamSelectList = new SelectList<TResult>(teamList, dummyobj.IdName, "Name", selectedTeamId); 
      return teamSelectList; 
     } 
    } 

    class Program 
    { 
     static void Main(string[] args) 
     { 
      var dal = new DataAccessLayer(); 
      SelectList<MemberStatus> results = dal.GetTeamSelectList<IRepository<MemberStatus>, MemberStatus>(new MemberStatusRepository(), 5); 
      Console.WriteLine(); 
      Console.Read(); 
     } 
    } 

    public class SelectList<TResult> 
    { 
     public SelectList(List<TResult> teamList, string p, string p_2, int selectedTeamId) 
     { 

     } 
    } 

} 

Byłoby miło, jeśli można określić właściwości statyczne w interfejsie, ale skoro nie mogę polegać na tworzeniu fikcyjnego obiektu zamiast.