NHibernate - Caricamento lento
In questo capitolo tratteremo la funzione di caricamento lento. È un concetto completamente diverso per impostazione predefinita e NHibernate non ha un caricamento lento, ad esempio se carichi un cliente, non caricherà tutti gli ordini.
Il ritiro dell'ordine verrà caricato su richiesta.
Qualsiasi associazione, sia essa molti-a-uno o una raccolta caricata in modo pigro per impostazione predefinita, richiede un'estensione Open ISession.
Se hai chiuso la sessione o se hai eseguito il commit della transazione, puoi ottenere un'eccezione di caricamento lazy che non può inserire quegli oggetti aggiuntivi.
Devi stare attento al caricamento lento e alla quantità di dati di cui hai effettivamente bisogno.
Puoi disattivare il caricamento lento per un'intera associazione oppure puoi mettere lazy uguale a false oppure puoi anche specificare una strategia di recupero.
Ecco il file Program.cs implementazione del file.
using System;
using System.Data;
using System.Linq;
using System.Reflection;
using HibernatingRhinos.Profiler.Appender.NHibernate;
using NHibernate.Cfg;
using NHibernate.Dialect;
using NHibernate.Driver;
using NHibernate.Linq;
namespace NHibernateDemo {
internal class Program {
private static void Main() {
var cfg = ConfigureNHibernate();
var sessionFactory = cfg.BuildSessionFactory();
Guid id;
using(var session = sessionFactory.OpenSession())
using(var tx = session.BeginTransaction()) {
var newCustomer = CreateCustomer();
Console.WriteLine("New Customer:");
Console.WriteLine(newCustomer);
session.Save(newCustomer);
id = newCustomer.Id;
tx.Commit();
}
using(var session = sessionFactory.OpenSession())
using(var tx = session.BeginTransaction()) {
var reloaded = session.Load<Customer>(id);
Console.WriteLine("Reloaded:");
Console.WriteLine(reloaded);
Console.WriteLine("The orders were ordered by: ");
foreach (var order in reloaded.Orders) {
Console.WriteLine(order.Customer);
}
tx.Commit();
}
Console.WriteLine("Press <ENTER> to exit...");
Console.ReadLine();
}
private static Customer CreateCustomer() {
var customer = new Customer {
FirstName = "John",
LastName = "Doe",
Points =100,
HasGoldStatus = true,
MemberSince = new DateTime(2012, 1, 1),
CreditRating = CustomerCreditRating.Good,
AverageRating = 42.42424242,
Address = CreateLocation()
};
var order1 = new Order { Ordered = DateTime.Now };
customer.AddOrder(order1);
var order2 = new Order {
Ordered = DateTime.Now.AddDays(-1),
Shipped = DateTime.Now,
ShipTo = CreateLocation()
};
customer.AddOrder(order2); return customer;
}
private static Location CreateLocation() {
return new Location {
Street = "123 Somewhere Avenue",
City = "Nowhere",
Province = "Alberta",
Country = "Canada"
};
}
private static Configuration ConfigureNHibernate() {
NHibernateProfiler.Initialize();
var cfg = new Configuration();
cfg.DataBaseIntegration(x => {
x.ConnectionStringName = "default";
x.Driver<SqlClientDriver>();
x.Dialect<MsSql2008Dialect<();
x.IsolationLevel = IsolationLevel.RepeatableRead;
x.Timeout = 10;
x.BatchSize = 10;
});
cfg.SessionFactory().GenerateStatistics();
cfg.AddAssembly(Assembly.GetExecutingAssembly());
return cfg;
}
}
}Per capirlo, eseguiamo l'applicazione e diamo un'occhiata a NHibernate Profiler.
Come puoi vedere, abbiamo il Seleziona da cliente, dato un particolare ID cliente e poi abbiamo anche un'altra tabella Seleziona da ordini, quando accede effettivamente alla raccolta di quel cliente.
Quindi abbiamo 2 viaggi di andata e ritorno al database. Ora, a volte, vorremmo ottimizzarlo. Per fare questo, andiamo alcustomer.hbm.xml file e aggiungi una strategia di recupero e chiedigli di eseguire un recupero di join.
<?xml version = "1.0" encoding = "utf-8" ?>
<hibernate-mapping xmlns = "urn:nhibernate-mapping-2.2" assembly = "NHibernateDemo"
namespace = "NHibernateDemo">
<class name = "Customer">
<id name = "Id">
<generator class = "guid.comb"/>
</id>
<property name = "FirstName"/>
<property name = "LastName"/>
<property name = "AverageRating"/>
<property name = "Points"/>
<property name = "HasGoldStatus"/>
<property name = "MemberSince" type = "UtcDateTime"/>
<property name = "CreditRating" type = "CustomerCreditRatingType"/>
<component name = "Address">
<property name = "Street"/>
<property name = "City"/>
<property name = "Province"/>
<property name = "Country"/>
</component>
<set name = "Orders" table = "`Order`" cascade = "all-delete-orphan"
fetch = "join">
<key column = "CustomerId"/>
<one-to-many class = "Order"/>
</set>
</class>
</hibernate-mapping>Come puoi vedere che non abbiamo modificato alcun codice nella nostra applicazione, abbiamo appena aggiunto una strategia di recupero nel file customer.hbm.xml. Eseguiamo di nuovo questa applicazione, si comporta ancora esattamente allo stesso modo. Diamo un'occhiata a NHibernate Profiler.
Prima, il programma aveva due viaggi di andata e ritorno al database, ora ne ha solo uno e questo perché qui sta facendo un join esterno sinistro.
Possiamo vedere che sta eseguendo un join esterno sinistro tra la tabella dei clienti e la tabella degli ordini in base all'ID cliente e, quindi, è in grado di caricare tutte quelle informazioni contemporaneamente.
Abbiamo salvato 1 viaggio di andata e ritorno nel database.
Il lato negativo è che le informazioni sul cliente verranno duplicate su entrambe le righe e questo è il modo in cui funziona un join esterno sinistro SQL.
Quindi, con la strategia di recupero, stiamo ritirando un po 'più di dati e stiamo salvando un roundtrip.
Puoi anche farlo a livello di query, quindi andiamo al Program.cs file e guarda l'esempio più semplice ricaricato.
using(var session = sessionFactory.OpenSession())
using(var tx = session.BeginTransaction()) {
//var query = from customer in session.Query<Customer>()
// select customer;
//var reloaded = query.Fetch(x => x.Orders).ToList();
var reloaded = session.Load<Customer>(id);
Console.WriteLine("Reloaded:");
Console.WriteLine(reloaded);
Console.WriteLine("The orders were ordered by: ");
foreach (var order in reloaded.Orders) {
Console.WriteLine(order.Customer);
}
tx.Commit();
}Qui stiamo facendo un carico da parte del cliente. Ora cambiamolo in una query e useremo una query di collegamento come mostrato nel codice seguente.
using(var session = sessionFactory.OpenSession())
using(var tx = session.BeginTransaction()) {
var query = from customer in session.Query<Customer>()
where customer.Id == id select customer;
var reloaded = query.Fetch(x => x.Orders).ToList().First();
Console.WriteLine("Reloaded:");
Console.WriteLine(reloaded);
tx.Commit();
}Rimuoviamo anche la strategia di recupero dal file customer.hbm.xml file.
<?xml version = "1.0" encoding = "utf-8" ?>
<hibernate-mapping xmlns = "urn:nhibernate-mapping-2.2" assembly = "NHibernateDemo"
namespace = "NHibernateDemo">
<class name = "Customer">
<id name = "Id">
<generator class = "guid.comb"/>
</id>
<property name = "FirstName"/>
<property name = "LastName"/>
<property name = "AverageRating"/>
<property name = "Points"/>
<property name = "HasGoldStatus"/>
<property name = "MemberSince" type = "UtcDateTime"/>
<property name = "CreditRating" type = "CustomerCreditRatingType"/>
<component name = "Address">
<property name = "Street"/>
<property name = "City"/>
<property name = "Province"/>
<property name = "Country"/>
</component>
<set name = "Orders" table = "`Order`" cascade = "all-delete-orphan">
<key column = "CustomerId"/>
<one-to-many class = "Order"/>
</set>
</class>
</hibernate-mapping>Eseguiamo nuovamente questa applicazione e vedrai il seguente output.
New Customer:
John Doe (00000000-0000-0000-0000-000000000000)
Points: 100
HasGoldStatus: True
MemberSince: 1/1/2012 12:00:00 AM (Unspecified)
CreditRating: Good
AverageRating: 42.42424242
Orders:
Order Id: 00000000-0000-0000-0000-000000000000
Order Id: 00000000-0000-0000-0000-000000000000
Reloaded:
John Doe (6ebacd17-f9ba-4ad8-9817-a5bb01112a5a)
Points: 100
HasGoldStatus: True
MemberSince: 1/1/2012 12:00:00 AM (Utc)
CreditRating: Good
AverageRating: 42.4242
Orders:
Order Id: 16a6596b-d56e-41c7-9681-a5bb01112a60
Order Id: d41d615b-0f21-4032-81db-a5bb01112a61
Press <ENTER> to exit...Ora diamo un'occhiata a NHibernate Profiler, puoi vedere che abbiamo questo recupero del join impaziente che si verifica ancora una volta, ma questa volta è basato sulla query.
