Entity Framework 4 - AddObject vs Attach

Ich arbeite mit Entity Framework 4 seit kurzem und bin etwas verwirrt, als bei der Verwendung ObjectSet.Befestigenund ObjectSet.AddObject.

Aus meinem Verständnis:

Verwenden Sie "Anhängen", wenn ein Unternehmen schon im system vorhanden ist
Verwenden "AddObject", wenn die Schaffung einer Marke neue Person

So, wenn ich mich erstellen einer neuen PersonTue ich dies.

var ctx = new MyEntities();
var newPerson = new Person { Name = "Joe Bloggs" };
ctx.Persons.AddObject(newPerson);
ctx.SaveChanges();

Wenn ich ändern einer vorhandenen PersonTue ich dies:

var ctx = new MyEntities();
var existingPerson = ctx.Persons.SingleOrDefault(p => p.Name = "Joe Bloggs" };
existingPerson.Name = "Joe Briggs";
ctx.SaveChanges();

Beachten Sie, dies ist ein sehr einfach Beispiel. In Wirklichkeit bin ich Reine POCO ' s (keine code-generation), Repository-pattern (befassen sich nicht mit ctx.Personen), und die Arbeitseinheit (befassen sich nicht mit ctx.SaveChanges). Aber "unter der Haube", die oben ist was passiert in meiner Implementierung.

Nun meine Frage - ich bin noch zu finden, ein Szenario, wo ich zu verwenden habe Befestigen.

Was vermisse ich hier? Wann müssen wir die Verwendung Befestigen?

BEARBEITEN

Nur zur Klarstellung, ich bin auf der Suche nach Beispiele der Verwendung von Anhängen über AddObject (oder Umgekehrt).

EDIT 2

Den unten Antwort richtig ist (was ich akzeptiert), aber dachte, ich würde hinzufügen, ein weiteres Beispiel, wo Befestigen nützlich wäre.

In meinem obigen Beispiel für ändern einer vorhandenen Person zwei Abfragen tatsächlich ausgeführt wird.

Eine zum abrufen der Person (.SingleOrDefault), und ein weiteres, um das UPDATE durchzuführen (.SaveChanges).

Wenn (aus irgendeinem Grund), ich wusste schon, dass "max Mustermann" existiert im system, warum eine zusätzliche Abfrage, um ihn zuerst? Ich konnte dies tun:

var ctx = new MyEntities();
var existingPerson = new Person { Name = "Joe Bloggs" };
ctx.Persons.Attach(existingPerson);
ctx.SaveChanges();

Dies wird im Ergebnis nur eine UPDATE-Anweisung ausgeführt wird.

InformationsquelleAutor der Frage RPM1984 | 2010-10-13

.net c#crud entity-framework-4

147

ObjectContext.AddObject und ObjectSet.AddObject:

Die AddObject Methode für das hinzufügen der neu erzeugte Objekte, die nicht in der Datenbank vorhanden. Die Einheit erhalten Sie eine automatisch generierte temporäre EntityKey und seine
EntityState auf Hinzugefügt. Wenn SaveChanges aufgerufen wird, wird klar, dass der EF aus, dass diese Einheit muss in die Datenbank eingefügt.

ObjectContext.Befestigen und ObjectSet.Anfügen:

Auf der anderen Seite Befestigen wird verwendet für Personen, die bereits existieren in der Datenbank. Anstatt die Einstellung
EntityState Hinzugefügt, Befestigen Ergebnisse in einer Unverändert EntityState, was bedeutet, es hat sich nicht geändert, da es angebracht war, auf den Kontext. Objekte, die Sie anbringen, sind davon ausgegangen, dass in der Datenbank vorhanden. Wenn Sie ändern die Objekte werden, nachdem Sie zugewiesen wurden, wenn Sie die SaveChanges aufrufen der Wert der EntityKey verwendet wird, zu aktualisieren (oder löschen) die entsprechende Zeile von der Suche der passenden ID in der db-Tabelle.

Außerdem, mithilfe der Attach-Methode können Sie festlegen, Beziehungen zwischen Entitäten, die bereits in der ObjectContext-aber das haben nicht wurde automatisch verbunden. Im Grunde der Hauptzweck Befestigen, ist eine Verbindung zu Personen, die bereits mit der ObjectContext und sind nicht neue, so dass Sie nicht verwenden können, Anfügen aus, um Personen, deren EntityState Hinzugefügt wird. Verwenden Sie Add() in diesem Fall.

