Entity Framework Extensions

https://entityframework-extensions.net/
Admin
Entity Framework Extensions is a library that dramatically improves EF Core and EF6 performance with...
Tokens:231,427
Snippets:1,678
Trust Score:9.5
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install EF Core Tools and Design Packages

Source: https://entityframework-extensions.net/efcore-devart-oracle-provider

Install the required packages for migrations using Package Manager Console.

```powershell
PM> Install-Package Microsoft.EntityFrameworkCore.Tools
PM> Install-Package Microsoft.EntityFrameworkCore.Design
```

--------------------------------

### C# Benchmark Example for BulkSaveChanges and SaveChanges

Source: https://entityframework-extensions.net/benchmark

A complete benchmark example that JIT compiles the library first, then runs the target methods multiple times and averages the elapsed time. It separates the data generation and context setup from the timed operations.

```csharp
public Benchmark()
{
    // BENCHMARK using Stopwatch
    var clock1 = new Stopwatch();
    var clock2 = new Stopwatch();

    var nbRecord = 1000;
    var nbTry = 5;

    var list = GenerateData(nbRecord);

    // BENCHMARK: JIT compile library first
    Test1(list, new Stopwatch());
    Test2(list, new Stopwatch());
    
    for (var i = 0; i < nbTry; i++)
    {
        Test1(list, clock1);
        Test2(list, clock2);
    }

    var r1 = clock1.ElapsedMilliseconds/nbTry;
    var r2 = clock2.ElapsedMilliseconds/nbTry;
}

public void Test1(List<string> lines, Stopwatch clock)
{
    using (var ctx = new CustomerContext())
    {
        var customers = new List<Customer>();

        foreach (var line in lines)
        {
            var customer = new Customer();
            // ...code...
            customers.Add(customer);
        }

        ctx.Customers.AddRange(customers);

        // BENCHMARK: Only method we want to test
        clock.Start();
        ctx.BulkSaveChanges();
        clock.Stop();
    }
}

public void Test2(List<string> lines, Stopwatch clock)
{
    using (var ctx = new CustomerContext())
    {
        var customers = new List<Customer>();

        foreach (var line in lines)
        {
            var customer = new Customer();
            // ...code...
            customers.Add(customer);
        }

        ctx.Customers.AddRange(customers);

        // BENCHMARK: Only method we want to test
        clock.Start();
        ctx.SaveChanges();
        clock.Stop();
    }
}

public List<string> GenerateData(int nbRecord)
{
	var list = new List<string>();

	for (var i = 0; i < nbRecord; i++)
	{
		list.Add(i.ToString());
	}

	return list;
}
```

--------------------------------

### Install Z.EntityFramework.Extensions.EFCore via Package Manager Console

Source: https://entityframework-extensions.net/efcore-devart-oracle-provider

Run this command in the Package Manager Console to install the EFE library. The installation also includes Microsoft.EntityFrameworkCore.

```powershell
PM> Install-Package Z.EntityFramework.Extensions.EFCore
```

--------------------------------

### Install Glimpse.MVC5 and Glimpse.EF6 via Package Manager Console

Source: https://entityframework-extensions.net/glimpse

Use these commands to install the Glimpse packages required for EF6 debugging. Run them in the Package Manager Console.

```powershell
PM> Install-Package Glimpse.MVC5
```

```powershell
PM> Install-Package Glimpse.EF6
```

--------------------------------

### Install EntityFramework.SqlServerCompact via Package Manager Console

Source: https://entityframework-extensions.net/sql-server-compact-provider

Use this command to install the EntityFramework.SqlServerCompact NuGet package, which automatically adds the necessary provider registration to app.config or web.config.

```powershell
PM> Install-Package EntityFramework.SqlServerCompact
```

--------------------------------

### Install Microsoft.EntityFrameworkCore.SqlServer via Package Manager Console

Source: https://entityframework-extensions.net/efcore-profiler

Install the SQL Server provider package required for EF Core to work with SQL Server LocalDB, which is installed with Visual Studio.

```powershell
PM> Install-Package Microsoft.EntityFrameworkCore.SqlServer
```

--------------------------------

### Install EntityFrameworkCore.SqlServerCompact40 via Package Manager Console

Source: https://entityframework-extensions.net/efcore-sql-server-compact-provider

Use this command to install the SQL Server Compact 4.0 provider package for EF Core. This package includes all required EF Core packages for SQL CE.

```powershell
PM> Install-Package EntityFrameworkCore.SqlServerCompact40
```

