Overview

Start with the DbContext you already use

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

Applications continue to use normal Entity Framework Core APIs, LINQ, change tracking, dependency injection, IDbContextFactory<TContext>, and ordinary tracked persistence.

Use DataArc where composed parallel or high-volume execution is useful and continue using Entity Framework Core normally everywhere else.

Supports .NET 6 through .NET 10.

Free to Use

Composable parallel and bulk execution without a commercial DataArc license

DataArc.EntityFrameworkCore is available free of charge.

Use it in personal, commercial, educational, government, and enterprise .NET applications without purchasing a DataArc commercial license.

dotnet add package DataArc.EntityFrameworkCore

Registration

Register DataArc.EntityFrameworkCore once in the application dependency-injection pipeline. Continue registering Entity Framework Core contexts normally.

services.AddDataArcCore();

Free Execution Features

Compose standard and high-volume write operations without redesigning the persistence layer

• 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

Immediate Bulk Operations

Execute directly against a standard DbContext

Immediate bulk operations execute when called. They do not wait for a later Entity Framework Core SaveChangesAsync().

AddBulkAsync

Insert entities into the database in batches.

await dbContext.AddBulkAsync(
    employees,
    batchSize);

Supply a schema when the target table is not in dbo.

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

RemoveBulkAsync

Delete entities from the database in batches.

await dbContext.RemoveBulkAsync(
    employees,
    batchSize);

Parallel Execution Builder

Compose standard and bulk operations and execute one DataArc pipeline

AsParallel() creates a DataArc execution builder over the existing DbContext, scoped to that originating context.

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

Standard entity operations and DataArc bulk operations can be composed before execution. The terminal SaveChangesParallelAsync() executes the queued operations through the DataArc parallel execution path and returns the number of affected rows.

DbContext
    |
    v
AsParallel()
    |
    +-- Add(...)
    |
    +-- AddBulk(...)
    |
    v
SaveChangesParallelAsync()
    |
    v
parallel execution

The builder supports standard entity write operations together with DataArc bulk operations without replacing the application's existing Entity Framework Core persistence model.

Standard DbContext Usage

Keep the Entity Framework Core programming model

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

Contexts created through standard Entity Framework Core factories continue to query and persist normally.

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

var existingEmployees = await dbContext
    .Employees
    .AsNoTracking()
    .ToListAsync();

await dbContext.AddBulkAsync(
    newEmployees,
    batchSize);

This allows DataArc parallel or high-volume execution to be introduced into individual workflows without redesigning repositories or replacing the application's existing persistence model.

Performance

High throughput with low managed-memory allocation

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

Memory efficiency is particularly useful for APIs, background workers, integration services, imports, synchronization workloads, batch processing, and long-running application services.

AddBulkAsync Benchmark

At 100,000 entities, the benchmark completed in approximately 453 ms while allocating 23.73 MB of managed memory.

Benchmarks were produced using BenchmarkDotNet. Actual performance will vary depending on hardware, database configuration, entity structure, runtime version, and execution environment.

Commercial SQL Server Tooling

Add stronger transactional, multi-context, and relational database capabilities

DataArc.EntityFrameworkCore.SqlServer is the commercial extension to the free DataArc.EntityFrameworkCore package.

Install it only where the application requires the additional SQL Server capabilities.

dotnet add package DataArc.EntityFrameworkCore.SqlServer

• Transaction-aware bulk inserts and deletes
• Participation in caller-owned Entity Framework Core transactions
• Parallel transactional execution
• Transactional execution pipelines
• Multi-context command coordination
• Multi-context query composition
• DataArc DDL Builder capabilities
• Composition of multiple DbContext models into deliberate relational database topologies
• SQL Server-specific execution infrastructure

Commercial Registration

Commercial SQL Server capabilities require DataArc Core initialization with a server key.

services.AddDataArcCore(options =>
    options.UseServerKey());

Transactional Bulk Operations

Commercial bulk operations can participate in a caller-owned Entity Framework Core transaction.

await using var transaction =
    await dbContext.Database.BeginTransactionAsync();

await dbContext.AddBulkTransactionalAsync(
    employees,
    100_000,
    "hr");

await transaction.CommitAsync();

The transaction remains owned by the application. DataArc does not commit or roll back a caller-owned transaction.

Parallel Transactional Execution

AsParallelTransaction() is provided by DataArc.EntityFrameworkCore.SqlServer. It uses the same compositional builder model as AsParallel() while executing through the commercial SQL Server transactional path.

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

CommitTransactionParallelAsync() executes the queued operations through the DataArc transaction-coordinated parallel path.

Multi-Context Command and Query Tooling

Coordinate selected workflows across DbContext boundaries

DataArc.EntityFrameworkCore.SqlServer provides command and query tooling for operations that need to coordinate work across multiple registered Entity Framework Core execution contexts.

Each DbContext remains independently usable through normal Entity Framework Core APIs. Selected workflows can opt into DataArc coordination only where a broader application operation requires it.

DDL Builder

Keep application boundaries without automatically creating relational boundaries

The commercial SQL Server package includes the DataArc DDL Builder for applications that need deliberate control over how multiple Entity Framework Core models are composed into relational databases.

var dbBuilder =
    _databaseBuilderFactory.CreateDatabaseBuilder();

var db = dbBuilder
    .IncludeDbContext<DatabaseContextReadCommitted>()
    .IncludeDbContext<DatabaseContextReadUncommitted>()
    .IncludeDbContext<DatabaseContextSerializable>()
    .IncludeDbContext<DatabaseContextRepeatableRead>()
    .IncludeDbContext<DatabaseContextSnapshot>()
    .Build(
        applyChanges: true,
        generateScripts: true);

db.ExecuteDrop();
db.ExecuteCreate();

A DbContext boundary does not have to become a relational boundary.

Multiple independently defined contexts can participate in one physical relational database with schemas, foreign keys, constraints, and database-enforced relational integrity where appropriate.

DataArc also supports multiple independent relational databases, each with its own connection string and its own relational model and constraints.

The database topology remains an architectural choice rather than an automatic consequence of the DbContext boundary.

DataArc Orchestration Framework

Compose application orchestration, observation, and free persistence capabilities

DataArc.OrchestrationFramework is available free of charge.

The Framework combines DataArc.Orchestrator, DataArc.Observer, DataArc.EntityFrameworkCore, and supporting DataArc infrastructure into a single application orchestration composition.

DataArc.EntityFrameworkCore.SqlServer remains a separate commercial package and is not required to use the Framework.

dotnet add package DataArc.OrchestrationFramework

Licensing

Free foundation, commercial SQL Server extension

DataArc.EntityFrameworkCore is available free of charge and does not require a DataArc commercial license, subscription, activation, or runtime entitlement.

DataArc.EntityFrameworkCore.SqlServer is a commercial DataArc product. Its commercial functionality requires the applicable DataArc entitlement and server initialization.

Installing or using the free package does not grant rights to the commercial SQL Server package, and using the free package does not require purchasing it.

Documentation

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

Support

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