Oggi al lavoro un collega stava esaminando un modulo che avevo scritto un mese fa come implementazione di riferimento.
Avevo scritto un servizio WCF che stava consumando un servizio di Windows.
Ho un singolo operation esposto come di seguito.
[ServiceContract]
public interface IMyService
{
[OperationContract]
void PerformASpecificTask(int randomNumber);
}
Ho un'interfaccia simile in un assembly separato e faccio riferimento a questo contratto in un altro assembly che implementa questa interfaccia sopra,
simile a come si implementerebbero i contratti di servizio della WCF.
Ho l'interfaccia in un assembly separato perché posso distribuire la DLL con l'interfaccia da sola ai client (servizio Windows nel mio caso).
public class MyService : Contract.IMyService
{
private readonly Domain.ISomeDomainNameHereDataProvider _domainDataProvider;
private readonly Domain.ADomainService _aDomainService;
public MyService(Domain.ISomeDomainNameHereDataProvider domainDataProvider,
Domain.ADomainService aDomainService)
{
_domainDataProvider = domainDataProvider;
_aDomainService = aDomainService;
}
public void PerformASpecificTask(int randomNumber)
{
var myRequiredData = _domainDataProvider.GetMyRequiredData(randomNumber);
myRequiredData.ForEach(data => _aDomainService.DoSomething(data));
_domainDataProvider.SaveMyChanges(myRequiredData);
}
}
Qui ADomainService è una classe che vive in un assembly chiamato Domain e questa classe usa internamente un altro servizio WCF,
il cui proxy è ingiusto durante la sua istanziazione.
ISomeDomainNameHereDataProvider è un'interfaccia che ho nell'assembly Domain Ho anche un'altra interfaccia IDataAccess nell'assembly Domain .
IDataAccess è implementata nel mio assembly DAL .
L'implementazione di 'ISomeDomainNameHereDataProvider' è contenuta nello stesso gruppo 'Dominio' e viene implementata un'implementazione di 'IDataAccess' che si trova in 'DAL'.
Quindi 'ISomeDomainNameHereDataProvider' fa uso di 'IDataAccess' per accedere ai dati o per essere sql-server specifico in questo caso.
Si noti che non ho definito 'IDataAccess' in un proprio assieme separato, poiché questo lavoro era un compito di piccole dimensioni e il mio 'Dominio' sarebbe stato solo uno che lo consumava.
Venendo ora alla domanda, questo collega mi chiama e mi domando perché il tuo servizio parli direttamente con 'DAL' e non usi il livello 'Dominio'.
Il suo ragionamento era la mia implementazione di un'interfaccia definita in "Dominio" proveniente da "DAL".
È andato a dire che il tuo servizio ha una logica aziendale e viola il principio "open-close" e "single-responsibility",
Sono orgoglioso del mio lavoro e ho scoperto di non violare i principi e tutte le mie classi hanno una sola responsabilità e
open-close non è una regola e non si applica in questo caso d'uso.
Ho anche provato a ragionare per questo requisito. Devo ottenere alcuni dati, eseguire alcune operazioni con i dati e poi salvarli e
hai bisogno di un posto per coordinare tutto questo e la mia classe di servizio lo fa e questa è la responsabilità del mio servizio.
Non sarebbe d'accordo e ha iniziato a parlare di cambiamenti dei requisiti, ecc.
Ho provato a ragionare con un'altra soluzione sarebbe stato spostare il codice che ho nella mia implementazione del servizio in una classe diversa e quella classe avrebbe lo stesso codice
e lui non sarebbe d'accordo.
Mi sto perdendo qualcosa ?
Per favore fatemi sapere cosa ne pensate della soluzione e degli eventi di cui sopra?
Potrei solo pensare, proviene da un background "MVC" e pensa alla classe di servizio simile a un "Controller".
'Controller' comunque delegherebbe le chiamate a un livello di servizio e tutto il codice che ho nella mia implementazione di servizio rimarrebbe?
Ho letto questo Quanto è accurato" La logica di business dovrebbe essere in un servizio, non in un modello "? e richiederebbe comunque delle opinioni sulla mia soluzione di cui sopra.