EntityFramework carica / aggiorna entità

A me, ti piace deviare dalle convenzioni sul codice framework dell'entità , vero?

(1) Definizioni di classi errate

Le relazioni tra le tue tabelle sono Elenchi, invece di ICollections, non sono dichiarati virtuali e hai dimenticato di dichiarare la chiave esterna

Esiste una relazione uno-a-molti tra Todo e Categoria: ogni Todo appartiene a una sola Category (usando una chiave straniera), ogni Categoria ha zero o più Todos.

Scegli di dare una proprietà a Categoria List<Todo> Todos {get; set;} . Sei sicuro che la category.Todos[4] ha un significato definito? E cosa significherebbe `category.Todos.Insert (4, new Todo ())?

Meglio attenersi a un'interfaccia in cui non è possibile utilizzare funzioni che non hanno un significato corretto nel database: utilizzare `ICollection Todos {get; impostato;}. In questo modo avrai accesso solo alle funzioni che Entity Framework può tradurre in SQL.

Inoltre, una query sarà probabilmente più veloce: offrite al framework di entità la possibilità di interrogare i dati nel modo più efficiente, invece di forzarli a mettere il risultato in una lista.

Nel framework di entità le colonne di una tabella sono rappresentate da proprietà non virtuali; le proprietà virtuali rappresentano le relazioni tra le tabelle (uno-a-molti, molti-a-molti)

public class Category
{
    public int Id { get; set; }
    public string Name { get; set; }
    ... // other properties

    // every Category has zero or more Todos (one-to-many)
    public virtual ICollection<Todo> Todos  { get; set; }
}

public class Todo
{
    public int Id { get; set; }
    public string Content { get; set; }
    ... // other properties

    // every Todo belongs to exactly one Category, using foreign key
    public int CategoryId { get; set }
    public virtual Category Category { get; set; }

    // every Category has zero or more Infos:
    public virtual ICollection<Info> Infos { get; set; }
}

Probabilmente dovrai indovinare Info ora:

public class Info
{
    public int Id { get; set; }
    public string Value { get; set; }
    ... // other properties

    // every info belongs to exactly one Todo, using foreign key
    public int TodoId {get; set;}
    public virtual Todo Todo { get; set; }
}

Tre miglioramenti principali: ICollection, virtual, foreign key definition: sono colonne reali nelle tue tabelle.

(2) Usa Seleziona invece di Includi

Una delle parti più lente di una query del database è il trasporto dei dati selezionati dal sistema di gestione dei database al processo locale. Quindi è consigliabile limitare la quantità di dati trasportati.

Supponiamo che la Categoria con Id 4 abbia mille Todos. Ogni Todo avrà una chiave esterna per la categoria a cui appartiene con un valore 4. Quindi questo stesso valore 4 verrà trascritto 1001 volte. Che spreco!

Nel framework di entità utilizzare Seleziona invece di Includi per eseguire query sui dati e selezionare solo le proprietà che si prevede di utilizzare. Utilizzare solo Includi se si prevede di aggiornare i dati selezionati.

Dammi tutte le Categorie che ... con i loro Todos che ...

var results = dbContext.Categories
    .Where(category => ...)
    .Select(category => new
    {
         // only select properties that you plan to use
         Id = category.Id,
         Name = category.Name,
         ...

         Todos = category.Todos
             .Where(todo => ...)        // only if you don't want all Todos
             .Select(todo => new
             {
                 // again, select only the properties you'll plan to use
                 Id = todo.Id,
                 ...

                 // not needed, you know the value: CategoryId = todo.CategoryId

                 // only if you also want some infos:
                 Infos = todo.Infos
                    .Select(info => ....) // you know the drill by now
                    .ToList(),
            })
            .ToList(),
        });

(3) Non tenere vivo DbContext per così tanto tempo!

Un altro problema è che mantieni il tuo DbContext aperto per un po 'di tempo. Questo non è il significato di un dbContext. Se il tuo database cambia tra la tua query e il tuo aggiornamento, avrai dei problemi. Riesco a malapena a immaginare di interrogare così tanti dati che è necessario ottimizzarli mantenendo vivo il tuo dbContext. Anche se si esegue una query su molti dati, la visualizzazione di questa enorme quantità di dati sarebbe il collo di bottiglia, non la query del database.

È meglio recuperare i dati una volta, disporre di DbContext e, quando si aggiornano i dati di recupero, aggiornare le proprietà modificate e SaveChanges.

recupera dati:

RepositoryCategory FetchCategory(int categoryId)
{
     using (var dbContext = new MyDbContext())
     {
         return dbContext.Categories.Where(category => category.Id == categoryId)
            .Select(category => new RepositoryCategory
            {
                 ... // see above
            })
            .FirstOrDefault();
     }
}

Sì, avrai bisogno di una categoria di RepositoryCategory classe extra per questo. Il vantaggio è che nascondi che hai recuperato i tuoi dati da un database. Il tuo codice cambierebbe difficilmente se recuperi i tuoi dati da un file CSV o da Internet. Questo è il modo migliore testabile e anche il modo più gestibile: se la tabella delle categorie nel tuo database cambia, gli utenti della tua RepositoryCategory non se ne accorgeranno.

Prendi in considerazione la creazione di uno spazio dei nomi speciale per i dati recuperati dal tuo database. In questo modo è possibile chiamare la categoria di categoria recuperata, invece di RepositoryCategory. Puoi persino nascondere meglio da dove hai prelevato i tuoi dati.

Torna alla tua domanda

Hai scritto:

Ora stavo cercando di caricare solo i Todos che provengono dall'attuale utente

Dopo i precedenti miglioramenti, sarà facile:

string owner = Settings.User; // or something similar
var result = dbContext.Todos.Where(todo => todo.Owner == owner)
    .Select(todo => new 
    {
         // properties you need
    })