Introducción

En el ámbito del desarrollo de software moderno, la gestión eficaz de los datos es crucial. Tanto si está creando una aplicación sencilla como un sistema empresarial complejo, acceder a los datos, manipularlos y guardarlos con eficacia es un requisito fundamental. Núcleo de Entity Framework (Núcleo EF) en C# es una potente herramienta que simplifica el acceso a los datos proporcionando un enfoque cómodo y orientado a objetos para trabajar con bases de datos. En este artículo, nos adentraremos en el mundo de EF Core, explorando sus características, capacidades y mejores prácticas. Además, echaremos un vistazo a IronPDF de IronSoftware para leer, escribir y gestionar documentos PDF. Crearemos un ejemplo práctico con ambos paquetes.

Entender Entity Framework Core

Entity Framework Core es una versión de código abierto, ligera y extensible de la popular tecnología de acceso a datos Entity Framework. Está diseñado para funcionar en varias plataformas y es compatible con varios proveedores de servidores de bases de datos, como SQL Server, SQLite, MySQL, PostgreSQL y Azure Cosmos DB, entre otros. EF Core es un moderno mapeador de bases de datos de objetos y sigue el ORM (Mapeo Objeto-Relacional) que permite a los desarrolladores trabajar con bases de datos utilizando objetos .NET, lo que elimina la necesidad de escribir manualmente tediosas consultas SQL.

Características principales de EF Core

1. Modelado de entidades: EF Core permite a los desarrolladores definir modelos de datos utilizando objetos CLR normales y corrientes (POCOs). Estas clases de entidad representan tablas de bases de datos, con propiedades que se corresponden con columnas de la tabla.

2. Soporte LINQ: EF Core soporta consultas LINQ sin problemas (Idioma Consulta integrada)que permite a los desarrolladores escribir consultas fuertemente tipadas contra SQL Server o cualquier otra base de datos utilizando la conocida sintaxis de C#. Esto hace que la consulta de datos sea intuitiva y reduce la probabilidad de errores en tiempo de ejecución. Además, se pueden utilizar sentencias SQL sin procesar junto con consultas LINQ.

3. Migraciones de bases de datos: La gestión de los cambios de esquema de base de datos puede ser un reto, especialmente en un entorno de equipo. EF Core simplifica este proceso proporcionando capacidades de migración de bases de datos, lo que permite a los desarrolladores aplicar cambios incrementales en el esquema de la base de datos utilizando migraciones de código primero.

4. Carga lenta y carga rápida: EF Core admite estrategias de carga lenta y carga rápida, lo que permite a los desarrolladores optimizar el rendimiento cargando datos relacionados bajo demanda o por adelantado, en función del caso de uso.

5. Gestión de transacciones: Las transacciones garantizan la coherencia e integridad de los datos durante las operaciones de la base de datos. EF Core permite a los desarrolladores trabajar con transacciones explícitamente, garantizando que un grupo de operaciones de base de datos tengan éxito o fallen juntas.

6. Control de concurrencia: EF Core proporciona soporte integrado para la gestión de conflictos de concurrencia, lo que permite a los desarrolladores detectar y resolver los conflictos que puedan surgir cuando varios usuarios intentan modificar los mismos datos simultáneamente.

Introducción al núcleo EF

Vamos a crear un ejemplo básico de uso de SQLite con Entity Framework Core (Núcleo EF) en una aplicación ASP.NET Core. Estos son los pasos:

1. Cree su solicitud:

   • Empiece por crear una aplicación de consola o ASP.Net.

2. Instalar los paquetes necesarios:

   • Añada los siguientes paquetes NuGet a su proyecto:

             * Microsoft.EntityFrameworkCore (versión 1.0.0 o posterior)
     
         * Microsoft.EntityFrameworkCore.Sqlite (versión 1.0.0 o posterior)