--------------------------------

### Install MySql.Data.EntityFrameworkCore via NuGet

Source: https://entityframework-extensions.net/efcore-mysql-provider

Use this command in the Package Manager Console to install the MySQL provider package required for EF Core to work with MySQL.

```powershell
PM> Install-Package MySql.Data.EntityFrameworkCore
```

--------------------------------

### Install Pomelo.EntityFrameworkCore.MySql via NuGet Package Manager

Source: https://entityframework-extensions.net/efcore-pomelo-mysql-provider

Use this command in the Package Manager Console to install the Pomelo.EntityFrameworkCore.MySql provider, which includes all required packages for EF Core with MySQL.

```powershell
PM> Install-Package Pomelo.EntityFrameworkCore.MySql
```

--------------------------------

### Install Microsoft.EntityFrameworkCore.InMemory package

Source: https://entityframework-extensions.net/efcore-inmemory-provider

Use this Package Manager Console command to install the Microsoft.EntityFrameworkCore.InMemory NuGet package, which includes all required EF Core packages.

```powershell
PM> Install-Package Microsoft.EntityFrameworkCore.InMemory
```

--------------------------------

### Install EntityFrameworkProfiler via NuGet Package Manager

Source: https://entityframework-extensions.net/ef-profiler

Use this command in the Package Manager Console to install the EntityFrameworkProfiler NuGet package, which installs all required binaries.

```powershell
PM> Install-Package EntityFrameworkProfiler
```

--------------------------------

### Install Devart.Data.MySql.EFCore Package

Source: https://entityframework-extensions.net/efcore-devart-mysql-provider

Use the Package Manager Console to install the Devart.Data.MySql.EFCore NuGet package, which includes all required EF Core packages.

```powershell
PM> Install-Package Devart.Data.MySql.EFCore
```

--------------------------------

### Install Z.EntityFramework.Extensions via Package Manager Console

Source: https://entityframework-extensions.net/ef-profiler

Use this command in the Package Manager Console to install the Entity Framework Extensions (EFE) library as a NuGet package. The package is available on NuGet and can also be installed via the Manage NuGet Packages UI.

```powershell
PM> Install-Package Z.EntityFramework.Extensions
```

--------------------------------

### Install Oracle.EntityFrameworkCore via Package Manager Console

Source: https://entityframework-extensions.net/efcore-oracle-provider

Use this command to install the Oracle EF Core provider package, which includes all required packages for using Oracle with EF Core.

```powershell
PM> Install-Package Oracle.EntityFrameworkCore
```

--------------------------------

### Install Npgsql.EntityFrameworkCore.PostgreSQL Package

Source: https://entityframework-extensions.net/efcore-postgresql-provider

Use the Package Manager Console to install the Npgsql.EntityFrameworkCore.PostgreSQL NuGet package, which includes all required EF Core packages for PostgreSQL.

```powershell
PM> Install-Package Npgsql.EntityFrameworkCore.PostgreSQL
```

--------------------------------

### WhereExistsBulkInsert example with custom primary key

Source: https://entityframework-extensions.net/where-exists-bulk-insert

This example inserts customers into a destination tenant only if they exist in the source tenant. It uses the ColumnPrimaryKeyExpression option to match by CustomerID, ignoring TenantID. Customers A and B are inserted, while Customer C is skipped because it does not exist in the source tenant.

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

var sourceTenantID = 1;
var destinationTenantID = 3;

var customers = new List<Customer>();

customers.Add(new Customer() { CustomerID = 1, Code = "A", Name = "Customer_A", TenantID = destinationTenantID });
customers.Add(new Customer() { CustomerID = 2, Code = "B", Name = "Customer_B", TenantID = destinationTenantID });
customers.Add(new Customer() { CustomerID = 3, Code = "C", Name = "Customer_C", TenantID = destinationTenantID });

