Attach many objects with id = 0

The problem is very similar with this answer I gave, where the questioner has the same error , but does not deserve to be treated as duplicate because, in your case, the answer deserves additional considerations.

For example, this part:

    foreach(var d in projeto.Documentos.ToList())
    {
        // Documento alterado
        if(d.id != 0)
        {
             ctx.Entry(d).State = EntityState.Modified;
        }
        else // Documento adicionado
        {
             d.Parte1Id = parte1Id;
             ctx.Entry(d).State = EntityState.Added;
        }
     }

     ctx.Projetos.Attach(projeto);

Since projeto.Documentos implements ICollection , projeto.Documentos.ToList() is unnecessary. The snippet can be rewritten as:

foreach(var d in projeto.Documentos) { ... }

Another thing is about aggregate entities. From Entity Framework 6, this foreach block is unnecessary, since the context already tries to resolve changes, even, in the dependent entities. That is, the whole block can be replaced by:

ctx.Entry(projeto).State = EntityState.Modified;
ctx.SaveChanges();

Also, the statement below:

ctx.Projetos.Attach(projeto);

It is incorrect at this point in the code. According to the official documentation itself, Attach should be used when you know two things:

• Object has not yet been loaded in context;
• The object exists in the database.

Not the case here. projeto has already been loaded before. The correct one is to use:

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

Another troubling detail is here:

    // A lista de documentos que permaneceu no banco como Unchanged é porque foi excluída na view
     var apagados = (from d in dLista where ctx.Entry(d).State = EntityState.Unchanged select d).ToList();

     foreach(var a in apagados)
     {
          ctx.Entry(a).State = EntityState.Deleted;
     }

Here you mark the original records as EntityState.Deleted but only call ctx.SaveChanges() in the parent function, which is, from the transactional point of view, not only incorrect but also bad practice.

To include a transactional scope in your code, use:

private void salvar(Projetos projeto)
{
    try
    {
        using (var scope = new TransactionScope()) 
        {
            resolverParte1(projeto);
            resolverParte2(projeto);
            ...

            ctx.Entry(projeto).State = EntityState.Modified;
            ctx.SaveChanges();

            scope.Complete();
        } 
    }
    catch (Exception ex)
    {

    }
}

If you are keen to maintain logic for solving separate parts, logic may receive nested transactional scope:

private void resolverParte1(Projetos projeto)
{
     using (var scope = new TransactionScope()) 
     {
         ctx.Entry(projeto).State = EntityState.Modified;
         ctx.SaveChanges();

         ICollection<Documentos> dLista = null;

         ctx.Entry(projeto).Collection("Documentos").Load();
         dLista = projeto.Documentos;

         // A lista de documentos que permaneceu no banco como Unchanged é porque foi excluída na view
         var apagados = (from d in dLista where ctx.Entry(d).State = EntityState.Unchanged select d).ToList();

         foreach(var a in apagados)
         {
             ctx.Entry(a).State = EntityState.Deleted;
         }

         scope.Complete();
    }
}