C# Data Access: Working with Entity Framework Core

Hello, C# developers! In today’s post, we’re going to explore Entity Framework Core (EF Core), a powerful Object-Relational Mapper (ORM) for .NET applications. EF Core simplifies data access in C# applications, enabling you to work with databases using strongly typed objects. Let’s get started with setting up EF Core, performing CRUD operations, and managing database migrations.

What is Entity Framework Core?

Entity Framework Core is the lightweight, extensible, and cross-platform version of Entity Framework. It allows developers to interact with databases using C# objects without needing to write extensive SQL queries. EF Core supports LINQ, making database queries easier and more intuitive.

Setting Up EF Core

To get started with EF Core, you need to install the relevant NuGet packages. Use the following command to install EF Core and any database provider, for example, if you are using SQLite:

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.Sqlite

Once you have installed the packages, you can create your data model and context.

Defining the Data Model

Create classes that represent your data model. Here’s an example of a simple Product class:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}

This Product class will define the structure of the data we want to manage in the database.

Creating the DbContext

The DbContext class is used to interact with the database. Create a context class that inherits from DbContext:

using Microsoft.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public DbSet<Product> Products { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder options)
    {
        options.UseSqlite("Data Source=app.db"); // Configure SQLite connection
    }
}

In this example, we configure the AppDbContext to use SQLite and define a DbSet for Product. A DbSet represents a collection of entities that can be queried from the database.

Performing CRUD Operations

With Entity Framework Core set up, let’s perform CRUD (Create, Read, Update, Delete) operations:

public class Program
{
    public static void Main(string[] args)
    {
        using (var context = new AppDbContext())
        {
            // Create
            var newProduct = new Product { Name = "Laptop", Price = 999.99M };
            context.Products.Add(newProduct);
            context.SaveChanges();

            // Read
            var products = context.Products.ToList();
            Console.WriteLine("Products:");
            foreach (var product in products)
            {
                Console.WriteLine($"{product.Id}: {product.Name} - ${product.Price}");
            }

            // Update
            var productToUpdate = context.Products.First();
            productToUpdate.Price = 899.99M;
            context.SaveChanges();

            // Delete
            var productToDelete = context.Products.Last();
            context.Products.Remove(productToDelete);
            context.SaveChanges();
        }
    }
}

This example demonstrates how to create a new product, read all products from the database, update an existing product, and delete a product.

Database Migrations

Entity Framework Core provides a migration feature to manage database schema changes over time. You can create a migration after defining your model and context:

dotnet ef migrations add InitialCreate

After adding a migration, apply it to the database using:

dotnet ef database update

These commands generate and apply schema changes based on your data model.

Best Practices for Using EF Core

• Keep Database Context Scoped: Use dependency injection to manage the lifetimes of your DbContext instances.
• Use Asynchronous Operations: Prefer asynchronous methods (e.g., SaveChangesAsync()) to improve responsiveness in your applications.
• Handle Exceptions: Implement proper exception handling for database operations to manage errors effectively.

Conclusion

Entity Framework Core is a powerful ORM that simplifies data access in C#. By setting up a data model, using a context, performing CRUD operations, managing migrations, and following best practices, you can efficiently manage database interactions in your applications. Start utilizing EF Core today to enhance your data access layer!

To learn more about ITER Academy, visit our website. Visit Here