Entity Framework 4 - AddObject vs Attach

Question

He estado trabajando recientemente con Entity Framework 4, y estoy un poco confundido sobre cuándo usar ObjectSet.Attach y ObjectSet.AddObject.

Desde mi entendimiento:

• Uso "Adjuntar" cuando una entidad ya existe en el sistema
• Uso "AddObject" al crear una marca nueva Entidad

lo tanto, si i' m creando una nueva Persona, hago esto.

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

si estoy modificación de una persona existente, hago esto:

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

tener en cuenta, este es un ejemplo muy simple. En realidad estoy usando Pure POCO (sin generación de código), el patrón Repository (no se ocupan de ctx.Persons), y la Unidad de trabajo (no se ocupan de ctx.SaveChanges). Pero "debajo de las sábanas", lo anterior es lo que sucede en mi implementación.

Ahora, mi pregunta - Todavía tengo que encontrar un escenario en el que he tenido que usar Acople.

¿Qué es lo que falta aquí? ¿Cuándo necesitamos usar Adjuntar?

EDITAR

Solo para aclarar, estoy buscando ejemplos de cuándo utilizar Adjuntar sobre AddObject (o viceversa).

EDIT 2

La respuesta a continuación es correcta (que acepté), pero que me gustaría añadir otro ejemplo donde Adjuntar sería útil.

En mi ejemplo anterior para modificando una Persona existente, se están ejecutando dos consultas.

Uno para recuperar la Persona (.SingleOrDefault), y otro para realizar la ACTUALIZACIÓN (.SaveChanges).

Si (por alguna razón), ya sabía que "Joe Bloggs" existía en el sistema, ¿por qué hacer una consulta adicional para obtenerlo primero? Podría hacer esto:

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

Esto dará como resultado que solo se ejecute una instrucción UPDATE.

Answer 1

ObjectContext.AddObject y ObjectSet.AddObject:
El AddObject método es para la adición de objetos recién creados que hacen no existen en la base de datos.La entidad obtendrá un EntityKey temporal generado automáticamente y su EntityState se establecerá en Se agregó. Cuando se llama a SaveChanges, el EF tendrá claro que esta entidad debe insertarse en la base de datos.

ObjectContext.Attach y ObjectSet.Attach:
Por otro lado, Acople se utiliza para las entidades que ya existan en la base de datos. En lugar de establecer la EntityState a Agregado, Adjuntar resultados en una Sin cambios EntityState, lo que significa que no ha cambiado desde que se adjunta al contexto. Se supone que los objetos que está adjuntando existen en la base de datos. Si modifica los objetos después de que se han adjuntado, cuando llama a SaveChanges, el valor de EntityKey se usa para actualizar (o eliminar) la fila adecuada al encontrar su ID coincidente en la tabla db.

Además, utilizando el método Adjuntar, puede definir las relaciones entre las entidades que ya existen en el ObjectContext pero que tienen no han conectado automáticamente. Básicamente, el objetivo principal de Attach es conectar entidades que ya están asociadas al ObjectContext y que no son , no nuevas, por lo que no puede usar Adjuntar para adjuntar entidades cuyo EntityState está agregado. Tienes que usar Add() en este caso.

Por ejemplo, vamos a asumir que su entidad Persona tiene una propiedad de navegación llamado Direcciones que es una colección de Dirección entidad. Digamos que usted ha leído los dos objetos de contexto, pero que no están relacionados entre sí y que desea que sea así:

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(); 

Answer 2

¿Qué pasa solamente refiriéndose a la clave principal en lugar de fijarlo?

es decir:

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(); 

Answer 3

Ésta es una respuesta tardía pero podría ayudar a otros que encuentran esto.

Básicamente, una entidad "desconectado" puede ocurrir cuando se manipula una entidad fuera de la "usando" ámbito.

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 
} 

Si introduce otro "por medio de" alcance a continuación, la "e" variable se desconecta porque pertenece a la anterior "utilizando" el alcance y desde la anterior "El uso de" alcance se destruye a continuación "e" se desconecta .

Así es como lo entiendo.

Answer 4

Esta es una cita de Programming Entity Framework: DbContext

Calling Eliminar en una entidad que no es seguido por el contexto, se producirá un InvalidOperationException a ser lanzado.El Entity Framework arroja esta excepción porque no está claro si la entidad que está intentando eliminar es una entidad existente que debe marcarse para su eliminación o una nueva entidad que simplemente debe ignorarse. Por este motivo, no podemos usar simplemente Eliminar para marcar una entidad desconectada como Eliminada; tenemos que adjuntarlo primero.

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(); 
    } 
} 

El método TestDeleteDestination simula una aplicación cliente ir a buscar un destino existente desde el servidor y luego pasarlo al método DeleteDestination en el servidor. El método DeleteDestination utiliza el método Attach para que el contexto sepa que es un Destino existente. Luego, el método Remove se usa para registrar el Destination para su eliminación