Creare un'istanza di un contesto in LINQ per le entità

Question

Ho visto due modi diversi che i programmatori affrontano quando creano un contesto di entità nel loro codice.

Il primo è simile e puoi trovarlo in tutti gli esempi di codice MSDN:

public void DoSomething() {
     using (TaxableEducationEntities context = new TaxableEducationEntities()) {
          // business logic and whatever else
     }
}

Il secondo è creare il contesto come attributo privato in una classe che incapsula la tua logica aziendale. Quindi avresti qualcosa del tipo:

public class Education_LINQ {

        private TaxableEducationEntities context = new TaxableEducationEntities();

        public void DoSomething() {
            var result = from a in context.luAction
                         select a;

            // business logic and whatever else
        }
}

In che modo è più efficiente?

Supponi di avere due metodi, uno chiamato DoSomething1 () e un altro chiamato DoSomething2 (), ed entrambi i metodi incorporano l'istruzione using per aprire il contesto e fare qualunque cosa con esso. Se dovessi chiamare un metodo dopo l'altro, ci sarebbe un sovraccarico inutile in corso, dal momento che essenzialmente entrambi i metodi creano il contesto e poi lo puliscono quando hanno finito? Al contrario di avere un solo attributo privato che viene creato quando viene istanziato un oggetto di classe, e poi a sua volta ripulito quando l'oggetto esce dall'ambito?

Answer 1

La creazione di un nuovo ObjectContext ogni volta comporta un sovraccarico 'alcuni'. Sostanzialmente l'overhead coinvolto sta copiando i metadati da una cache globale in metadati associati allo specifico ObjectContext.

Questo sovraccarico è relativamente minore, quindi spesso non vale la pena preoccuparsi, specialmente se si considera la sicurezza aggiuntiva inerente al modello di utilizzo.

Per me quale opzione scegli dipende da cose come:

1. Da quanto tempo vivi classe di avvolgimento probabilmente? Se vive per a molto tempo potrebbe ObjectContext crescere per contenere molte entità rallentando nel tempo. Quindi un nuovo ObjectContext ogni volta potrebbe essere un buona idea.
2. Sono chiamate al metodi sulla classe di wrapping sincronizzato? ObjectContext la stessa classe non è thread-safe quindi se usi il secondo modello che ti serve per assicurarsi che la classe di avvolgimento / repository è sicuro per i thread, se lo desideri si aspettano che più thread lo chiamino.
3. I metodi sono essenzialmente non correlato? In tal caso, potresti ottenere effetti collaterali imprevisti se condividono un contesto tra i metodi.

In generale la mia raccomandazione è che se i metodi sono apolidi, vale a dire sparare e dimenticare un nuovo contesto per ogni metodo è probabilmente una buona idea.

Se tuttavia hai una forma stateful relativamente breve o qualcosa del genere, forse un contesto condiviso è un'idea migliore.

AGGIORNAMENTO: ho impiegato del tempo per mettere insieme una risposta più completa

Answer 2

La seconda opzione in realtà non pulisce dopo se stessa se questo è ciò che intendi. Preferisco usare la versione di ObjectContext ogni volta perché non devo eliminarla dopo. Non sono sicuro di aver capito bene la domanda però ... Troppe ore di programmazione oggi.

public class UserManagerRepository : IUserManagerRepository, IDisposable
{
    private readonly Entities _context = new Entities();
    private bool _disposed;

    public User Create(User user, int countryId)
    {
        user.Country = GetCountry(countryId);
        _context.AddToUser(user);
        _context.SaveChanges();
        return user;
    }
}

Quindi per usare questo repository faccio qualcosa del tipo:

using(var repository = new UserManagerRepository())
{
    repository.Create(user);
}