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. Entity Framework Core (EF Core) en C# es una herramienta poderosa que simplifica el acceso a los datos al proporcionar un enfoque conveniente 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 for Handling PDF Documents de Iron Software Solutions 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 mapeador de base de datos de objetos moderno y sigue el patrón ORM (Mapeo Objeto-Relacional), permitiendo a los desarrolladores trabajar con bases de datos utilizando objetos .NET, lo que elimina la necesidad de escribir consultas SQL tediosas de forma manual.

Características principales de EF Core

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

2. Compatibilidad con LINQ: EF Core admite sin problemas consultas LINQ (Language Integrated Query), lo que permite a los desarrolladores escribir consultas fuertemente tipadas contra SQL Server o cualquier otra base de datos utilizando la sintaxis familiar 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: Gestionar los cambios en el esquema de la base de datos puede ser un desafío, 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 diferida y carga preparada: EF Core admite tanto las estrategias de carga diferida como las de carga preparada, permitiendo a los desarrolladores optimizar el rendimiento cargando los datos relacionados bajo demanda o por adelantado, según el caso de uso.

5. Gestión de transacciones: Las transacciones aseguran la consistencia 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 gestionar conflictos de concurrencia, lo que permite a los desarrolladores detectar y resolver conflictos que pueden surgir cuando varios usuarios intentan modificar los mismos datos simultáneamente.

Introducción al núcleo EF

Creemos un ejemplo básico de cómo utilizar SQLite con Entity Framework Core (EF Core) en una aplicación ASP.NET Core. Estos son los pasos:

1. Crea tu aplicación:

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

2. Instalar 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. Crea tu contexto de base de datos:

   • Define una clase para tu contexto de base de datos (por ejemplo, DatabaseContext) que herede 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 iniciar:

   • 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. Usa SQLite en tu 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 adaptar esto a sus necesidades específicas!

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

1. Mantener DbContext con Ámbito: Las instancias de DbContext en EF Core están diseñadas para ser de corta duración y, generalmente, deben tener un ámbito limitado a la duración de una única solicitud en aplicaciones web.

2. Utilice AsNoTracking para operaciones de solo lectura: Cuando realice operaciones de solo lectura donde no se espera que las entidades sean modificadas, utilice el método AsNoTracking para mejorar el rendimiento al omitir el seguimiento de cambios.

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

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

5. Monitorear el Rendimiento: Monitorea el rendimiento de EF Core utilizando herramientas como Entity Framework Profiler o capacidades de registro integradas para identificar y abordar cuellos de botella en el 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 Contenido:

   • 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 procesador de 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.

   • Se crea un nuevo estudiante (stud1) con propiedades como NombreDelEstudiante, FechaDeNacimiento, Altura, Peso y Calificación.

   • client.Estudiantes.Añadir(estud1); añade este alumno a la base de datos.
   • client.SaveChanges(); guarda los cambios en la base de datos.

3. Mostrar estudiantes:

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

   • Recupera a todos los estudiantes usando 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. Renderizado a PDF:

   • El ChromePdfRenderer es instanciado.

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

Salida

PDF

Licencias IronPDF

El paquete IronPDF requiere una licencia para ejecutar 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

La Licencia de Prueba está disponible en la Página de Licencias de IronPDF.

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. Puedes usarlo junto con EF Core para convertir contenido HTML (incluidas las imágenes) en un archivo PDF.