DataArc.EntityFrameworkCore.SqlServer 2.0.0

DataArc.EntityFrameworkCore.SqlServer

Commercial SQL Server tooling for transaction-coordinated execution, multi-context coordination, and relational model composition.

DataArc.EntityFrameworkCore.SqlServer extends the free DataArc.EntityFrameworkCore package with advanced SQL Server-specific capabilities.

Applications continue to use normal Entity Framework Core DbContext instances, IDbContextFactory<TContext>, LINQ, change tracking, dependency injection, and transaction APIs.

DataArc adds transactional execution, coordinated command and query tooling, and relational database composition where applications require stronger execution guarantees or need to operate across multiple DbContext boundaries.

Supports .NET 6 through .NET 10.

Install

dotnet add package DataArc.EntityFrameworkCore.SqlServer

DataArc.EntityFrameworkCore.SqlServer builds on DataArc.EntityFrameworkCore, which provides the free parallel execution and bulk operation foundation.

Registration

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

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

Register Entity Framework Core contexts normally:

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

The normal Entity Framework Core programming model remains unchanged.

What This Package Adds

DataArc.EntityFrameworkCore.SqlServer adds commercial SQL Server capabilities on top of DataArc.EntityFrameworkCore, including:

• Transaction-aware bulk inserts and deletes
• Participation in caller-owned Entity Framework Core transactions
• Transaction-coordinated parallel execution
• Composable transactional execution through AsParallelTransaction()
• 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 licensing and server-authority validation

Transactional Bulk Operations

Bulk operations can participate in an existing Entity Framework Core transaction while ordinary tracked Entity Framework Core operations continue to use the same DbContext.

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

await dbContext.AddBulkTransactionalAsync(
    primaryEntities,
    100_000,
    "prim");

await dbContext.AddBulkTransactionalAsync(
    foreignEntities,
    100_000,
    "foreign");

var trackedEntity = primaryEntities.First();

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

await transaction.CommitAsync();

The bulk operations execute inside the active transaction and remain uncommitted until the application commits that transaction.

The transaction remains owned by the application.

DataArc does not commit or roll back a caller-owned transaction.

This allows DataArc bulk execution and ordinary tracked Entity Framework Core operations to participate in the same transaction boundary.

Parallel Transactional Execution

For workloads that require composable parallel execution with transactional guarantees, use AsParallelTransaction().

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

AsParallelTransaction() creates a transaction-coordinated DataArc execution builder over the existing DbContext.

Standard entity operations and bulk operations can be composed before execution.

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

This is distinct from the non-transactional parallel execution provided by the free package:

DataArc.EntityFrameworkCore

    AsParallel()
        ↓
    compose operations
        ↓
    SaveChangesParallelAsync()


DataArc.EntityFrameworkCore.SqlServer

    AsParallelTransaction()
        ↓
    compose operations
        ↓
    CommitTransactionParallelAsync()
        ↓
    transaction-coordinated execution

The distinction allows applications to choose the execution model required by a particular workload without changing the underlying Entity Framework Core programming model.

Standard Entity Framework Core Remains Available

DataArc does not replace DbContext.

The same context can continue to use ordinary Entity Framework Core operations before or after DataArc execution:

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

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

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

await transaction.CommitAsync();

var employee = new Employee
{
    Name = "Example"
};

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

Entity Framework Core retains responsibility for its normal change tracking, querying, and persistence behavior.

DataArc adds additional execution capabilities where they are required.

Multi-Context Command and Query Tooling

DataArc.EntityFrameworkCore.SqlServer provides tooling for applications that need to coordinate operations across multiple Entity Framework Core context boundaries.

This allows separate DbContext models to remain independently usable through normal Entity Framework Core while selected workflows opt into DataArc coordination.

The commercial package provides command and query capabilities for scenarios where a single application operation needs to work across more than one registered database execution context.

This is particularly useful in systems where DbContext boundaries represent application or domain boundaries without requiring every boundary to become an isolated persistence model.

DDL Builder

DataArc.EntityFrameworkCore.SqlServer includes the DataArc DDL Builder for applications that require deliberate control over how Entity Framework Core models are composed into relational SQL Server databases.

The DDL Builder supports architectures where multiple DbContext models represent separate application boundaries while still participating in intentionally structured relational database topologies.

Supported scenarios include:

• Multiple DbContext models composed into one physical relational database
• Schema-based organization within a shared database
• Foreign keys and relational constraints across composed models where appropriate
• Multiple independent relational databases
• Separate connection strings for independently deployed database models
• Full relational modelling within each independent database
• Database creation from deliberately composed Entity Framework Core models

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

For example, an application can preserve separate context boundaries while composing those models into a single normalized relational database with database-enforced foreign keys and constraints.

Alternatively, contexts can participate in separate physical databases where isolation is the required topology.

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

Relationship to DataArc.EntityFrameworkCore

The package relationship is deliberately one-way:

DataArc.EntityFrameworkCore
        ↑
        │
DataArc.EntityFrameworkCore.SqlServer

DataArc.EntityFrameworkCore provides the free foundation and does not depend on the commercial SQL Server package.

DataArc.EntityFrameworkCore.SqlServer builds on that foundation and adds commercial SQL Server capabilities to the same DataArc Entity Framework Core programming surface.

Applications can therefore use the free package independently and introduce the commercial package only where its additional capabilities are required.

Licensing

DataArc.EntityFrameworkCore.SqlServer is a commercial DataArc product.

Use of its commercial functionality requires a valid DataArc commercial entitlement and server initialization.

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

Installing the package does not grant a commercial entitlement.

Without valid commercial initialization, functionality protected by the DataArc commercial license is not available for use.

See the included license file and DataArc product documentation for complete licensing terms.

Documentation

Implementation guidance, examples, demonstrations, licensing information, and product documentation are available through DataArc.

• Documentation: dataarc.dev
• NuGet: DataArc.EntityFrameworkCore.SqlServer
• Support: support@dataarc.dev

DataArc

Structured .NET tooling for complex application boundaries.