Entity Framework Core (How It Works For Developers)

Understanding Entity Framework Core

Entity Framework Core is an open-source, lightweight, and extensible version of the popular Entity Framework data access technology. It's designed to work cross-platform, supporting various existing database server providers including SQL Server, SQLite, MySQL, PostgreSQL, Azure Cosmos DB, and more. EF Core is a modern object database mapper and follows the ORM (Object-Relational Mapping) pattern, allowing developers to work with databases using .NET objects, which eliminates the need for writing tedious SQL queries manually.

Key Features of EF Core

1. Modeling Entities: EF Core enables developers to define data models using Plain Old CLR Objects (POCOs). These entity classes represent database tables, with properties mapping to table columns.

2. LINQ Support: EF Core seamlessly supports LINQ queries (Language Integrated Query), allowing developers to write strongly typed queries against the SQL Server or any other database using familiar C# syntax. This makes querying data intuitive and reduces the likelihood of runtime errors. Also, raw SQL statements can be used along with LINQ queries.

3. Database Migrations: Managing database schema changes can be challenging, especially in a team environment. EF Core simplifies this process by providing database migration capabilities, allowing developers to apply incremental changes to the database schema using code-first migrations.

4. Lazy Loading and Eager Loading: EF Core supports both lazy loading and eager loading strategies, enabling developers to optimize performance by loading related data on demand or upfront, depending on the use case.

5. Transaction Management: Transactions ensure data consistency and integrity during database operations. EF Core allows developers to work with transactions explicitly, ensuring that a group of database operations either succeed or fail together.

6. Concurrency Control: EF Core provides built-in support for managing concurrency conflicts, allowing developers to detect and resolve conflicts that may arise when multiple users attempt to modify the same data simultaneously.

Getting Started with EF Core

Let’s create a basic example of using SQLite with Entity Framework Core (EF Core) in an ASP.NET Core application. Here are the steps:

1. Create Your Application:

   • Start by creating a Console or ASP.NET application.

2. Install Necessary Packages:

   • Add the following NuGet packages to your project:

     • Microsoft.EntityFrameworkCore (version 1.0.0 or later)
     • Microsoft.EntityFrameworkCore.Sqlite (version 1.0.0 or later)

3. Create Your Database Context:

   • Define a class for your database context (e.g., DatabaseContext) that inherits from DbContext.

   • In the OnConfiguring method, set the SQLite connection string:

     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");
      }
     }

     $vbLabelText   $csharpLabel

4. Register the Context:

   • In your Startup class, add your context to the services:

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

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

     $vbLabelText   $csharpLabel

5. Create the Database on Startup:

   • In the Startup constructor, create your database:

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

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

     $vbLabelText   $csharpLabel

6. Use SQLite in Your Application:

   • Now you can use SQLite in your ASP.NET Core application through EF Core.
   • Define your models and use the DatabaseContext to interact with the database.

Remember that this is a basic example, and there are other ways to configure the connection string and use EF Core. Feel free to explore more advanced features and adapt this to your specific needs!

Best Practices for EF Core Development

1. Keep DbContext Scoped: DbContext instances in EF Core are designed to be short-lived and should typically be scoped to the lifetime of a single request in web applications.

2. Use AsNoTracking for Read-Only Operations: When performing read-only operations where entities are not expected to be modified, use the AsNoTracking method to improve performance by bypassing change tracking.

3. Optimize Queries: Write efficient queries by using appropriate indexing, pagination, and filtering techniques to minimize the amount of data retrieved from the database.

4. Avoid N+1 Query Problems: Be mindful of the N+1 query problem, where a query is executed for each related entity in a collection. Use eager loading or explicit loading to fetch related data efficiently.

5. Monitor Performance: Monitor EF Core performance using tools like Entity Framework Profiler or built-in logging capabilities to identify and address performance bottlenecks.

Introduction to IronPDF

IronPDF is a powerful C# PDF library that allows you to generate, edit, and extract content from PDF documents in .NET projects. Here are some key features:

1. HTML to PDF Conversion:

   • Convert HTML, CSS, and JavaScript content to PDF format.
   • Use the Chrome Rendering Engine for pixel-perfect PDFs.
   • Generate PDFs from URLs, HTML files, or HTML strings.

2. Image and Content Conversion:

   • Convert images to and from PDF.
   • Extract text and images from existing PDFs.
   • Support for various image formats.

