Entity Framework – Overview

Entity Framework wallpaper

Imagine this: you’re building a fantastic web application, but every time you need to interact with the database, you have to write raw SQL queries. It’s slow, error-prone, and can be a real drag on your development process. Enter Entity Framework (EF), a powerful tool that simplifies how you work with databases in your .NET applications.

Think of EF as a translator. On one side, you have your application code, written in a high-level language like C#. On the other side, you have the relational database, which speaks its own language (SQL). EF acts as the bridge between these two worlds.

Here’s how it works:

  • Modeling Your Data: You start by defining your application’s data model using classes that represent real-world entities, like customers, products, or orders. These classes have properties that map to the columns in your database tables.
  • Automatic Mapping: EF uses a technique called Object-Relational Mapping (ORM) to automatically translate between your object model and the underlying database schema. You don’t need to write complex SQL queries by hand!
  • LINQ for Queries: Instead of writing raw SQL, you can use LINQ (Language Integrated Query) to interact with your data. LINQ allows you to write queries that look very similar to working with objects in your C# code. EF takes care of translating those LINQ queries into efficient SQL queries that the database can understand (This really improves the development experience).

Here’s a simple example using EF Core and LINQ to show how it works:

Let’s create a class named Product and add the following properties:

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

This class represents a simple product entity with properties for ID, name, and price.

The class below defines the DbContext, which acts as the bridge between your application and the database. It has a DbSet property for the Product entity, essentially creating an in-memory representation of your database table. The OnConfiguring method specifies the connection string for your database (You could also configure the connection to your database on the program.cs file).

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

  protected override void OnConfiguring(DbContextOptionsBuilder      optionsBuilder)
  {
    // Replace "YourConnectionString" with your actual connection      string
    optionsBuilder.UseSqlServer("YourConnectionString");
  }
}

We can now use LINQ to query the items from our database, let’s see how we would do it:

public class Program
{
  public static void Main(string[] args)
  {
    // Create the DbContext instance
    using (var context = new DataContext())
    {
      // Sample data
      context.Products.Add(new Product { Name = "T-Shirt", Price = 19.99m });
      context.Products.Add(new Product { Name = "Laptop", Price = 799.99m });
      context.SaveChanges(); // Save changes to the database

      // Use LINQ to query products
      var discountedProducts = context.Products
        .Where(p => p.Price > 20) // Filter products with price > $20
        .OrderByDescending(p => p.Price) // Order by price descending
        .ToList(); // Convert the results to a list

      // Print the results
      foreach (var product in discountedProducts)
      {
        Console.WriteLine($"Product Name: {product.Name}, Price: ${product.Price}");
      }
    }
  }

This code first creates a DbContext instance, and then adds some sample products. The SaveChanges method persists these changes to the database.

The interesting part is the LINQ query. Here’s what’s happening:

  • .Where(p => p.Price > 20): This filters the products where the price is greater than 20 (dollars, euros, etc).
  • .OrderByDescending(p => p.Price): This orders the results by price in descending order.
  • .ToList(): This converts the results of the query into a list of Product objects.

Finally, the code iterates through the list and prints the product name and price.

This is a very basic example, but it demonstrates how EF and LINQ work together. You can use LINQ to perform various operations on your data model, and EF translates those operations into efficient SQL queries behind the scenes.