context.Customers.Where(x => x.TenantID == sourceTenantID).WhereExistsBulkInsert(customers, options => {
    // Match customers by `CustomerID` only.
    // This ignores `TenantID`, allowing customers from `sourceTenantID`
    // to be matched with customers in another tenant.
    options.ColumnPrimaryKeyExpression = x => x.CustomerID;
});
```

--------------------------------

### Install Oracle.ManagedDataAccess.EntityFramework via Package Manager Console

Source: https://entityframework-extensions.net/oracle-provider

Run this command to install the Oracle EF6 provider package, which automatically adds the necessary provider registration to app.config or web.config.

```powershell
PM> Install-Package Oracle.ManagedDataAccess.EntityFramework
```

--------------------------------

### Install System.Data.SQLite via Package Manager Console

Source: https://entityframework-extensions.net/sqlite-provider

Command to install the System.Data.SQLite NuGet package, which automatically adds the provider registration to the config file.

```powershell
PM> Install-Package System.Data.SQLite
```

--------------------------------

### Install EntityFramework6.Npgsql via Package Manager Console

Source: https://entityframework-extensions.net/postgresql-provider

Use this command to install the Npgsql provider for EF6. The NuGet package automatically adds the necessary provider registration to the app.config or web.config file.

```powershell
PM> Install-Package EntityFramework6.Npgsql
```

--------------------------------

### Duplicate Key on Root - Customer class and list setup

Source: https://entityframework-extensions.net/v7-100-0-0-include-graph

Defines a Customer entity and creates a list with two customers sharing the same CustomerID (1). This setup is used to demonstrate duplicate key handling in BulkInsert operations.

```csharp
public class Customer
{
    public int CustomerID { get; set; }
    public string Name { get; set; }
}

List<Customer> customers = new List<Customer>();

customers.Add(new Customer { CustomerID = 1, Name = "ZZZ Projects" });
customers.Add(new Customer { CustomerID = 1, Name = "Jonathan Magnan" });
```

--------------------------------

### Install Microsoft.EntityFrameworkCore.Sqlite via Package Manager Console

Source: https://entityframework-extensions.net/efcore-sqlite-provider

Use this command to install the SQLite database provider for EF Core. This package includes all required packages for EF Core to work with SQLite.

```powershell
PM> Install-Package Microsoft.EntityFrameworkCore.Sqlite
```

--------------------------------

### Install Devart.Data.Oracle.EFCore Package

Source: https://entityframework-extensions.net/efcore-devart-oracle-provider

Use the Package Manager Console to install the Devart.Data.Oracle.EFCore NuGet package, which includes all required packages for EF Core. This starts the 30-day trial period after installing dotConnect for Oracle Professional Trial.

```powershell
PM> Install-Package Devart.Data.Oracle.EFCore
```

--------------------------------

### BulkInsert with ForceValueGeneratedStrategy OnAddOrUpdate

Source: https://entityframework-extensions.net/forcevaluegeneratedstrategy

Shows how to change the default behavior by using ForceValueGeneratedStrategy = ValueGeneratedStrategyType.OnAddOrUpdate. This forces the property value to always be inserted, even if not specified. In this example, ZZZ Projects gets 200 and Jonathan Magnan gets 0.

```csharp
var customers = new List<Customer>();

customers.Add(new Customer() { Name = "ZZZ Projects", TokenLimit = 200 });
customers.Add(new Customer() { Name = "Jonathan Magnan"});

context.BulkInsert(customers, options => {
	options.ForceValueGeneratedStrategy = ValueGeneratedStrategyType.OnAddOrUpdate;
});
```

--------------------------------

### Configure options using an instance

Source: https://entityframework-extensions.net/configure-options

Creates a reusable BulkOptions instance to avoid duplication when similar configurations are used across the application. Shows two ways to create the instance: from context.Customers.CreateBulkOptions() or context.CreateBulkOptions<Customer>().

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

var customerOptions = context.Customers.CreateBulkOptions();
// or
var customerOptions = context.CreateBulkOptions<Customer>();

customerOptions.BatchSize = 1000;
customerOptions.BatchTimeout = 60;
customerOptions.ColumnPrimaryKeyExpression = x => x.ID;

context.BulkInsert(list, customerOptions);
```

--------------------------------

### Remove PreStart call from Program.cs

Source: https://entityframework-extensions.net/ef-profiler

This statement is added by the installer at the start of the Main method. The instructions say to remove it and replace with the Initialize() call.

```csharp
App_Start.EntityFrameworkProfilerBootstrapper.PreStart();
```

--------------------------------

### WhereBulkNotContains usage example

Source: https://entityframework-extensions.net/bulk-extensions

Shows how to use WhereBulkNotContains to get database records not in a list of IDs, by a custom key, and asynchronously. Like WhereBulkContains, it is deferred and requires ToList() or ToListAsync() to execute.

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

// Filter to get database records NOT in the list of IDs
var list1 = context.Customers.WhereBulkNotContains(ids).ToList();

