2015-10-28 17 views
5

Ho una differenza generale di opinione su un progetto di architettura e anche se lo stackoverflow non deve essere utilizzato per chiedere opinioni vorrei chiedere pro e contro di entrambi gli approcci che descriverò qui sotto:Classi di Entity Framework rispetto a POCO

Dettagli: - C# applicazione - database di SQL Server - utilizzo di Entity Framework - e abbiamo bisogno di decidere quali oggetti abbiamo intenzione di utilizzare per memorizzare le nostre informazioni e utilizzare tutti durante l'applicazione

Scenario 1 : Useremo le entità Entity Framework per passare tutto intorno alla nostra applicazione, per esempio l'oggetto dovrebbe essere usato per memorizzare tutte le informazioni, lo passiamo al BL e infine il nostro WepApi prenderà questa entità e restituirà il valore. Nessun DTO o POCO.

Se lo schema del database cambia, aggiorniamo l'entità e la modifica in tutte le classi in cui viene utilizzata.

Scenario 2: Creiamo una classe intermedia, denominata DTO o chiamata POCO, per conservare tutte le informazioni richieste dall'applicazione. C'è una fase intermedia di prendere le informazioni memorizzate nell'entità e popolate nel POCO ma manteniamo tutto il codice EF all'interno dell'accesso ai dati e non attraverso tutti i livelli.

Quali sono i pro e i contro di ciascuno?

+0

* StackOverflow non deve essere utilizzato per chiedere opinioni * –

risposta

4

Vorrei utilizzare le classi intermedie, ovvero POCO anziché EF.

L'unico vantaggio che vedo utilizzare direttamente entità EF è che è meno codice da scrivere ...

Vantaggi da utilizzare POCO invece:

si espongono solo i dati dell'applicazione in realtà ha bisogno

Sostanzialmente, supponiamo di avere un metodo di business GetUsers. Se si desidera solo l'elenco degli utenti per popolare una griglia (cioè è necessario il loro ID, cognome, nome, ad esempio), si può solo scrivere qualcosa di simile:

public IEnumerable<SimpleUser> GetUsers() 
{ 
    return this.DbContext 
     .Users 
     .Select(z => new SimpleUser 
     { 
      ID = z.ID, 
      Name = z.Name, 
      FirstName = z.FirstName 
     }) 
     .ToList(); 
} 

E 'chiaro che cosa il vostro metodo di realtà ritorna. Ora immaginate invece, ha restituito una full User un'entità con tutte le proprietà di navigazione e roba interna che non si desidera esporre (come ad esempio il campo Password) ...

E 'davvero semplificare il lavoro della persona che consuma la tua servizi

È ancora più evidente per i metodi commerciali Create. Certamente non si desidera utilizzare un User un'entità come parametro, sarebbe terribilmente complicato per i consumatori del vostro servizio di sapere cosa proprietà sono in realtà necessari ...

Immaginate la seguente entità:

public class User 
{ 
    public long ID { get; set; } 
    public string Name { get; set; } 
    public string FirstName { get; set; } 
    public string Password { get; set; } 
    public bool IsDeleted { get; set; } 
    public bool IsActive { get; set; } 
    public virtual ICollection<Profile> Profiles { get; set; } 
    public virtual ICollection<UserEvent> Events { get; set; } 
} 

Quali proprietà sono necessarie per il consumo del metodo void Create(User entity);?

  • ID: Boh, forse è generato forse non è
  • Nome/Cognome: ben quelli dovrebbe essere impostato
  • Password: è che una password di testo semplice, una versione hash? che cos'è?
  • IsDeleted/IsActive: devo attivare personalmente l'utente? È fatto dal metodo commerciale?
  • Profili: hum ... come si influisce su un profilo per un utente?
  • Eventi: l'inferno è ??

ti costringe a non uso pigro carico

Sì, io odio questa funzione per diverse ragioni. Alcuni di loro sono:

  • estremamente difficile da utilizzare in modo efficiente. Ho visto troppe volte codice che produce migliaia di richieste SQL perché gli sviluppatori non sapevano come utilizzare correttamente il caricamento lazy
  • estremamente difficile da gestire le eccezioni. Consentendo l'esecuzione delle richieste SQL in qualsiasi momento (ad es. Quando si è pigri carichi), si delega il ruolo di gestione delle eccezioni del database al livello superiore, vale a dire il livello aziendale o anche l'applicazione. Una brutta abitudine.

L'utilizzo di POCO ti costringe a caricare con entusiasmo le tue entità, molto meglio IMO.

Chi automapper

AutoMapper è uno strumento che permette di convertire automagicamente Entità a pocos e vice versa et. Non mi piace neanche. Vedi https://stackoverflow.com/a/32459232/870604

4

Ho una contro-domanda: perché non entrambi?

Considerare qualsiasi applicazione MVC arbitraria. Nel livello del modello e del controller in genere si desidera utilizzare gli oggetti EF. Se li hai definiti utilizzando Code First, in sostanza hai definito come vengono utilizzati nell'applicazione prima e poi hai progettato il tuo livello di persistenza per salvare con precisione le modifiche necessarie nell'applicazione.

Ora considera la possibilità di servire questi oggetti al livello Vista. Le visualizzazioni possono o potrebbero non riflettere i tuoi oggetti, o una aggregazione dei tuoi oggetti di lavoro. Questo spesso porta a POCOS/DTO che catturano tutto ciò che è necessario nella vista. Un altro scenario è quando si desidera pubblicare oggetti in un servizio Web. Molti framework forniscono serializzazione semplice su classi poco, nel qual caso tipicamente è necessario 1) annotare le classi EF o 2) creare DTO.

Inoltre, qualsiasi caricamento lento che si può avere sulle classi EF viene perso quando si utilizza POCOS o si chiude il contesto.

+0

Mi hai fatto pensare a questo. Il mio punto di vista è di POCO, il mio amico va per EF. La risposta di @ken2k è esattamente ciò che volevo sentire, ma ora ho bisogno di rivederlo con il mio amico. Grazie Richard. – xmorera