(26) ASP.NET Core EF guardar (básico guardar, guardar datos, eliminaciones en cascada, el uso de transacción)

1. Introducción

Cada instancia de contexto tiene un ChangeTracker, que es responsable de deben ser escritos a la base de datos de seguimiento de los cambios. Cuando se cambia el tipo de instancias de entidad, estos cambios se registran en el ChangeTracker, y luego, cuando se llama a SaveChanges se escribirán en la base de datos. Este proveedor de base de datos es responsable de convertir los cambios específicos para el funcionamiento de la base de datos (por ejemplo, bases de datos relacionales INSERT, UPDATE y DELETE comandos).

2. Guardar básico

Aprender a utilizar clases de contexto y de las entidades para añadir, modificar y borrar los datos.

2.1 Adición de datos

Añadir una nueva instancia de la clase de entidad utilizando el método DbSet.Add. Cuando se llama a SaveChanges, los datos se inserta en la base de datos.

usando ( var context = nueva BloggingContext ()) 
{ 
    var el blog = nuevo Blog {url = " http://sample.com " }; 
    context.Blogs.Add (blog); 
    context.SaveChanges (); 
}

2.2 datos de actualización

EF detecta automáticamente los cambios en la entidad existente rastreado por el contexto. Esto incluye a las entidades cargadas desde la consulta de bases de datos, así como añadir y guardar entidad a la base de datos antes. Simplemente mediante la asignación de atributos a modificar, y luego SaveChanges llamada puede ser.

usando ( var context = nuevo BloggingContext ()) 
{ 
    var el blog = context.Blogs.First (); 
    blog.Url = " http://sample.com/blog " ; 
    context.SaveChanges (); 
}

2.3 a los datos de borrado

utilice el método DbSet.Remove a instancia de eliminación de una clase de entidad. Si la entidad ya existe en la base de datos, a continuación, elimine la entidad durante SaveChanges. Si la entidad no se ha guardado en la base de datos (es decir, el seguimiento es "Alta"), cuando se llama SaveChanges, la entidad va a ser retirado del contexto y ya no se inserta.

usando ( var context = nuevo BloggingContext ()) 
{ 
    var el blog = context.Blogs.First (); 
    context.Blogs.Remove (blog); 
    context.SaveChanges (); 
}

2.4 una pluralidad de operaciones en un solo SaveChanges

Más usted puede añadir / operaciones de actualización / borrado en una sola llamada a los SaveChanges.

usando ( var context = nueva BloggingContext ()) 
{ 
    // añadir 
    context.Blogs.Add ( nuevo Blog {url = " http://sample.com/blog_one " }); 
    context.Blogs.Add ( nuevo Blog {url = " http://sample.com/blog_two " });
    // actualización 
    var firstBlog = context.Blogs.First (); 
    firstBlog.Url = "" ;
    // remove 
    var lastBlog = context.Blogs.Last (); 
    context.Blogs.Remove (lastBlog);
    context.SaveChanges (); 
}

3. Guardar datos Linked

Además de una entidad independiente, sino también la relación definida en el modelo puede ser utilizado.

3.1 Adición de datos asociados

Si también agrega otras entidades para crear varias nuevas entidades relacionadas, uno de los cuales se añadirán al contexto. En el siguiente ejemplo, se insertarán el blog y los tres artículos relacionados en la base de datos. Buscar y agregar estos artículos, ya que se puede acceder a través de los Blog.Posts propiedad de navegación.

usando ( var context = nueva BloggingContext ()) 
{ 
    var el blog = nuevo Blog 
    { 
        Url = " http://blogs.msdn.com/dotnet " , 
        Mensajes = nueva lista <publicación> 
        { 
            nuevo mensaje {Título = " Introducción a C # " },
             nuevo post {Título = " Introducción a VB.NET " },
             nuevo post {Título = " Introducción a C # " } 
        }
    }; 
    context.Blogs.Add (blog); 
    context.SaveChanges (); 
}

3.2 Adición de entidades relacionadas

Si la referencia de los nuevos atributos de contexto de navegación entidad de la entidad ha sido rastreado, la entidad se encuentra y se inserta en la base de datos. En el ejemplo siguiente, la entidad posterior inserción como la entidad se añade a las entradas del blog entidad atributos extrae de la base de datos.

usando ( var context = nueva BloggingContext ()) 
{ 
    var el blog = context.Blogs.Include (b => b.Posts) .First ();
    var post = nuevo mensaje {Título = " Introducción a EF Core " }; 
    blog.Posts.Add (post); 
    context.SaveChanges (); 
}

3.3 Modificación de la relación

Si cambia los atributos de navegación de la entidad, a continuación, la clave externa de la base de datos cambia la columna correspondiente. En el siguiente ejemplo, para actualizar una entidad perteneciente a publicar el blog nueva entidad debido a su propiedad a punto de navegación Blog Blog, el blog se inserta en la base de datos, ya que es el contexto de la propiedad después Navegación de pista ha sido citado nueva entidad entidad.

