DataArc.EntityFrameworkCore 2.0.0

DataArc.EntityFrameworkCore

Composable parallel execution and high-performance bulk operations for Entity Framework Core without replacing Entity Framework Core.

DataArc.EntityFrameworkCore extends a standard Entity Framework Core DbContext with a parallel execution builder and memory-efficient bulk operations for data-intensive .NET workloads.

Use the same DbContext for DataArc execution and ordinary Entity Framework Core operations.

Free to Use

DataArc.EntityFrameworkCore is available free of charge.

It may be used in personal, commercial, educational, government, and enterprise .NET applications without purchasing a DataArc commercial license.

dotnet add package DataArc.EntityFrameworkCore

Supports .NET 6 through .NET 10.

The current bulk implementation targets SQL Server.

Quick Start

Create and use your DbContext through the normal Entity Framework Core APIs.

await using var dbContext =
    await dbContextFactory.CreateDbContextAsync();

var affected = await dbContext
    .AsParallel()
    .Add(entity)
    .AddBulk(data, batchSize)
    .SaveChangesParallelAsync();

AsParallel() creates a DataArc execution builder over the existing DbContext.

Operations can be composed before execution, including standard entity operations and high-volume bulk operations.

SaveChangesParallelAsync() executes the queued operations through the DataArc parallel execution path.

The same DbContext remains available for ordinary Entity Framework Core operations:

await dbContext.AddAsync(anotherEntity);
await dbContext.SaveChangesAsync();

DataArc does not replace:

• DbContext
• LINQ
• change tracking
• dependency injection
• IDbContextFactory<TContext>
• normal Entity Framework Core persistence

It adds an additional execution path for workloads where composed parallel or bulk operations are useful.

Registration

Register DataArc.EntityFrameworkCore once in the application dependency-injection pipeline:

services.AddDataArcCore();

Continue registering Entity Framework Core contexts normally:

services.AddDbContextFactory<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString));

Create contexts through the standard Entity Framework Core APIs:

await using var dbContext =
    await dbContextFactory.CreateDbContextAsync();

No alternative DbContext implementation or repository abstraction is required.

Parallel Execution Builder

Multiple operations can be composed against the same DbContext and executed through a DataArc parallel execution pipeline.

var affected = await dbContext
    .AsParallel()
    .Add(entity)
    .AddBulk(data, batchSize)
    .SaveChangesParallelAsync();

AsParallel() creates the DataArc parallel execution builder.

Operations are added to the builder before execution.

The terminal SaveChangesParallelAsync() executes the queued operations and returns the number of affected rows.

DbContext
    ↓
AsParallel()
    ↓
Add(...)
AddBulk(...)
    ↓
SaveChangesParallelAsync()
    ↓
parallel execution

The builder is scoped to the originating DbContext.

Once execution completes, the same context remains available for ordinary Entity Framework Core operations.

The builder supports standard entity write operations together with DataArc bulk operations, allowing high-volume work to be composed without replacing the application's existing Entity Framework Core persistence model.

Transactional Parallel Execution

Transaction-coordinated parallel execution is available through the commercial DataArc.EntityFrameworkCore.SqlServer package.

The programming model remains similar while execution moves through the SQL Server transactional path.

await dbContext
    .AsParallelTransaction()
    .Add(entity)
    .AddBulk(data, batchSize)
    .CommitTransactionParallelAsync();

AsParallelTransaction() and its transaction coordination capabilities are not part of the free DataArc.EntityFrameworkCore package.

For SQL Server transactional execution, multi-context coordination, DDL composition, and other commercial SQL Server capabilities, see DataArc.EntityFrameworkCore.SqlServer.

Immediate Bulk Operations

Bulk operations can also execute directly against a standard DbContext without creating a parallel execution builder.

AddBulkAsync

Insert entities in batches:

await dbContext.AddBulkAsync(
    employees,
    batchSize);

An optional schema can be supplied when the target table is not in dbo:

await dbContext.AddBulkAsync(
    employees,
    batchSize,
    schema: "hr");