3. Cree el contexto de su base de datos:

   • Defina una clase para su contexto de base de datos (por ejemplo, DatabaseContext) que hereda de DbContext.

   • En el método OnConfiguring, establezca la cadena de conexión SQLite:

public class DatabaseContext : DbContext
        {
            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            {
                optionsBuilder.UseSqlite("Filename=sample.db");
            }
        }

public class DatabaseContext : DbContext
        {
            protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
            {
                optionsBuilder.UseSqlite("Filename=sample.db");
            }
        }

Public Class DatabaseContext
	Inherits DbContext

			Protected Overrides Sub OnConfiguring(ByVal optionsBuilder As DbContextOptionsBuilder)
				optionsBuilder.UseSqlite("Filename=sample.db")
			End Sub
End Class

4. Registrar el Contexto:

   • En su clase Startup, añada su contexto a los servicios:

public void ConfigureServices(IServiceCollection services)
        {
            services.AddEntityFrameworkSqlite().AddDbContext<DatabaseContext>();
        }

public void ConfigureServices(IServiceCollection services)
        {
            services.AddEntityFrameworkSqlite().AddDbContext<DatabaseContext>();
        }

Public Sub ConfigureServices(ByVal services As IServiceCollection)
			services.AddEntityFrameworkSqlite().AddDbContext(Of DatabaseContext)()
End Sub

5. Crear la base de datos al inicio:

   • En el constructor Startup, crea tu base de datos:

public Startup(IHostingEnvironment env)
        {
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated();
            }
        }

public Startup(IHostingEnvironment env)
        {
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated();
            }
        }

'INSTANT VB WARNING: The following constructor is declared outside of its associated class:
'ORIGINAL LINE: public Startup(IHostingEnvironment env)
Public Sub New(ByVal env As IHostingEnvironment)
			Using client = New DatabaseContext()
				client.Database.EnsureCreated()
			End Using
End Sub

6. Utilice SQLite en su aplicación:

   • Ahora puede utilizar SQLite en su aplicación ASP.NET Core a través de EF Core.
   • Defina sus modelos y utilice el DatabaseContext para interactuar con la base de datos.

   Recuerda que este es un ejemplo básico, y que existen otras formas de configurar la cadena de conexión y utilizar EF Core. Siéntase libre de explorar funciones más avanzadas y adaptarlas a sus necesidades específicas!

Buenas prácticas para el desarrollo del núcleo de EF

1. **Las instancias de DbContext en EF Core están diseñadas para ser de corta duración y normalmente deberían estar limitadas al tiempo de vida de una única petición en aplicaciones web.

2. Utilizar AsNoTracking para operaciones de sólo lectura: Al realizar operaciones de sólo lectura en las que no se espera que se modifiquen las entidades, utilice el método AsNoTracking para mejorar el rendimiento omitiendo el seguimiento de cambios.

3. Optimizar las consultas: Escribir consultas eficientes utilizando técnicas adecuadas de indexación, paginación y filtrado para minimizar la cantidad de datos recuperados de la base de datos.

4. Evite los problemas de consulta N+1: Tenga en cuenta el problema de consulta N+1, en el que se ejecuta una consulta para cada entidad relacionada de una colección. Utilice la carga rápida o la carga explícita para obtener datos relacionados de forma eficaz.

5. Supervisar el rendimiento: Supervisar el rendimiento de EF Core utilizando herramientas como Entity Framework Profiler o capacidades de registro integradas para identificar y abordar los cuellos de botella de rendimiento.

Introducción a IronPDF

IronPDF es una potente biblioteca PDF en C# que permite generar, editar y extraer contenido de documentos PDF en proyectos .NET. Estas son algunas de sus principales características:

1. Conversión de HTML a PDF:

   • Convierte contenidos HTML, CSS y JavaScript a formato PDF.

   • Utiliza el motor de renderizado de Chrome para obtener PDF perfectos.
   • Genere PDF a partir de URL, archivos HTML o cadenas HTML.

