Refactor due metodi che generano una SelectList in un unico metodo

Question

Ho i seguenti due metodi che ottengono i dati dal mio DB e restituiscono un oggetto PopLista popolato (incluso un valore di opzione "Tutto") che poi passerò sulla mia vista. Il problema è che sono quasi identici con l'eccezione che entrambi accedono a diversi oggetti del repository e hanno nomi ID diversi (StatusId e TeamId). Penso che ci sia un'opportunità per rifattorizzarli in un singolo metodo che accetta il repository come parametro e in qualche modo capisce quale dovrebbe essere il nome dell'ID, magari usando il reflection o qualche tipo di espressione lambda, ma non so come per realizzare questo.

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

Qualcuno può aiutare a capire come refactoring questi in un unico metodo?

Answer 1

si può provare il seguente:

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

Questa soluzione non è ideale e si basa su alcune convenzioni (ad esempio, tutti gli oggetti devono avere Name proprietà). Tuttavia sembra essere un modo non male per iniziare. Potrebbe essere ulteriormente migliorato utilizzando le espressioni anziché i nomi di proprietà, il che consentirebbe di modificare i nomi delle proprietà con il controllo del tempo di compilazione.

Answer 2

Bene, questo è il più generico che possa venire, ma richiederà che il tuo MemberStatus e MemberTeam implementino IIdentifiable, che non so se possa applicarsi al tuo caso. Se è così, questa sarebbe la strada da percorrere.

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

E il codice di interfaccia

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

Answer 3

Da quello che vedo, i principali ostacoli nel modo di refactoring questo in un unico metodo sono i new MemberStatus ei new MemberTeam chiamate, oltre a determinare il diritto repository da usare.

Per trovare una soluzione elegante, è necessario configurare un po 'più di infrastruttura: in pratica è necessario risolvere il repository corretto in base al tipo e si vorrebbe avere una sorta di factory build up dell'istanza dell'oggetto.

Di seguito vi refactoring del codice in un unico metodo, ma non è (a mio parere) meglio rispetto ai metodi separati avete già:

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

È quindi possibile chiamare in questo modo:

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

Answer 4

Se IRepository aggiunge alcune "caratteristiche", otterrete un codice più pulito.

Invece di All() ha un metodo SingleRecordsWithAllRecord() che gestisce le prime due righe. Quindi fare in modo che il repository definisca il proprio DataValueField e DataTextField.

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

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

Answer 5

Si può andare un po 'pazzo e un'interfaccia effettuare le seguenti operazioni:

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

     } 
    } 

} 

Sarebbe bello se si potesse definire le proprietà statiche in un'interfaccia, ma dal momento che non posso contare sulla creazione di un oggetto fittizio anziché.