AddBulkAsync executes immediately and does not wait for a later Entity Framework Core SaveChangesAsync() call.

RemoveBulkAsync

Delete entities in batches:

await dbContext.RemoveBulkAsync(
    employees,
    batchSize);

An optional schema can also be supplied:

await dbContext.RemoveBulkAsync(
    employees,
    batchSize,
    schema: "hr");

RemoveBulkAsync also executes immediately.

DataArc and Entity Framework Core on the Same DbContext

DataArc.EntityFrameworkCore does not take ownership of the DbContext and does not replace the Entity Framework Core change tracker.

A context can execute DataArc operations and then continue immediately with normal tracked EF Core operations.

await using var dbContext =
    await dbContextFactory.CreateDbContextAsync();

await dbContext
    .AsParallel()
    .Add(entity)
    .AddBulk(data, batchSize)
    .SaveChangesParallelAsync();

await dbContext.AddAsync(anotherEntity);
await dbContext.SaveChangesAsync();

The execution paths remain separate:

same DbContext
    │
    ├── DataArc
    │     AsParallel()
    │     Add(...)
    │     AddBulk(...)
    │     SaveChangesParallelAsync()
    │
    └── Entity Framework Core
          Add / Update / Remove
          SaveChangesAsync()

This allows DataArc execution to be introduced into individual workflows without replacing the application's existing Entity Framework Core persistence model.

IDbContextFactory Support

Applications can continue using the standard Entity Framework Core IDbContextFactory<TContext> pattern.

public sealed class EmployeeImportService
{
    private readonly IDbContextFactory<ApplicationDbContext> _dbContextFactory;

    public EmployeeImportService(
        IDbContextFactory<ApplicationDbContext> dbContextFactory)
    {
        _dbContextFactory = dbContextFactory;
    }

    public async Task ImportAsync(
        IEnumerable<Employee> employees,
        int batchSize)
    {
        await using var dbContext =
            await _dbContextFactory.CreateDbContextAsync();

        await dbContext.AddBulkAsync(
            employees,
            batchSize);
    }
}

DataArc works with contexts created through the same factory pattern already used by Entity Framework Core applications.

Standard Entity Framework Core Remains Standard

Queries remain ordinary Entity Framework Core:

var employees = await dbContext.Employees
    .AsNoTracking()
    .Where(employee => employee.Rating > rating)
    .ToListAsync();

Tracked persistence remains ordinary Entity Framework Core:

await dbContext.AddAsync(employee);
await dbContext.SaveChangesAsync();

Use DataArc where composed parallel or high-volume execution is useful.

Use Entity Framework Core normally everywhere else.

Features

DataArc.EntityFrameworkCore provides:

• Parallel execution over a standard DbContext
• Builder-style composition through AsParallel()
• Standard entity write operations within the parallel execution builder
• High-performance bulk insert and delete operations
• Composition of standard and bulk operations in the same execution pipeline
• Immediate bulk insert operations
• Immediate bulk delete operations
• High-throughput SQL Server bulk execution
• Batched execution for large data sets
• Memory-efficient bulk processing
• Optional database schema selection
• Compatibility with IDbContextFactory<TContext>
• Reuse of existing Entity Framework Core connections and metadata
• Normal tracked Entity Framework Core operations before and after DataArc execution

Performance

DataArc.EntityFrameworkCore is designed for high-throughput execution with low and predictable managed-memory allocation for large data workloads.

This is particularly useful for workloads such as:

• APIs
• background workers
• integration services
• imports
• synchronization processes
• batch processing
• long-running application services

Benchmarks, methodology, and execution results are available through the DataArc documentation and public repositories.

Documentation

Implementation guidance, benchmarks, examples, and demonstrations are available through the DataArc documentation and public repositories.

• Documentation: dataarc.dev
• Demo: DataArc.EntityFrameworkCore.Demos public GitHub repository
• Microsoft Learn: Entity Framework Core extensions

Support

For support and enquiries, contact support@dataarc.dev.

DataArc

Structured .NET tooling for complex application boundaries.