3. Editing and Manipulation:

   • Set properties, security, and permissions for PDFs.
   • Add digital signatures.
   • Edit metadata and revision history.

4. Cross-Platform Support:

   • Works with .NET Core (8, 7, 6, 5, and 3.1+), .NET Standard (2.0+), and .NET Framework (4.6.2+).
   • Compatible with Windows, Linux, and macOS.
   • Available on NuGet for easy installation.

Generate PDF document using IronPDF along with EF Core

To start with, create a Console application using Visual Studio as below.

Provide Project Name.

Provide .NET cross platform version.

Install Microsoft.EntityFrameworkCore package.

Install Microsoft.EntityFrameworkCore.SqlLite package.

Install IronPDF package.

Add below code to Program.cs.

using IronPdf;
using Microsoft.EntityFrameworkCore;
using System;
using System.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();

            // Start with initial HTML content
            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 if it doesn't exist
                client.Students.ExecuteDelete(); // Ensure the table is clean

                // Define students
                var students = new[]
                {
                    new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 },
                    new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 },
                    new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 }
                };

                // Add students to database
                client.Students.AddRange(students);
                client.SaveChanges();

                // Add students info to HTML content
                foreach (var student in students)
                {
                    content = AddStudent(content, student);
                }
            }

            content += "<h2>Display Students in Database</h2>";

            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Displaying Students in Database:");
                var students = client.Students.ToList();

                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={student.Height}");
                    content = AddStudent(content, student);
                }
            }           

            // Render HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Export to a file or stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }

        // Helper method to add student info as HTML content
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={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 IronPdf;
using Microsoft.EntityFrameworkCore;
using System;
using System.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();

            // Start with initial HTML content
            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 if it doesn't exist
                client.Students.ExecuteDelete(); // Ensure the table is clean

                // Define students
                var students = new[]
                {
                    new Student { StudentName = "Bill", DateOfBirth = new DateTime(1990, 12, 01), Height = 5.45M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Mike", DateOfBirth = new DateTime(1992, 12, 06), Height = 4.45M, Weight = 34, Grade = 8 },
                    new Student { StudentName = "Peter", DateOfBirth = new DateTime(1990, 12, 03), Height = 5.0M, Weight = 50, Grade = 10 },
                    new Student { StudentName = "Bob", DateOfBirth = new DateTime(1990, 12, 09), Height = 4.56M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Harry", DateOfBirth = new DateTime(1990, 12, 21), Height = 5.6M, Weight = 56, Grade = 10 },
                    new Student { StudentName = "Charle", DateOfBirth = new DateTime(1993, 12, 11), Height = 5.5M, Weight = 56, Grade = 7 }
                };

                // Add students to database
                client.Students.AddRange(students);
                client.SaveChanges();

                // Add students info to HTML content
                foreach (var student in students)
                {
                    content = AddStudent(content, student);
                }
            }

            content += "<h2>Display Students in Database</h2>";

            // Display Students in Database
            using (var client = new DatabaseContext())
            {
                Console.WriteLine($"Displaying Students in Database:");
                var students = client.Students.ToList();

                foreach (var student in students)
                {
                    Console.WriteLine($"Name= {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={student.Height}");
                    content = AddStudent(content, student);
                }
            }           

            // Render HTML content to PDF
            var pdf = renderer.RenderHtmlAsPdf(content);

            // Export to a file or stream
            pdf.SaveAs("AwesomeEfCoreAndIronPdf.pdf");
        }

        // Helper method to add student info as HTML content
        private static string AddStudent(string content, Student student)
        {
            content += $"<p>Name = {student.StudentName}, ID={student.StudentID}, Grade={student.Grade}, Weight={student.Weight}, Height={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; }
    }
}

Output

IronPDF Licensing

IronPDF package requires a license to run and generate the PDF. Add the below code at the start of the application before the package is accessed.

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

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

A trial license is available from the IronPDF Licensing Page.

Conclusion

Entity Framework Core in C# provides a robust and intuitive way to interact with databases, offering features like LINQ support, database migrations, and transaction management out of the box. By following best practices and leveraging its powerful capabilities, developers can build scalable and maintainable applications with ease. Whether you're a seasoned developer or just getting started, EF Core is a valuable tool to have in your toolkit for modern data access in C# applications. On the other hand, IronPDF is a .NET library for creating, manipulating, and rendering PDF documents within your applications. You can use it along with EF Core to convert HTML content (including images) into a PDF file.