2. Conversión de imágenes y contenidos:

   • Convierte imágenes a y desde PDF.

   • Extraiga texto e imágenes de PDF existentes.
   • Compatible con varios formatos de imagen.

3. Edición y manipulación:

   • Establezca las propiedades, la seguridad y los permisos de los archivos PDF.

   • Añade firmas digitales.
   • Editar metadatos e historial de revisiones.

4. Soporte multiplataforma:

   • Funciona con .NET Core (8, 7, 6, 5 y 3.1+.).NET Standard (2.0+)y .NET Framework (4.6.2+).

   • Compatible con Windows, Linux y macOS.
   • Disponible en NuGet para facilitar la instalación.

Generación de documentos PDF con IronPDF y EF Core

Para empezar, cree una aplicación de consola utilizando Visual Studio como se indica a continuación.

Proporcione el nombre del proyecto.

Proporcionar la versión multiplataforma de .NET.

Instale el paquete Microsoft.EntityFrameworkCore.

Instale el paquete Microsoft.EntityFrameworkCore.SqlLite.

Instale el paquete IronPDF.

Añade el siguiente código a Program.cs.

using Microsoft.EntityFrameworkCore;
using System.Xml.Linq;
namespace CodeSample
{
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("-------------Demo EF core and IronPDF--------------");
            // Disable local disk access or cross-origin requests
            Installation.EnableWebSecurity = true;
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo EF core and IronPDF</h1>";
            content += "<h2>Add Students</h2>";
            // Add Students to Database
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated(); // create table
                client.Students.ExecuteDelete(); // ensure clean table
                var stud1 = new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud1);
                var stud2 = new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 };
                content = AddStudent(content, stud2);
                var stud3 = new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 };
                content = AddStudent(content, stud3);
                var stud4 = new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud4);
                var stud5 = new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud5);
                var stud6 = new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 };
                content = AddStudent(content, stud6);
                client.Students.Add(stud1);
                client.Students.Add(stud2);
                client.Students.Add(stud3);
                client.Students.Add(stud4);
                client.Students.Add(stud5);
                client.Students.Add(stud6);
                client.SaveChanges();
            }
            content += "<h2>Display Students in Database</h2>";
            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Display Stduents in Database");
                var students = client.Students.ToList();
                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}");
                    content = AddStudent(content, student);
                }
            }           
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}</p>";
            return content;
        }
    }
    public class DatabaseContext : DbContext
    {
        public DbSet<Student> Students { get; set; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Filename=IronPdfDemo.db");
        }        
    }
    public class Student
    {
        public int StudentID { get; set; }
        public string StudentName { get; set; }
        public DateTime? DateOfBirth { get; set; }
        public decimal Height { get; set; }
        public float Weight { get; set; }
        public int Grade { get; set; }
    }
}