// Filter by custom key
var list2 = context.Customers.WhereBulkNotContains(list, x => new { x.Email, x.PhoneNumber });

// Async version
var list3 = await context.Customers.WhereBulkNotContains(ids).ToListAsync();
```

--------------------------------

### BulkInsert with default value behavior

Source: https://entityframework-extensions.net/forcevaluegeneratedstrategy

Demonstrates the default behavior of BulkInsert when a property has a default value. Even if a value is specified for some entities, the default value is always inserted. In this example, both customers get TokenLimit = 100.

```csharp
var customers = new List<Customer>();

customers.Add(new Customer() { Name = "ZZZ Projects", TokenLimit = 200 });
customers.Add(new Customer() { Name = "Jonathan Magnan"});

context.BulkInsert(customers);
```

--------------------------------

### BulkInsertOptimized usage examples

Source: https://entityframework-extensions.net/bulk-insert-optimized

Two examples of calling BulkInsertOptimized. Example 1 is optimized and uses SqlBulkCopy directly. Example 2 is not optimized because InsertIfNotExists = true requires extra logic with a temporary table, causing a performance penalty.

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

// Example 1
var analysis = context.BulkInsertOptimized(customers);

// Example 2
var analysis = context.BulkInsertOptimized(customers, options => {
    options.InsertIfNotExists = true;
});
```

--------------------------------

### Bulk SaveChanges with and without options

Source: https://entityframework-extensions.net/

Demonstrates the simple usage of BulkSaveChanges and how to customize it with options like BatchSize.

```csharp
// Just add "Bulk" prefix to "SaveChanges()"

// Easy to use
context.BulkSaveChanges();

// Easy to customize
context.BulkSaveChanges(options => options.BatchSize = 1000);
```

--------------------------------

### BulkDelete examples for EF Core

Source: https://entityframework-extensions.net/bulk-extensions

Shows how to use BulkDelete for simple deletes, applying a custom SQL condition via DeleteMatchedAndFormula, deleting from an anonymous list, and the async version. Requires the Z.EntityFramework.Extensions.EFCore NuGet package.

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

// Simple bulk delete
context.BulkDelete(customers);

// Bulk delete with a custom SQL condition
context.BulkDelete(customers, options =>
{
    options.DeleteMatchedAndFormula = "DestinationTable.CreatedDate < DATEADD(YEAR, -2, GETDATE())";
});

// Bulk delete from an anonymous list
context.BulkDelete<Customer>(anonymousList);

// Bulk delete async version
await context.BulkDeleteAsync(customers);
```

--------------------------------

### Default constructor example for context class

Source: https://entityframework-extensions.net/context-factory

Shows a DbContext class with a default constructor that calls a base constructor with a connection string name. This demonstrates when a context factory might not be needed.

```csharp
public class EntitiesContext : DbContext
{
	public EntitiesContext() : base("CodeFirstEntities")
	{
		// I'm a default constructor!
	}
	
	// ...code...
}
```

--------------------------------

### Create BookStoreInitializer class with Seed method

Source: https://entityframework-extensions.net/glimpse

Defines a custom database initializer that drops and recreates the database when the model changes. The Seed method populates the database with test data for authors and books.

```csharp
using EFEWithGlimpse.Models;
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;

namespace EFEWithGlimpse.DAL
{
    public class BookStoreInitializer : DropCreateDatabaseIfModelChanges<BookStore>
    {
        protected override void Seed(BookStore context)
        {
            var authors = new List<Author>
            {
                new Author { FirstName="Carson", LastName="Alexander", BirthDate = DateTime.Parse("1985-09-01")},
                new Author { FirstName="Meredith", LastName="Alonso", BirthDate = DateTime.Parse("1970-09-01")},
                new Author { FirstName="Arturo", LastName="Anand", BirthDate = DateTime.Parse("1963-09-01")},
                new Author { FirstName="Gytis", LastName="Barzdukas", BirthDate = DateTime.Parse("1988-09-01")},
                new Author { FirstName="Yan", LastName="Li", BirthDate = DateTime.Parse("2000-09-01")},
            };

            authors.ForEach(a => context.Authors.Add(a));
            context.SaveChanges();

            var books = new List<Book>
            {
                new Book { Title = "Introduction to Machine Learning", AuthorId = 1 },
                new Book { Title = "Advanced Topics in Machine Learning", AuthorId = 1 },
                new Book { Title = "Introduction to Computing", AuthorId = 1 },
                new Book { Title = "Introduction to Microeconomics", AuthorId = 2 },
                new Book { Title = "Calculus I", AuthorId = 3 },
                new Book { Title = "Calculus II", AuthorId = 3 },
                new Book { Title = "Trigonometry Basics", AuthorId = 4 },
                new Book { Title = "Special Topics in Trigonometry", AuthorId = 4 },
                new Book { Title = "Advanced Topics in Mathematics", AuthorId = 4 },
                new Book { Title = "Introduction to AI", AuthorId = 4 },
            };

            books.ForEach(b => context.Books.Add(b));
            context.SaveChanges();
        }
    }
}
```

--------------------------------

### AddLicense and ValidateLicense from configuration

Source: https://entityframework-extensions.net/trial

Use this snippet when the license is not in the appsettings.json at the project root. It reads the license name and key from configuration, calls AddLicense, and then ValidateLicense to ensure the license is valid, throwing an exception if not.

```csharp
string licenseName = _configuration["licenseName"]; // or any other technique you usually use to read values from the appsettings.json
string licenseKey = _configuration["licenseKey"]; // or any other technique you usually use to read values from the appsettings.json

