Entity Framework 4 - AddObject vs Attach

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

Desde mi entendimiento:

• Use "Adjuntar" cuando ya exista una entidad en el sistema
• Use "AddObject" al crear una nueva entidad

Entonces, si estoy 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 modificando 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();

Tenga en cuenta que este es un ejemplo muy simple . En realidad estoy usando Pure POCO's (sin generación de código), patrón de repositorio (no trate con ctx.Persons) y Unit of Work (no trate con ctx.SaveChanges). Pero "bajo las sábanas", lo anterior es lo que sucede en mi implementación.

Ahora, mi pregunta : todavía no he encontrado un escenario en el que haya tenido que usar Attach .

que me estoy perdiendo aqui? ¿Cuándo necesitamos usar Attach?

EDITAR

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

EDITAR 2

La respuesta a continuación es correcta (que acepté), pero pensé que agregaría otro ejemplo donde Attach sería útil.

En mi ejemplo anterior para modificar 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? Yo 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.

ObjectContext.AddObject y ObjectSet.AddObject :
Elmétodo AddObject es para agregar objetos recién creados que no existen en la base de datos. La entidad obtendrá una EntityKey temporal generada automáticamentey su EntityState se establecerá en Agregado . Cuando se llama SaveChanges, el EF tendrá claro que esta entidad debe insertarse en la base de datos.

ObjectContext.Attach y ObjectSet.Attach :
por otro lado, Attach se usa para entidades que ya existen en la base de datos. En lugar de establecer EntityState en Agregado, Adjuntar da como resultado un Estado deentidad sin cambios , lo que significa que no ha cambiado desde que se adjuntó 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 hayan 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 Attach, puede definir relaciones entre entidades que ya existen en ObjectContext pero que tienenNo se ha conectado automáticamente. Básicamente, el propósito principal de Attach es conectar entidades que ya están adjuntas al ObjectContext y que no sonnuevas, por lo que no puede usar Attach para adjuntar entidades cuyo EntityState se agrega. Tienes que usar Add () en este caso.

Por ejemplo, supongamos que su entidad Persona tiene una propiedad de navegación llamada Direcciones, que es una colección deentidad Dirección . Supongamos que ha leído ambos objetos desde el contexto, pero no están relacionados entre sí y 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();

Esta es una respuesta tardía, pero podría ayudar a otros que la encuentren.

Básicamente, una entidad "desconectada" puede suceder cuando manipula una entidad fuera del alcance "en uso".

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 ingresa otro alcance "en uso", la variable "e" se desconectará porque pertenece al alcance "en uso" anterior y dado que el alcance "en uso" anterior se destruye, se desconecta "e".

Así lo entiendo.

Esta es una cita de Programming Entity Framework: DbContext

Llamar a Eliminar en una entidad que no es rastreada por el contexto provocará una InvalidOperationException. Entity Framework arroja esta excepción porque no está claro si la entidad que está tratando de eliminar es una entidad existente que debe marcarse para su eliminación o una nueva entidad que simplemente debe ignorarse. Por esta razón, no podemos usar solo Eliminar para marcar una entidad desconectada como Eliminada; Necesitamos 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 que una aplicación cliente obtiene un Destino existente del servidor y luego lo pasa al método DeleteDestination en el servidor. El método DeleteDestination usa el método Attach para que el contexto sepa que es un Destino existente. Luego, el método Eliminar se utiliza para registrar el Destino existente para su eliminación

¿Qué hay de referirse solo a la clave primaria en lugar de adjuntar?

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