Zum Beispiel, nehmen wir an, Ihre Person zu Person hat eine navigation-Eigenschaft mit dem Namen Adressen das ist eine Sammlung von Adresse Einheit. Lassen Sie uns sagen Sie, dass Sie gelesen haben, beide Objekte aus dem Kontext, aber Sie sind nicht miteinander verwandt sind und Sie wollen es so machen:
```
var existingPerson = ctx.Persons.SingleOrDefault(p => p.Name = "Joe Bloggs" };
var myAddress = ctx.Addresses.First(a => a.PersonID != existingPerson.PersonID);
existingPerson.Addresses.Attach(myAddress);
//OR:
myAddress.PersonReference.Attach(existingPerson)
ctx.SaveChanges();
```
InformationsquelleAutor der Antwort Morteza Manavi
23

Dies ist eine späte Antwort, aber es könnte helfen, andere, die finden diese.

Grundsätzlich "getrennt" Entität kann passieren, wenn Sie manipulieren, eine Entität außerhalb der "using" - Bereich.
```
Employee e = null;

using (var ctx = new MyModelContainer())
{
     e = ctx.Employees.SingleOrDefault(emp => emp .....);
}

using (var ctx2 = new MyModelContainer())
{
     e; //This entity instance is disconnected from ctx2
}
```
Wenn Sie einem anderen geben "using" - Bereich, dann die "e" - variable wird getrennt werden, denn es gehört zu der vorherigen "mit" Umfang und seit dem letzten "mit" Umfang zerstört wird, dann "e" getrennt ist.

Das ist, wie ich es verstehe.

InformationsquelleAutor der Antwort TchiYuan
6

Dies ist ein Zitat aus Programming Entity Framework: DbContext

Aufruf Entfernen, auf eine Entität, die
nicht nachverfolgt wird, durch den Kontext bewirkt eine InvalidOperationException geworfen werden. Die
Entity Framework löst diese Ausnahme aus, da es nicht klar ist, ob die Entität, die Sie
versuchen, Sie zu entfernen, ist eine bereits vorhandene Entität, die markiert werden soll für die Löschung oder eine neue
Entität, die sollten einfach ignoriert werden. Aus diesem Grund können wir nicht verwenden, Entfernen Sie einfach markieren
getrennte Entität, die als Gelöscht; wir müssen, Befestigen Sie es zuerst.
```
private static void TestDeleteDestination()
{
    Destination canyon;
    using (var context = new BreakAwayContext())
    {
        canyon = (from d in context.Destinations
        where d.Name == "Grand Canyon"
        select d).Single();
    }
    DeleteDestination(canyon);
}
private static void DeleteDestination(Destination destination)
{
    using (var context = new BreakAwayContext())
    {
        context.Destinations.Attach(destination);
        context.Destinations.Remove(destination);
        context.SaveChanges();
    }
}
```
Den TestDeleteDestination Methode simuliert eine client-Anwendung, die das abrufen einer vorhandenen
Ziel vom server und dann an die DeleteDestination Methode auf
die server. Die DeleteDestination Methode verwendet die Methode zum Anfügen zu lassen, den Kontext
wissen, dass es ist ein vorhandenes Ziel. Dann die Remove-Methode wird verwendet, um zu registrieren
vorhandenes Ziel für die Löschung

InformationsquelleAutor der Antwort Teoman shipahi

-8

Was ist nur mit Bezug auf den Primärschlüssel anstelle von anfügen?

ich.e:

var existingPerson = ctx.Persons.SingleOrDefault(p => p.Name = "Joe Bloggs" };
var myAddress = ctx.Addresses.First(a => a.PersonID != existingPerson.PersonID);
existingPerson.AddressId = myAddress.Id //not -> existingPerson.Addresses.Attach(myAddress);
//OR:
myAddress.Person.Id = existingPerson.Id //not -> myAddress.PersonReference.Attach(existingPerson);
ctx.SaveChanges();

InformationsquelleAutor der Antwort Dan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.