Entity Framework: Auf welche Nachteile kann ich stoßen, wenn ich meinen Objektkontext nicht beseitige?

Question

EDIT: Doppelte vonShould Entity Framework Context be Put into Using Statement?

Ich habe um diese Idee zu werfen einige Zeit zu fragen, was schlecht durch nicht ordnungsgemäß entsorgen meinen Objektkontext passieren könnte, und ermöglicht es mit dem GC zu sterben. Normalerweise würde ich das meiden, aber es gibt einen triftigen Grund dafür.

Wir verwenden Teilklassen. In diesen partiellen Klassen legen wir Eigenschaften offen, die auf FK-Objekte zugreifen. Angenommen, ich habe eine Customer-Klasse mit einem CustomerType FK-Objekt. In der Klasse, würde ich eine CustomerTypeName Eigenschaft aussetzen, das dies tut:

public string CustomerTypeName { 
    get { 
    if (CustomerType == null) { 
     CustomerTypeReference.Load() 
    } 

    return CustomerType.CustomerTypeName; 
    } 
} 

Dies funktioniert sehr praktisch, wenn die ursprüngliche Abfrage nicht .INCLUDE („Customer“) zu tun hat.

Wenn ich jedoch den Kontext entsorgt, funktioniert die obige Eigenschaft nicht mehr. Also ... ich denke, das führt zu ein paar Fragen:

1) Wenn ich nie explizit über den Kontext verfüge, welche Negative werde ich sehen, wenn überhaupt?
2) Gibt es einen anderen Weg, um Lazy Loading im obigen Szenario zu erreichen und den Kontext noch zu beseitigen?

Answer 1

Well ObjectContext, die auf unbestimmte Zeit verlassen werden, sind in Ordnung, solange Sie nicht viele neue Objekte laden/hinzufügen.

Jedes Objekt, das geladen oder hinzugefügt wird, wird immer durch den ObjectContext verfolgt, bis es entsorgt wird. Wenn Sie also keine Objekte löschen und weitere Objekte verfolgen, wird es immer größer und größer.

Eine Option, die Sie betrachten könnten, ist die Verwendung einer Hilfsmethode, um entweder auf einen bekannten Kontext zuzugreifen oder einen temporären Kontext zu erstellen.

Der Schlüssel dazu ist die Verwendung der EntityReference.EntityKey und stellen Sie sicher, dass beide Entitäten getrennt sind.

heißt

this.CustomerType = Utility.GetDetachedObjectByKey<Customer>(
     this.CustomerTypeReference.EntityKey); 

Die grundlegende Implementierung von GetDetachedObjectByKey ist so etwas wie diese:

public static T GetDetachedObjectByKey<T>(EntityKey key) 
    where T: EntityObject 
{ 
    using (MyContext ctx = new MyContext()) 
    { 
     T t = ctx.GetObjectByKey(key) as T; 
     ctx.Detach(t); 
     return t; 
    } 
} 

Dies funktioniert nur, wenn das ursprüngliche Zielobjekt zu gelöst wird. Sie können experimentieren mit, woher der von dieser Methode verwendete Kontext stammt.

this helps

Alex

Answer 2

Warum nicht den Kontext für die Länge des Bildschirms beibehalten?

Answer 3

In meinem answer bis 'LINQ to SQL - where does your DataContext live?' haben wir die Seite als Besitzer des DataContext für die Lebensdauer der Seite, und es ist die Seite, die den DataContext ordnungsgemäß entsorgt, wenn die Seite selbst entsorgt wird.

Wie @Chu darauf hinweist, ist es ein wenig schmutzig, aber wenn Sie verwenden, was wohl ein Datenübertragungsobjekt direkt in Ihrer Benutzeroberfläche ist, sollte Ihre Benutzeroberfläche die Lebensdauer des DataContext steuern.