Z.EntityFramework.Extensions.LicenseManager.AddLicense(licenseName, licenseKey);

string licenseErrorMessage;
if (!Z.EntityFramework.Extensions.LicenseManager.ValidateLicense(out licenseErrorMessage))
{
  throw new Exception(licenseErrorMessage);
}
```

--------------------------------

### Safe and unsafe usage of MergeMatchedAndFormula

Source: https://entityframework-extensions.net/is-entity-framework-extensions-sql-injection-safe

Shows a safe hardcoded condition and an unsafe example with raw user input. The unsafe example is flagged as a risk.

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore

// ✅ Safe (hardcoded condition)
options.MergeMatchedAndFormula = "Price > 100";

// ❌ Unsafe (user input directly injected)
options.MergeMatchedAndFormula = $"Price > {userInput}";
```

--------------------------------

### BulkUpdate examples for EF Core

Source: https://entityframework-extensions.net/bulk-extensions

Shows how to use BulkUpdate for simple updates, updating specific columns via ColumnInputExpression, updating from an anonymous list, and the async version. Requires the Z.EntityFramework.Extensions.EFCore NuGet package.

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

// Simple bulk update
context.BulkUpdate(customers);

// Bulk update specific columns using an expression
context.BulkUpdate(customers, options =>
{
    options.ColumnInputExpression = x => new { x.FirstName, x.LastName };
});

// Bulk update from an anonymous list
context.BulkUpdate<Customer>(anonymousList);

// Bulk update async version
await context.BulkUpdateAsync(customers);
```

--------------------------------

### Configuring BulkDelete options - three approaches

Source: https://entityframework-extensions.net/bulk-delete

Shows three ways to configure options for BulkDelete: a simple lambda expression, a lambda expression with a body, and a BulkOperationOption instance. The instance approach is useful for reusing configurations across multiple operations.

```csharp
// @nuget: Z.EntityFramework.Extensions.EFCore
using Z.EntityFramework.Extensions;

// Using a lambda expression (only works with one option)
context.BulkDelete(list, options => options.IncludeGraph = true);

// Using a lambda expression with a body (works with one or multiple options)
context.BulkDelete(list, options =>
{
    options.IncludeGraph = true;
    options.ColumnPrimaryKeyExpression = x => new { x.ID };
});

// Using a `BulkOperationOption` instance
var options = context.CreateBulkOptions<EntitySimple>();
options.IncludeGraph = true;
options.ColumnPrimaryKeyExpression = x => new { x.ID };

context.BulkDelete(list, options);
```

--------------------------------

### Configure BookStore DbContext with UseMySql

Source: https://entityframework-extensions.net/efcore-devart-mysql-provider

Creates a DbContext derived class that overrides OnConfiguring to use the UseMySql method with a connection string, and exposes DbSet properties for Authors and Books.

```csharp
public class BookStore : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseMySql(@"server=localhost;database=BookStoreDb;uid=root;password=;");
    }
        
    public DbSet<Author> Authors { get; set; }
    public DbSet<Book> Books { get; set; }
}
```

--------------------------------

### Install MySql.Data.Entity via Package Manager Console

Source: https://entityframework-extensions.net/mysql-provider

Use this NuGet command to install the MySql.Data.Entity package, which automatically adds the EF provider registration to the config file.

```powershell
PM> Install-Package MySql.Data.Entity
```
Tokens:
Raw