Da dove gli oggetti si fondono / unire i dati in un modello 3-tier?

Question

La sua probarbly un semplice problema di 3-tier. Voglio solo fare in modo che usiamo la migliore pratica per questo e io non sono che familiary con le strutture ancora.

Abbiamo i 3 livelli:

• GUI: ASP.NET per la presentazione-strato (prima piattaforma)
• BAL: Business-strato sarà la gestione della logica su un web server in C #, in modo che sia in grado di usarlo per webforms / MVC + webservices
• DAL: LINQ to SQL nel Data-layer, il ritorno non BusinessObjects LINQ.
• DB:. L'SQL sarà Microsoft SQL server / Express (havent deciso ancora)

Consente di pensare setup dove abbiamo un database di [persone]. Tutti possono avere più [indirizzo] ES e abbiamo un elenco completo di tutti [PostalCode] e corrispondenti citynames ecc.

L'accordo è che abbiamo unito un sacco di dettagli da altre tabelle.

{Relazioni} / [tabelle]

• [Person]: 1 --- N: {} PersonAddress: M --- 1: [indirizzo]
• [indirizzo]: N --- 1: [PostalCode]

Ora si vuole costruire il DAL per persona. Come dovrebbe l'aspetto PersonBO e quando lo fa i join occure? È un problema di business-layer per andare a prendere tutti i citynames e possibili addressses pr. Persona? o se il DAL completare tutto questo prima di restituire il PersonBO al BAL?

Class PersonBO 
{
    public int ID {get;set;}
    public string Name {get;set;}
    public List<AddressBO> {get;set;} // Question #1
} 

// Q1: facciamo a recuperare gli oggetti prima di restituire il PersonBO e dovrebbe essere un array, invece? o si tratta di totalmente sbagliato per n-tier / 3-tier ??

Class AddressBO 
{
    public int ID {get;set;}
    public string StreetName {get;set;}
    public int PostalCode {get;set;} // Question #2
} 

// Q2: non facciamo la ricerca o semplicemente lasciare il PostalCode per la ricerca successiva

?

Qualcuno può spiegare in quale ordine di tirare quali oggetti? Le critiche costruttive è molto gradito. : O)

Answer 1

Sei tipo di reinventare la ruota; ORM già risolvere la maggior parte di questo problema per voi e si sta andando a trovare un po 'difficile da fare da soli.

I ORM modo come LINQ to SQL, Entity Framework e NHibernate farlo è una tecnica chiamata lazy loading di associazioni (che può opzionalmente essere sovrascritte con un carico ansioso).

Quando si tira su un Person, non carica l'Address fino a quando non specificamente chiedere per essa, a quel punto un altro di andata e ritorno al database avviene (carico pigro). È inoltre possibile specificare su una base per-query che si desidera che il Address da caricare per tutti persona (carico ansioso).

In un certo senso, con questa domanda si sono fondamentalmente chiede se o non si dovrebbe svolgere carichi pigri o desiderosi di AddressBO per la PersonBO, e la risposta è: nessuno dei due. Non c'è un unico approccio che funziona universalmente. Per impostazione predefinita è necessario caricare probabilmente pigro, in modo che non si fa un sacco di inutili unisce; al fine di tirare fuori questo, dovrete costruire il vostro PersonBO con un meccanismo minimale di carico che mantiene qualche riferimento al DAL. Ma si vuole ancora avere la possibilità di ansioso-carico, che è necessario per costruire nella vostra logica di "business-accesso".

Un'altra opzione, se avete bisogno di tornare un dato altamente personalizzati impostati con proprietà specifiche popolate da molte tabelle differenti, è quello di non restituire un PersonBO a tutti, ma invece utilizzare un dati Transfer Object (DTO). Se si implementa un meccanismo di default lazy-carico, a volte è possibile sostituire questo come la versione ansioso-carico.

---

A proposito, Pale pigri framework di accesso di dati sono generalmente costruite con la logica di carico nella stessa associazione:

public class PersonBO
{
    public int ID { get; set; }
    public string Name { get; set; }
    public IList<AddressBO> Addresses { get; set; }
}

Questa è solo una POCO, la magia accade nella realizzazione elenco effettivo:

// NOT A PRODUCTION-READY IMPLEMENTATION - DO NOT USE

internal class LazyLoadList<T> : IList<T>
{
    private IQueryable<T> query;
    private List<T> items;

    public LazyLoadList(IQueryable<T> query)
    {
        if (query == null)
            throw new ArgumentNullException("query");
        this.query = query;
    }

    private void Materialize()
    {
        if (items == null)
            items = query.ToList();
    }

    public void Add(T item)
    {
        Materialize();
        items.Add(item);
    }

    // Etc.
}

(Questo ovviamente non è la produzione di qualità, è solo per dimostrare la tecnica;. Si inizia con una query e non si materializzano ha l'elenco fino ad avere a)