Recentemente ho lavorato su un codice che si interfaccia con un CMS che utilizziamo e mi ha presentato una domanda sul design della classe che ritengo sia applicabile in una serie di situazioni. In sostanza, ciò che sto facendo è estrarre informazioni dal CMS e trasformare queste informazioni in oggetti che posso utilizzare in modo programmatico per altri scopi. Questo consiste di due passaggi:
- Recupera i dati dal CMS (abbiamo un DAL che uso, quindi questo è essenzialmente solo specificando quali dati dal CMS voglio - nessuna logica di connessione o qualcosa del genere)
- Mappare i dati analizzati sui miei [C #] oggetti
Ci sono fondamentalmente due modi in cui posso avvicinarmi a questo:
Una chiamata da più metodi
public void MainMethodWhereIDoStuff()
{
IEnumerable<MyObject> myObjects = GetMyObjects();
// Do other stuff with myObjects
}
private static IEnumerable<MyObject> GetMyObjects()
{
IEnumerable<CmsDataItem> cmsDataItems = GetCmsDataItems();
List<MyObject> mappedObjects = new List<MyObject>();
// do stuff to map the CmsDataItems to MyObjects
return mappedObjects;
}
private static IEnumerable<CmsDataItem> GetCmsDataItems()
{
List<CmsDataItem> cmsDataItems = new List<CmsDataItem>();
// do stuff to get the CmsDataItems I want
return cmsDataItems;
}
Chiamate multiple da un metodo
public void MainMethodWhereIDoStuff()
{
IEnumerable<CmsDataItem> cmsDataItems = GetCmsDataItems();
IEnumerable<MyObject> myObjects = GetMyObjects(cmsDataItems);
// do stuff with myObjects
}
private static IEnumerable<MyObject> GetMyObjects(IEnumerable<CmsDataItem> itemsToMap)
{
// ...
}
private static IEnumerable<CmsDataItem> GetCmsDataItems()
{
// ...
}
Sono tentato di dire che quest'ultimo è migliore del primo, dato che GetMyObjects non dipende da GetCmsDataItems ed è esplicito nel metodo chiamante i passi che vengono eseguiti per recuperare gli oggetti (sono preoccupato che il primo approccio è una specie di versione orientata agli oggetti del codice spaghetti).
D'altra parte, i due metodi helper non saranno mai usati al di fuori della classe, quindi non sono sicuro che sia importante sapere se uno dipende dall'altra. Inoltre, mi piace il fatto che nel primo approccio gli oggetti possano essere recuperati da una linea - molto probabilmente a chi lavora con il metodo principale non interessa come vengono recuperati gli oggetti, hanno solo bisogno di recuperare gli oggetti, e il " "i metodi di supporto concatenati a margherita" nascondono i passaggi esatti necessari per recuperarli (in pratica, ho effettivamente qualche altro metodo ma sono ancora in grado di recuperare la raccolta di oggetti che voglio in una riga).
Uno di questi metodi è giusto e l'altro è sbagliato? O è semplicemente una questione di preferenza o dipendente dal contesto?