using Microsoft.EntityFrameworkCore;
using System.Xml.Linq;
namespace CodeSample
{
    public class Program
    {
        public static void Main()
        {
            Console.WriteLine("-------------Demo EF core and IronPDF--------------");
            // Disable local disk access or cross-origin requests
            Installation.EnableWebSecurity = true;
            // Instantiate Renderer
            var renderer = new ChromePdfRenderer();
            var content = "<h1>Demo EF core and IronPDF</h1>";
            content += "<h2>Add Students</h2>";
            // Add Students to Database
            using (var client = new DatabaseContext())
            {
                client.Database.EnsureCreated(); // create table
                client.Students.ExecuteDelete(); // ensure clean table
                var stud1 = new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud1);
                var stud2 = new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 };
                content = AddStudent(content, stud2);
                var stud3 = new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 };
                content = AddStudent(content, stud3);
                var stud4 = new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud4);
                var stud5 = new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 };
                content = AddStudent(content, stud5);
                var stud6 = new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 };
                content = AddStudent(content, stud6);
                client.Students.Add(stud1);
                client.Students.Add(stud2);
                client.Students.Add(stud3);
                client.Students.Add(stud4);
                client.Students.Add(stud5);
                client.Students.Add(stud6);
                client.SaveChanges();
            }
            content += "<h2>Display Students in Database</h2>";
            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Display Stduents in Database");
                var students = client.Students.ToList();
                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}");
                    content = AddStudent(content, student);
                }
            }           
            var pdf = renderer.RenderHtmlAsPdf(content);
            // Export to a file or Stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName},ID={student.StudentID},G={student.Grade},W={student.Weight},H={student.Height}</p>";
            return content;
        }
    }
    public class DatabaseContext : DbContext
    {
        public DbSet<Student> Students { get; set; }
        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlite("Filename=IronPdfDemo.db");
        }        
    }
    public class Student
    {
        public int StudentID { get; set; }
        public string StudentName { get; set; }
        public DateTime? DateOfBirth { get; set; }
        public decimal Height { get; set; }
        public float Weight { get; set; }
        public int Grade { get; set; }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Código Explicación

1. Configuración del renderizador y del contenido:

   • El código comienza creando una cadena de contenido HTML. Comienza con un encabezado

     y añade un subencabezado

     para añadir alumnos a la base de datos.

   • El objetivo parece ser generar un documento PDF utilizando IronPDF, que incluirá información sobre los estudiantes.

2. Contexto de la base de datos y adición de estudiantes:

   • La clase DatabaseContext se utiliza para interactuar con la base de datos.

     * client.Database.EnsureCreated(); garantiza que la tabla de la base de datos existe.
     
     * client.Students.ExecuteDelete(); borra los datos existentes en la tabla Estudiantes.

   • Un nuevo estudiante (semental1) se crea con propiedades como StudentName, DateOfBirth, Height, Weight y Grade.

   • client.Alumnos.Añadir(semental1); añade este alumno a la base de datos.
   • client.GuardarCambios(); guarda los cambios en la base de datos.

3. Estudiantes participantes:

   • A continuación, el código muestra los alumnos en la base de datos.

   • Recupera todos los estudiantes utilizando client.Students.ToList();.

   • Para cada alumno, imprime su nombre, DNI, curso, peso y altura.
   • Además, se llama a la función AddStudent (no se muestra en este fragmento).

4. Renderización a PDF:

   • El ChromePdfRenderer es instanciado.

   • El contenido HTML se convierte en un PDF utilizando renderer.RenderHtmlAsPdf(contenido).
   • Por último, el PDF se guarda como "AwesomeEfCoreAndIronPdf.pdf".

Salida

PDF

Licencias IronPDF

El paquete IronPDF requiere licencia para ejecutarse y generar el PDF. Añada el siguiente código al inicio de la aplicación antes de acceder al paquete.

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

IronPdf.License.LicenseKey = "IRONPDF-MYLICENSE-KEY";

IRON VB CONVERTER ERROR developers@ironsoftware.com

Licencia de prueba disponible aquí.

Conclusión

Entity Framework Core en C# proporciona una forma sólida e intuitiva de interactuar con las bases de datos, ofreciendo funciones como la compatibilidad con LINQ, las migraciones de bases de datos y la gestión de transacciones de forma inmediata. Siguiendo las mejores prácticas y aprovechando sus potentes funciones, los desarrolladores pueden crear aplicaciones escalables y mantenibles con facilidad. Tanto si eres un desarrollador experimentado como si acabas de empezar, EF Core es una valiosa herramienta que debes tener en tu kit de herramientas para el acceso moderno a datos en aplicaciones C#. Por otro lado, IronPDF es una biblioteca .NET para crear, manipular y renderizar documentos PDF dentro de sus aplicaciones. Puede utilizarlo junto con EF Core para convertir contenido HTML (incluyendo imágenes) en un archivo PDF.