Qual è la best practice per gli elenchi di sola lettura in NHibernate

Question

Il modello di dominio su cui sto lavorando ha aggregati radice e entità figlio. Qualcosa come il seguente codice:

class Order 
{ 
    IList<OrderLine> Lines {get;set;} 
} 

class OrderLine 
{ 
} 

Ora voglio la mia fine di controllare le linee. Qualcosa di simile:

class Order 
{ 
    OrderLine[] Lines {get;} 

    void AddLine(OrderLine line); 
} 

In questo momento stiamo utilizzando il seguente schema:

class Order 
{ 
    private IList<OrderLine> lines = new List<OrderLine>(); 
    OrderLine[] Lines {get {return this.lines;}} 

    void AddLine(OrderLine line) 
    { 
     this.orders.Add(line); 
    { 
} 

NHibernate viene mappato direttamente al campo linee.

Ora domande ...

• Cosa professi in tali situazioni?
• Qualcuno usa i metodi: public IEnumerable GetLines()
• Cosa si utilizza come tipo di ritorno per la proprietà? Può essere ReadOnlyCollection o IEnumerable;
• Forse questo non è il posto migliore per chiedere? Suggerisci per favore

Aggiornamento: Sembra vittorie IEnumerable, tuttavia la soluzione ancora non è perfetta ...

Answer 1

Il modello che uso è:

class Order 
{ 
    private List<OrderLine> lines = new List<OrderLine>(); 

    IEnumerable<OrderLine> Lines { get { return this.lines; } } 

    void AddLine(OrderLine line) 
    { 
     this.orders.Add(line); 
    } 
} 

Se stai usando NET 3.5 si ottiene tutto la ricerca funzionalità che potresti desiderare per IEnumerable usando LINQ e nascondi l'implementazione della raccolta.

Il problema con il ritorno OrderLine [] è che la tua collezione può essere modificata esternamente per esempio:

Order.Lines[0] = new OrderLine(). 

Answer 2

espongo collezioni ReadOnlyCollection e utilizzare metodi AddX e RemovEx per il mantenimento delle collezioni. Siamo passati a 3.5 e sto pensando di esporre invece IEnumerable. Nella maggior parte dei casi con NHibernate il bambino ha un riferimento al genitore in modo da esporre aggiungere e rimuovere i metodi consente di mantenere quel rapporto:

public void AddPlayer(Player player) 
    { 
     player.Company = this; 
     this._Players.Add(player); 
    } 

    public void RemovePlayer(Player player) 
    { 
     player.Company = null; 
     this._Players.Remove(player); 
    } 

Answer 3

Se sto esponendo un elenco che non deve essere modificato, allora io uso IEnumerable e yield. Trovo ingombrante cercando di utilizzare ReadOnlyCollections in collaborazione con NHiberante.

Con questo approccio, si ha ancora il campo delle righe private che viene mappato e popolato tramite NHibernate; tuttavia, l'accesso pubblico alla raccolta viene eseguito tramite iteratori. Non è possibile aggiungere o rimuovere dall'elenco sottostante con questa proprietà Lines.

Ad esempio:

public IEnumerable<OrderLine> Lines { 
    get { 
     foreach (OrderLine aline in lines) { 
      yield return aline; 
     } 
    } 
} 

Answer 4

lo faccio in questo modo:

public class Order 
{ 
     private ISet<OrderLine> _orderLines = new HashedSet<OrderLine>(); 

     public ReadOnlyCollection<OrderLine> OrderLines 
     { 
      get { return new List<OrderLine>(_orderLines).AsReadOnly(); } 
     } 

     public void AddOrderLine(OrderLine ol) 
     { 
      ... 
     } 
} 

Poi, offcourse, nella mappatura, NHibernate è stato detto di utilizzare il campo _orderLines:

<set name="OrderLine" access="field.camelcase-underscore" ... > 
... 
</set> 

Answer 5

Ho trascorso diversi giorni alla ricerca di un approccio migliore per le liste readonly in NHibernate. Questa discussione mi ha aiutato molto a formare quella che si adatta al nostro progetto.

C'è un approccio ho iniziato ad usare:

1. campi Backing vengono utilizzati per archiviare collezioni
2. IEnumerable < T> viene utilizzato per esporre le collezioni per costringere i clienti utilizzare AddLine() e RemoveLine() metodi .
3. Il tipo ReadOnlyCollection viene utilizzato in aggiunta a IEnumerable.

Codice:

public class Order 
{ 
    private readonly IList<OrderLine> lines = new List<OrderLine>(); 

    public virtual IEnumerable<OrderLine> Lines 
    { 
     get 
     { 
      return new ReadOnlyCollection<OrderLine>(lines); 
     } 
    } 

    public void AddLine(OrderLine line) 
    { 
     if (!lines.Contains(line)) 
     { 
      this.lines.Add(line); 
      line.Order = this; 
     } 
    } 

    public void RemoveLine(OrderLine line) 
    { 
     if (lines.Contains(line)) 
     { 
      this.lines.Remove(line); 
      line.Order = null; 
     } 
    } 
} 

public class OrderLine 
{ 
    public Order Order { get; set; } 
}