none
EF 4.1 Code First dbUpdateException RRS feed

  • Pregunta

  • Muy buenas,

    Tengo dos entidades, grupos y usuarios. Y es una relación M-N entre ellas. Estoy utilizando EF 4.1 Code First.

    Estoy testeando el repositorio, para que pueda actualizar los grupos a los que pertenece el usuario, como se puede ver a continuación:

    [TestMethod]
    
            public void Should_Update_user_with_adding_groups()
    
            {
    
                var sideEffects = new SideEffects();
    
                var conf = new Configuracion(sideEffects);
    
                var db = new CrisisContext(conf);
    
                var userRepository = new UsuarioRepository(db);
    
                var groupRepository = new GrupoRepository(conf);
    
                var idRed = Guid.NewGuid().ToString();
    
                var newUser = new Usuario() { IDRed = idRed, Nombre = "NombreUsuario", Apellidos = "Apellidos" };
    
                var groupOne = new Grupo() { NombreGrupo = "GrupoOne", IdRedUsuarioCreacion = "IdRedUsuarioCreacionOne" };
    
                var groupTwo = new Grupo() { NombreGrupo = "GrupoTwo", IdRedUsuarioCreacion = "IdRedUsuarioCreacionTwo" };
    
                var groupThree = new Grupo() { NombreGrupo = "GrupoThree", IdRedUsuarioCreacion = "IdRedUsuarioCreacionThree" };
    
                var groupFour = new Grupo() { NombreGrupo = "GrupoFour", IdRedUsuarioCreacion = "IdRedUsuarioCreacionFour" };
    
     
    
                newUser.Grupos.Add(groupOne);
    
                newUser.Grupos.Add(groupTwo);
    
     
    
                userRepository.Insert(newUser);
    
                var expectedUser = userRepository.GetById(idRed);
    
                expectedUser.Grupos.Add(groupThree);
    
                expectedUser.Grupos.Add(groupFour);
    
     
    
                userRepository.Update(expectedUser);       //dbUpdateException
    
                expectedUser = userRepository.GetById(idRed);
    
     
    
                Assert.AreEqual(newUser.IDRed, expectedUser.IDRed);
    
                Assert.AreEqual(newUser.Nombre, expectedUser.Nombre);
    
                Assert.AreEqual(newUser.Apellidos, expectedUser.Apellidos);
    
                Assert.AreEqual(newUser.EsAdministrador, expectedUser.EsAdministrador);
    
                Assert.AreEqual(newUser.Grupos.Count, expectedUser.Grupos.Count);
    
                Assert.AreEqual(newUser.Grupos.ToList<Grupo>()[0], expectedUser.Grupos.ToList<Grupo>()[0]);
    
                Assert.AreEqual(newUser.Grupos.ToList<Grupo>()[1], expectedUser.Grupos.ToList<Grupo>()[1]);
    
                Assert.AreEqual(newUser.Grupos.ToList<Grupo>()[2], expectedUser.Grupos.ToList<Grupo>()[2]);
    
                Assert.AreEqual(newUser.Grupos.ToList<Grupo>()[3], expectedUser.Grupos.ToList<Grupo>()[3]);
    
     
    
                var grpOne = newUser.Grupos.ToList<Grupo>()[0];
    
                var grpTwo = newUser.Grupos.ToList<Grupo>()[1];
    
                var grpThree = newUser.Grupos.ToList<Grupo>()[2];
    
                var grpFour = newUser.Grupos.ToList<Grupo>()[3];
    
     
    
                expectedUser.Grupos.Remove(grpOne);
    
                expectedUser.Grupos.Remove(grpTwo);
    
                expectedUser.Grupos.Remove(grpThree);
    
                expectedUser.Grupos.Remove(grpFour);
    
                userRepository.Delete(expectedUser);
    
     
    
                groupRepository.Delete(grpOne.ID);
    
                groupRepository.Delete(grpTwo.ID);
    
                groupRepository.Delete(grpThree.ID);
    
                groupRepository.Delete(grpFour.ID);
    
            }


    El código del repositorio:

         

       public void Update(Usuario usuario)
    
            {
    
                _db.Entry(usuario).State = EntityState.Modified;
    
                _db.SaveChanges();
    
            }

     

    La entidad Usuario:

     

        [Table("Usuarios")]
    
        public class Usuario
    
        {
    
            [Key]
    
            public string IDRed { get; set; }
    
            public bool EsSuperAdministrador { get; set; }
    
            public bool EsAdministrador { get; set; }
    
            public string Nombre { get; set; }
    
            public string Apellidos { get; set; }
    
            [JsonIgnore]
    
            public virtual ICollection<Crisis> Crisis { get; set; }
    
            //[JsonIgnore]
    
            public virtual ICollection<Grupo> Grupos{ get; set; }
    
            public bool Activo;
    
     
    
            public Usuario()
    
            {
    
                IDRed = string.Empty;
    
                EsSuperAdministrador = false;
    
                EsAdministrador = false;
    
                Nombre = string.Empty;
    
                Apellidos = string.Empty;
    
                Activo = true;
    
                Crisis = new List<Crisis>();
    
                Grupos = new List<Grupo>();
    
            }
    
        }

    Cuando en el test. Ejecuta la línea userRepository.Update(expectedUser); devuelve un dbUpdateException y no consigo solucionar el problema, ¿Sabeis qué puede estar pasando?

     

    Muchas gracias por adelantado.

    Saludos

    Imanol

    miércoles, 27 de noviembre de 2013 11:45

Todas las respuestas

  • hola

    cuando produce el error que mensaje puedes encontrar en el innerexception? quizas alli indique un poco mas de detalle de la causa del problema

    tambien hay otro tema, recuerda que debes marcar los otros grupos que ya habias creado con el

    context.Entry(entidad).State = EntityState.Unchanged;

    Add/Attach and Entity States

    para que no los vuelva a crear, es mas esos nuevos grupos que agregas deberias marcarlos con el

    context.Entry(grupo).State = EntityState.Added;

    porque alli tienes un mix de entidades que ya fueron agregadas y se deben actualizar con entidades nuevas que se deben crear, o sea debe programar un merge entre lo que tiene y lo que envias

    EF no sabe de forma automatica que debe realizar con cada entidad, por defecto va a querer actualizar todos y resulta que los nuevos grupos se debn crear no actualizar

    saludos


    Leandro Tuttini

    Blog
    Buenos Aires
    Argentina


    miércoles, 27 de noviembre de 2013 13:30