EF 4.1 Lazy Loading

[SkOrPiOn`87]

Ciao,

Io sto provando a disabilitare il lazy Loading in questo modo:

var contextDB = new VentiOttantaDB();
contextDB.Configuration.LazyLoadingEnabled = false;


Però non riesco a capire perchè quando eseguo questa query:


var subCatObj = (from SubCategory_Product t in contextDB.SubCategory_Products
where t.IDSubCategory == prodoctsDB.SubCategory
select t).SingleOrDefault();


if (subCatObj.Product!= null)
{
int ed = subCatObj.Product.Count;
}


subCatObj.Product <--- Non dovrebbe essere sempre a NULL con Lazy Loading disabilitato? Invece questo mi ritorna semrpe la collezione di tutti i prodotti


QUesto è il modo in cui ho mappato la classe:

public class SubCategory_Product
{
public string IDSubCategory { get; set; }
public string SubCategory { get; set; }
public string Ref_Category { get; set; }

public virtual Category_Product Category_Product { get; set; }

public virtual ICollection<Product> Product { get; set; }
}



Qualcuno mi può dare delle spiegazioni??? non ci capisco più niente...



Grazie

[djciko]

usa i tag CODE per favore, altrimenti non si distingue il testo dal codice.

[XWolverineX]

http://thedatafarm.com/blog/data-acc...oading-in-ef4/

[SkOrPiOn`87]

Questo articolo lo avevo già letto... (Ma si riferisce anche alla versione 4.0)

Ma non continuo ancora a capire che cosa devo far per caricare solo le SubCategory_Product senza farli caricare anche i Products associati...

var subCatObj = (from SubCategory_Product t in contextDB.SubCategory_Products
                          where t.IDSubCategory == prodoctsDB.SubCategory
                          select t).SingleOrDefault();

Questo è il codice che eseguo, e sia:

contextDB.Configuration.LazyLoadingEnabled = false;
che
contextDB.Configuration.LazyLoadingEnabled = true;

Non mi cambia niente...

[rsdpzed]

Ciao, non posso fare delle prove ora e non tocco ef da un po' perciò ti rispondo "a naso". Prendi tutto come un "dovrebbe essere..."

Il problema potrebbe essere qui:

var subCatObj = (from SubCategory_Product t in contextDB.SubCategory_Products
 where t.IDSubCategory == prodoctsDB.SubCategory
 select t).SingleOrDefault();
 

if (subCatObj.Product!= null) 
 {
 int ed = subCatObj.Product.Count;
 }

Prima dell'if tu non puoi vedere se i prodotti sono stati caricati o meno se non utilizzando sqlprofiler infatti con lazy abilitato o meno tu "costringi" EF a fare una query ai prodotti nel momento in cui gli chiedi il count. Finche non converti subcatobj in una collection (ToList()) il count lo fai attraverso EF (e quindi al db, che ti carica il grafo dei prodotti) e non con linq to object.

Per toglierti il pensiero senza sql-profiler, prova a mettere un ToList alla fine della query e vedere se continua ad entrare nell'IF. (Una volta che ti togli il pensiero puoi anche toglerlo e sei tranquillo che finche non gli chiedi qualcosa ai relativi prodotti lui non te li tocca)

Se invece ti serve comunque il count dei prodotti (o una qualsiasi aggregazione su di essi) ma non vuoi caricarne l'intero grafo:

var query= contextDB.SubCategory_Products
        .Where(c => c.IDSubCategory == categoria)                       
        .Collection(p => p.Product)                           
        .Query() //Da qui in poi puoi interrogare i prodotti senza caricarli                          
        .Count(); //occhio questo con le parentesi è il cont di linq!

[SkOrPiOn`87]

public class Category_Product
    {
        public string Category { get; set; }
        public ICollection<SubCategory_Product> SubCategory_Products { get; set; }
    }

    public class SubCategory_Product
    {
        public string IDSubCategory { get; set; }
        public string SubCategory { get; set; }
        public string Ref_Category { get; set; }
        public virtual Category_Product Category_Product { get; set; }
        public virtual ICollection<Product> Product { get; set; }
    }

modelBuilder.Entity<SubCategory_Product>().HasKey(c => c.IDSubCategory);
modelBuilder.Entity<SubCategory_Product>().HasRequired(c => c.Category_Product).WithMany().HasForeignKey(c => c.Ref_Category).WillCascadeOnDelete(false);

Ho notato che il comportamento anomalo avviene quando imposto la Foregin Key...

Senza questa impostata quando popolo il mio DB il campo Product dentro la tabella SubCategory_Product ha il valore impostato. Mentre se imposto la Foregin il valore è SEMPRE null.


Quindi il problema sta quando imposto la chiave esterna, ma non capisco il motivo...

Qualcuno ha mai provato ad utilizzarla??

[Gluck74]

Originariamente inviato da SkOrPiOn`87


if (subCatObj.Product!= null)
{
int ed = subCatObj.Product.Count;
}


subCatObj.Product <--- Non dovrebbe essere sempre a NULL con Lazy Loading disabilitato? Invece questo mi ritorna semrpe la collezione di tutti i prodotti

ciao,
nel momento in cui esegui la query, hai creato l'oggetto subCatObj INTERAMENTE popolato nel caso standard, ovvero le sue proprietà che sono collection, sono riempite.
Se disabiliti il LazyLoad, semplicemente hai l'oggetto semplice con le collection vuote (al momento) che vengono riempite appena chiamate in causa.
con l'istruzione

if (subCatObj.Product != null)

chiami in causa la collaction Product (io cambierei il nome in Products), che viene popolata, quindi non sarà mai null (a meno che non ci siano prodotti da associare).

ecco perché devi seguire il consiglio di rsdpzed
Spero di averti chiarito la questione

[SkOrPiOn`87]

Vi ringrazio per il chiarimento ed in efeftti anche a me torna come dite voi...


Il problema è che se abilito questa:

modelBuilder.Entity<SubCategory_Product>().HasRequ ired(c => c.Category_Product).WithMany().HasForeignKey(c => c.Ref_Category).WillCascadeOnDelete(false);



Cambia completamente il comportamento e non ci capisco niente, quindi risolvo togliendo il mapping di questa relazione... anche se non capisco il motivo...



Grazie

[Gluck74]

io ho perso un attimo il focus sul problema.

quale risultato vuoi?
vuoi che non vengano caricati i prodotti?
vuoi che non venga eseguita la query?
non ho ben capito

[SkOrPiOn`87]

modelBuilder.Entity<SubCategory_Product>().HasRequ ired(c => c.Category_Product).WithMany().HasForeignKey(c => c.Ref_Category).WillCascadeOnDelete(false);

Se imposto questo codice, sia che metto a true o false il Lazy, non cambia niente i dati veniva sempre caricati

Io non voglio che vengano caricati infatti imposto il Lazy a false e non ho problemi (perchè con il Lazy a False l'unico modo che ho di recuperare i dati nella Collecction è di scrivere la query con Include() ), quindi adesso è tutto OK... Ma per ottenere questo ho dovuto eliminare il codice che ho postato qualche riga qua sopra...