el uso de ( var context = new new BloggingContext ()) 
{ 
    // añadir una entidad cuerpo 
    var Blog = nuevo nuevo Blog del url = { " http://blogs.msdn.com/visualstudio " };
     var post = context.Posts.First ( );
     // actualización posterior a la relacional 
    post.Blog = Blog; 
    context.SaveChanges (); 
}

4. Eliminar en cascada

comportamiento Remove definiciones de tipo DeleteBehavior empadronador, y pueden ser transmitidos al control de API OnDelete Fluido:
● puede retirar al niño / dependencia
valor de clave externa ● niño puede ser fijado a nulo
● niño sin cambios
Ejemplo:

var el blog = context.Blogs.Include (b => b.Posts) .First ();
var mensajes = blog.Posts.ToList (); 
DumpEntities ( "   Después de entidades de carga: " , el contexto, blogs, mensajes); 
context.Remove (blog); 
DumpEntities ($ "   Después de eliminar el blog '{} blog.BlogId': " , contexto, blogs, mensajes);
tratar 
{ 
    Console.WriteLine (); 
    Console.WriteLine ( "   Almacenamiento de cambios: " ); 
    context.SaveChanges (); 
    DumpSql (); 
    DumpEntities ( "   Después de SaveChanges: " , el contexto, blogs, mensajes);
} 
Catch (Exception e) 
{ 
    DumpSql (); 
    Console.WriteLine (); 
    Console.WriteLine ($ "   SaveChanges lanzó {. E.GetType () Nombre}: {(e es DbUpdateException e.InnerException.Message:? E.Message)} " ); 
}

Registrar los resultados:

Después de entidades de carga: 
    Blog ' 1 '  es  en el estado sin cambios, con 2 puestos de referencia. 
      Mensaje ' 1 '  es  en el estado sin cambios con el FK ' 1 ' y la referencia al blog ' 1 ' . 
      Mensaje ' 2 '  está  en estado Sin cambios con el FK ' 1 ' y la referencia al blog ' 1 ' . 

  Después de eliminar el blog ' 1 ' :
    Blog ' 1 '  es  en estado eliminado con 2 mensajes referenciados. 
      Mensaje ' 1 '  es  en el estado sin cambios con el FK ' 1 ' y la referencia al blog ' 1 ' . 
      Mensaje ' 2 '  está  en estado Sin cambios con el FK ' 1 ' y la referencia al blog ' 1 ' . 

  Cambios de verano: 
    eliminar de [Mensajes] Donde [postID] = 1
    Eliminar de [Mensajes] Donde [postID] = 2 
    DELETE FROM [Blogs] Donde [blogid] = 1 

  Después de SaveChanges: 
    Blog ' 1 '  es  en estado independiente con 2 mensajes referenciados. 
      Mensaje ' 1 '  es  en estado independiente con FK ' 1 ' y no se hace referencia a un blog. 
      Mensaje ' 2 '  está  en estado independiente con FK ' 1 ' y no se hace referencia a un blog.

5. Transacción

Transacción atómicamente proceso permite que una pluralidad de operaciones de base de datos. Si se confirma la transacción, todas las operaciones se pueden aplicar con éxito a la base de datos. Si la transacción se deshace, entonces todas las operaciones no se aplican a la base de datos.

5.1 Control de Transacciones

API DbContext.Database se puede utilizar para iniciar, comprometerse y retrotraer transacciones. El siguiente ejemplo muestra dos consulta LINQ la operación SaveChanges (), y se lleva a cabo en una sola transacción. No todas las bases de datos proporcionan las aplicaciones soportan las transacciones. Cuando se llama a la API de transacción, proporcionando alguna aplicación puede producir una excepción o no hacer nada.

usando ( var context = nueva BloggingContext ()) 
{ 
    usando ( var transacción = context.Database.BeginTransaction ()) 
    { 
        try 
        { 
            context.Blogs.Add ( nuevo Blog {url = " http://blogs.msdn.com/dotnet " }); 
            context.SaveChanges (); 
            context.Blogs.Add ( nuevo Blog {url = " http://blogs.msdn.com/visualstudio " }); 
            context.SaveChanges (); 
            var blogs = context.Blogs
                .OrderBy (b => b.Url) 
                .ToList (); 
            // Commit transacción si todos los comandos de tener éxito, la voluntad transacción auto-rollback
             // cuando está dispuesto si cualquiera de los comandos falla 
            transaction.Commit (); 
        } 
        Catch (Exception) 
        { 
            // TODO: el fracaso de la manija 
        } 
    } 
}

6. Resumen

Como razón ocupado, EF serie aquí llegará a su fin, temporalmente no tienen mucho tiempo para ir a grabar. Hoy en día, este capítulo también se robó un perezoso, un poco más concisa, explicación oficial específica, voy a pegar a continuación, por favor, perdóname.

Referencias:
Básico Guardar
para guardar los datos pertinentes
eliminación en cascada
utilizando transacciones