Esecuzione di query e ricerca di entità

In questo argomento vengono illustrati i diversi modi in cui è possibile eseguire query sui dati usando Entity Framework, tra cui LINQ e il metodo Find. Le tecniche illustrate in questo argomento si applicano allo stesso modo ai modelli creati con Code First e Ef Designer.

Ricerca di entità tramite una query

DbSet e IDbSet implementano IQueryable e quindi possono essere usati come punto di partenza per la scrittura di una query LINQ sul database. Questo non è il posto appropriato per una discussione approfondita di LINQ, ma di seguito sono riportati alcuni semplici esempi:

using (var context = new BloggingContext())
{
    // Query for all blogs with names starting with B
    var blogs = from b in context.Blogs
                   where b.Name.StartsWith("B")
                   select b;

    // Query for the Blog named ADO.NET Blog
    var blog = context.Blogs
                    .Where(b => b.Name == "ADO.NET Blog")
                    .FirstOrDefault();
}

Si noti che DbSet e IDbSet creano sempre query sul database e comportano sempre un round trip al database anche se le entità restituite esistono già nel contesto. Una query viene eseguita sul database quando:

• Viene enumerato da un'istruzione foreach (C#) o For Each (Visual Basic).
• Viene enumerato da un'operazione di raccolta, ad esempio ToArray, ToDictionary o ToList.
• Gli operatori LINQ, ad esempio First o Any , vengono specificati nella parte più esterna della query.
• Vengono chiamati i metodi seguenti: il metodo di estensione Load in un oggetto DbSet, DbEntityEntry.Reload e Database.ExecuteSqlCommand.

Quando i risultati vengono restituiti dal database, gli oggetti che non esistono nel contesto vengono collegati al contesto. Se un oggetto è già nel contesto, viene restituito l'oggetto esistente (i valori correnti e originali delle proprietà dell'oggetto nella voce non vengono sovrascritti con i valori del database).

Quando si esegue una query, le entità aggiunte al contesto ma non sono ancora state salvate nel database non vengono restituite come parte del set di risultati. Per ottenere i dati presenti nel contesto, vedere Dati locali.

Se una query non restituisce righe dal database, il risultato sarà una raccolta vuota anziché null.

Ricerca di entità tramite chiavi primarie

Il metodo Find in DbSet usa il valore della chiave primaria per tentare di trovare un'entità rilevata dal contesto. Se l'entità non viene trovata nel contesto, verrà inviata una query al database per trovare l'entità. Se l'entità non viene trovata nel contesto o nel database, viene restituito Null.

La ricerca è diversa dall'uso di una query in due modi significativi:

• Verrà effettuato un accesso al database solo se l'entità con la chiave specificata non viene trovata nel contesto.
• Find restituirà le entità che si trovano nello stato Aggiunto. Ovvero, Find restituirà le entità aggiunte al contesto, ma non ancora salvate nel database.

Ricerca di un'entità in base alla chiave primaria

Il codice seguente illustra alcuni usi di Find:

using (var context = new BloggingContext())
{
    // Will hit the database
    var blog = context.Blogs.Find(3);

    // Will return the same instance without hitting the database
    var blogAgain = context.Blogs.Find(3);

    context.Blogs.Add(new Blog { Id = -1 });

    // Will find the new blog even though it does not exist in the database
    var newBlog = context.Blogs.Find(-1);

    // Will find a User which has a string primary key
    var user = context.Users.Find("johndoe1987");
}

Ricerca di un'entità in base alla chiave primaria composita

Entity Framework consente alle entità di avere chiavi composite, ovvero una chiave costituita da più di una proprietà. Ad esempio, è possibile avere un'entità BlogSettings che rappresenta le impostazioni di un utente per un blog specifico. Poiché un utente avrebbe solo uno BlogSettings per ogni blog, si potrebbe scegliere di impostare come chiave primaria di BlogSettings una combinazione di BlogId e NomeUtente. Il codice seguente tenta di trovare BlogSettings con BlogId = 3 e Username = "johndoe1987":

using (var context = new BloggingContext())
{
    var settings = context.BlogSettings.Find(3, "johndoe1987");
}

Si noti che quando si dispone di chiavi composite è necessario usare ColumnAttribute o l'API Fluent per specificare un ordinamento per le proprietà della chiave composita. La chiamata a Find deve utilizzare questo ordine quando si specificano i valori che formano la chiave.