Update Entity Framework 6 Objects disconnected Entities 1: N (One to many)

The problem with:

ctx.Entry(socio).State = EntityState.Modified;

... is that not only does it change the State from socio to Modified , but it also goes through all the addresses and if it finds one that is Detached , it changes the State to Unchanged automatically.

Now, Unchanged represents an entity that already exists in the database. But in the case that gives you an error, the truth is that you have 2 addresses that do not yet exist in the database, so to put the state Unchanged in fact is a lie and is not correct.

With a single new address, the lie goes unnoticed, and anyway you correct the State to Added or Modified and nothing happens.

But when you have at least 2 new addresses, now the lie is felt, because EF notes 2 entities that supposedly already exist in the database, but share the same primary key ( Id = 0 ), and that does not like it, so it throws the error.

The solution is simple: change the State of the directions before to change the State from socio to Modified . In this way, by the time you execute the problematic statement, the addresses will no longer be in State = Detached , and EF will not try to put the State to Unchanged , which would be incorrect.

Code:

else
{
    foreach (SocioDireccion d in socio.Direcciones)
    {
        if (d.Id == 0)
            ctx.Entry(d).State = EntityState.Added;
        else
            ctx.Entry(d).State = EntityState.Modified;
    }

    // Mueve esta sentencia después de las direcciones.
    ctx.Entry(socio).State = EntityState.Modified;             

    r = ctx.SaveChanges();
}

Edit

I'm sorry you still have the problem despite reordering the statements to modify the State of the addresses before the partner. It seems that I underestimated the way EF modifies the State automatically following the navigation properties .

I think what is happening is the following:

Finally, although my explanation is not understood at all, I propose a modification, which now, I think will solve the problem.

I think that even if you're in update mode, you should change the State from socio to Added . This has the effect (as you already noted) of changing the State of all the addresses to Added , whose State does not cause problems with Id = 0 .

The next step is to modify the State of the addresses to Added or Modified as you already do.

And finally, the final stage: you change the State to the instance socio again, but this time to Modified .

Code:

else
{
    // 1. Asigna el state "Added" temporalmente para eliminar el error.
    ctx.Entry(socio).State = EntityState.Added;             

    // 2. Asigna los states a tus direcciones normalmente.
    foreach (SocioDireccion d in socio.Direcciones)
    {
        if (d.Id == 0)
            ctx.Entry(d).State = EntityState.Added;
        else
            ctx.Entry(d).State = EntityState.Modified;
    }

    // 3. Ahora sí le cambias el state a "Modified" sin problemas.
    ctx.Entry(socio).State = EntityState.Modified;             

    r = ctx.SaveChanges();
}

Final note

In fact, the fact that the code is so complicated is a sign that the design is not the best. Actually, EF does not work very well with disconnected entities, particularly when there are several related entities.

Of being in your place, I would seriously think of working with entities "connected" to a context that does not close until you finish working with the entities. If you try, you will see that the code is reduced and simplified, and works more intuitively.

Based on the existing code you have, here is an example of code using "contectas" entities. Note that the Guardar disappears completely:

Method Leer :

public Socio Leer(int id, DbContext context)
{
        //Usando Include linq lambda
        return context.Socio
            .Include(s => s.CuentaBancaria)
            .Include(s=> s.Direcciones)
            .Include(s=>s.EMails)
            .Include(s=>s.Grupos)
            .Include(s=>s.Vocalias)
            .Where(s => s.Id == id).FirstOrDefault();
}

Event handler:

private void button1_Click_1(object sender, EventArgs e)
{
    Socio s;
    using (var ctx = new BDConectaClubContext())
    {
        ctx.Configuration.ProxyCreationEnabled = false;
        ctx.Configuration.LazyLoadingEnabled = false;

        //Crear un nuevo socio llamada Pepe con una direccion a
        s = new Socio();
        s.Nombre = "Pepe";

        SocioDireccion direccion = new SocioDireccion();
        direccion.Direccion = "calle a";
        direccion.Socio = s;

        s.Direcciones.Add(direccion);

        ctx.SaveChanges();
    }

    using (var ctx = new BDConectaClubContext())
    {
        //Leer el socio Pepe y crear dos direcciones a y b
        Socio nuevoSocio = new FachadaSocio().Leer(s.Id, ctx);

        SocioDireccion dir;
        dir = new SocioDireccion();
        dir.Direccion = "calle b";
        dir.Socio = nuevoSocio;

        nuevoSocio.Direcciones.Add(dir);

        dir = new SocioDireccion();
        dir.Direccion = "calle c";
        dir.Socio = nuevoSocio;
        nuevoSocio.Direcciones.Add(dir);

        // El socio Pepe tiene 3 direcciones a,b,c
        ctx.SaveChanges();
    }
}

Try this way:

        //Aquí se produce el error
        ctx.Entry(socio).State = EntityState.Modified;             


        foreach (SocioDireccion d in socio.Direcciones)
        {
            if (d.Id == 0)
                ctx.Entry(d).State = EntityState.Added;
            else
                {
                    // Uliza el método Find de tú DbSet Direcciones (cro que se llama así)
                    var data = context.Direcciones.Find(d.Id);
                    var entry = context.Entry(data);
                    entry.CurrentValues.SetValues(entity);
                }
        }

        r = ctx.SaveChanges();

It's another way to make changes, and that's how it should work correctly.

I leave you a generic AddOrUpdate method, which can be of great help in these cases:

public virtual int InsertOrUpdate<TEntity>(TEntity entity, params object[] keyValues)  where TEntity : class
{
    if (entity == null) throw new ArgumentNullException(nameof(entity), $"El parámetro {nameof(entity)} no puede ser null");
    if (keyValues == null) throw new ArgumentNullException(nameof(keyValues), $"El parámetro {nameof(keyValues)} no puede ser null");

    int resultado = 0;

    var context = new TuContexto(); //CreateContext();

    var dbSet = context.Set<TEntity>();

    var data = dbSet.Find(keyValues);

    if (data == null)
    {
        dbSet.Attach(entity);
        context.Entry(entity).State = EntityState.Added;
    }
    else
    {
        var entry = context.Entry(data);
        entry.CurrentValues.SetValues(entity);
    }

    resultado = TuContexto.SaveChanges();

    TuContexto.Dispose(); //DisposeContext();

    return resultado;
}

I leave a little creation and destruction of the context to the consumer's liking, in case you want to insert it in the constructor of the same or in the same method or wherever you want.