SharpCoreDB.EntityFrameworkCore 1.0.1

<div align="center"> <img src="https://raw.githubusercontent.com/MPCoreDeveloper/SharpCoreDB/master/SharpCoreDB.jpg" alt="SharpCoreDB Logo" width="200"/>

SharpCoreDB.EntityFrameworkCore

Entity Framework Core 10 Provider for SharpCoreDB

</div>

Overview

Entity Framework Core 10 database provider for SharpCoreDB - a high-performance encrypted embedded database engine. Use familiar EF Core APIs with SharpCoreDB's blazing-fast analytics, AES-256-GCM encryption, and SIMD acceleration.

Key Benefits:

• Full EF Core 10 support with LINQ, migrations, and change tracking
• AES-256-GCM encryption at rest with 0% performance overhead
• 345x faster analytics than traditional embedded databases
• Pure .NET implementation - works on Windows, Linux, macOS, Android, iOS, and IoT
• Multi-platform support: x64, ARM64 on all major operating systems

Installation

dotnet add package SharpCoreDB.EntityFrameworkCore

Requirements:

• .NET 10.0 or later
• Entity Framework Core 10.0.1 or later
• SharpCoreDB 1.0.0 or later (installed automatically)

Quick Start

1. Define Your DbContext

using Microsoft.EntityFrameworkCore;
using SharpCoreDB.EntityFrameworkCore;

public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Product> Products { get; set; }
    
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSharpCoreDB(
            databasePath: "./myapp.db",
            password: "MySecurePassword123!",
            storageEngine: StorageEngine.PageBased
        );
    }
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public decimal Salary { get; set; }
}

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

2. Use EF Core Normally

using (var context = new AppDbContext())
{
    // Create database and apply migrations
    context.Database.EnsureCreated();
    
    // Insert data
    context.Users.Add(new User 
    { 
        Name = "Alice", 
        Age = 30, 
        Salary = 75000 
    });
    context.SaveChanges();
    
    // Query with LINQ
    var highEarners = context.Users
        .Where(u => u.Salary > 50000)
        .OrderBy(u => u.Name)
        .ToList();
    
    // Fast analytics with SIMD acceleration
    var avgSalary = context.Users.Average(u => u.Salary);
    var totalSalary = context.Users.Sum(u => u.Salary);
}

Configuration Options

UseSharpCoreDB Extension Method

optionsBuilder.UseSharpCoreDB(
    databasePath: "./data.db",           // Database file path
    password: "YourPassword",            // Encryption password (required)
    storageEngine: StorageEngine.PageBased,  // Storage engine type
    configureOptions: options => 
    {
        // Optional: Configure SharpCoreDB-specific options
        options.EnableSensitiveDataLogging = true;
        options.CommandTimeout = TimeSpan.FromSeconds(30);
    }
);

Storage Engine Types

Dependency Injection

using Microsoft.Extensions.DependencyInjection;

var services = new ServiceCollection();

services.AddDbContext<AppDbContext>(options =>
    options.UseSharpCoreDB("./app.db", "SecurePassword123!"));

var provider = services.BuildServiceProvider();
var context = provider.GetRequiredService<AppDbContext>();

Features

[?] Supported EF Core Features

• CRUD Operations: Add, Update, Delete, Find
• LINQ Queries: Where, Select, OrderBy, GroupBy, Join
• Change Tracking: Automatic change detection and saving
• Migrations: Database schema migrations
• Relationships: One-to-many, many-to-many navigation properties
• Indexes: Automatic index creation for primary keys and foreign keys
• Transactions: Explicit and implicit transaction support
• Async/Await: Full async support for all operations
• Query Filters: Global query filters
• Value Conversions: Custom type converters
• Shadow Properties: Properties not on entity classes
• Owned Types: Complex types within entities

[?] SharpCoreDB-Specific Features

• AES-256-GCM Encryption: All data encrypted at rest with 0% overhead
• SIMD Analytics: 345x faster aggregations than traditional databases
• B-tree Indexes: O(log n) range queries with ORDER BY support
• Hash Indexes: O(1) point lookups for primary keys
• Multi-Platform: Windows, Linux, macOS, Android, iOS, IoT (x64, ARM64)
• Pure .NET: No native dependencies, works everywhere .NET runs
• NativeAOT Ready: Compatible with ahead-of-time compilation

[?] DDL Feature Support

SharpCoreDB supports advanced DDL features that enhance data integrity. Here's how they work with EF Core:

? DEFAULT Values (Fully Supported)

DEFAULT values work seamlessly with EF Core migrations and fluent API:

// Using Data Annotations
public class Product
{
    public int Id { get; set; }
    [DefaultValue("Unknown")]
    public string Name { get; set; }
    
    [DefaultValue(0)]
    public decimal Price { get; set; }
}

// Using Fluent API
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Product>()
        .Property(p => p.Name)
        .HasDefaultValue("Unknown");
        
    modelBuilder.Entity<Product>()
        .Property(p => p.CreatedAt)
        .HasDefaultValueSql("CURRENT_TIMESTAMP");
}

?? CHECK Constraints (Raw SQL Required)

EF Core 10 does not support CHECK constraints in migrations. Use raw SQL to add CHECK constraints:

// After creating your migration, add CHECK constraints manually
protected override void Up(MigrationBuilder migrationBuilder)
{
    // Create table with EF Core
    migrationBuilder.CreateTable(
        name: "Products",
        columns: table => new
        {
            Id = table.Column<int>(nullable: false),
            Name = table.Column<string>(nullable: false),
            Price = table.Column<decimal>(nullable: false),
            Stock = table.Column<int>(nullable: false)
        },
        constraints: table =>
        {
            table.PrimaryKey("PK_Products", x => x.Id);
        });

    // Add CHECK constraints with raw SQL
    migrationBuilder.Sql("ALTER TABLE Products ADD CONSTRAINT CK_Products_Price_Positive CHECK (Price > 0)");
    migrationBuilder.Sql("ALTER TABLE Products ADD CONSTRAINT CK_Products_Stock_NonNegative CHECK (Stock >= 0)");
    migrationBuilder.Sql("ALTER TABLE Products ADD CONSTRAINT CK_Products_Value CHECK (Price * Stock < 10000)");
}

protected override void Down(MigrationBuilder migrationBuilder)
{
    migrationBuilder.Sql("ALTER TABLE Products DROP CONSTRAINT CK_Products_Price_Positive");
    migrationBuilder.Sql("ALTER TABLE Products DROP CONSTRAINT CK_Products_Stock_NonNegative");
    migrationBuilder.Sql("ALTER TABLE Products DROP CONSTRAINT CK_Products_Value");
    migrationBuilder.DropTable(name: "Products");
}

Note: When EF Core adds CHECK constraint support in future versions, the SharpCoreDB provider will automatically support it through the standard migration operations.

Performance Benchmarks

Analytics Performance (EF Core)

Test: context.Users.Average(u => u.Salary) on 10,000 records

Insert Performance

Test: context.Users.AddRange(users); context.SaveChanges() with 10,000 records

Query Performance

Test: context.Users.Where(u => u.Age > 30).ToList() on 10,000 records

Note: SharpCoreDB excels at analytics workloads. For OLTP-heavy applications, consider SQLite. For analytics-heavy applications, SharpCoreDB is the clear winner.

Migrations

Create Migration

dotnet ef migrations add InitialCreate --project YourProject.csproj

Apply Migration

dotnet ef database update --project YourProject.csproj

Code-Based Migrations

using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;

[DbContext(typeof(AppDbContext))]
[Migration("20250101000000_InitialCreate")]
public partial class InitialCreate : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "Users",
            columns: table => new
            {
                Id = table.Column<int>(nullable: false)
                    .Annotation("SharpCoreDB:Identity", "1, 1"),
                Name = table.Column<string>(maxLength: 100, nullable: false),
                Age = table.Column<int>(nullable: false),
                Salary = table.Column<decimal>(precision: 18, scale: 2, nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_Users", x => x.Id);
            });
            
        migrationBuilder.CreateIndex(
            name: "IX_Users_Age",
            table: "Users",
            column: "Age");
    }
    
    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(name: "Users");
    }
}

Advanced Usage

Custom Index Configuration

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<User>(entity =>
    {
        // B-tree index for range queries
        entity.HasIndex(u => u.Age)
              .HasDatabaseName("IX_Users_Age_BTree")
              .HasAnnotation("SharpCoreDB:IndexType", "BTree");
        
        // Hash index for point lookups
        entity.HasIndex(u => u.Email)
              .IsUnique()
              .HasAnnotation("SharpCoreDB:IndexType", "Hash");
    });
}

Batch Operations

using (var context = new AppDbContext())
{
    // Batch inserts (significantly faster)
    var users = Enumerable.Range(1, 10000)
        .Select(i => new User { Name = $"User{i}", Age = 20 + (i % 50) })
        .ToList();
    
    context.Users.AddRange(users);
    context.SaveChanges(); // Uses SharpCoreDB's batch API internally
}

Analytics with Columnar Storage

// Use Columnar storage engine for analytics workloads
optionsBuilder.UseSharpCoreDB(
    "./analytics.db", 
    "Password", 
    StorageEngine.Columnar
);

// Fast SIMD-accelerated aggregations
var stats = context.Users
    .GroupBy(u => u.Department)
    .Select(g => new 
    {
        Department = g.Key,
        AvgSalary = g.Average(u => u.Salary),
        TotalSalary = g.Sum(u => u.Salary),
        Count = g.Count()
    })
    .ToList();

Async Operations

// All EF Core async operations are supported
await context.Users.AddAsync(new User { Name = "Bob", Age = 25 });
await context.SaveChangesAsync();

var users = await context.Users
    .Where(u => u.Age > 30)
    .ToListAsync();

var avgAge = await context.Users
    .AverageAsync(u => u.Age);

Platform Support

Supported Platforms

Runtime Identifiers (RIDs)

The NuGet package includes platform-specific optimizations for:

• win-x64, win-arm64
• linux-x64, linux-arm64
• osx-x64, osx-arm64

NuGet automatically selects the correct runtime assembly for your platform.

Security

Encryption Details

• Algorithm: AES-256-GCM (Galois/Counter Mode)
• Key Derivation: PBKDF2 with SHA-256 (100,000 iterations)
• Authenticated Encryption: Prevents tampering and ensures data integrity
• Hardware Acceleration: Uses AES-NI instructions when available
• Performance: 0% overhead (sometimes faster than unencrypted!)

Best Practices

1. Strong Passwords: Use at least 16 characters with mixed case, numbers, and symbols
2. Key Management: Store passwords securely (e.g., Azure Key Vault, environment variables)
3. Compliance: GDPR and HIPAA compliant when properly configured
4. Backup: Encrypted database files can be safely backed up

// Example: Load password from environment variable
var password = Environment.GetEnvironmentVariable("DB_PASSWORD") 
    ?? throw new InvalidOperationException("DB_PASSWORD not set");

optionsBuilder.UseSharpCoreDB("./secure.db", password);

Comparison with Other Providers

Troubleshooting

Common Issues

Issue: "Unable to load SharpCoreDB native library"

Solution: Ensure you're using a supported platform (Windows/Linux/macOS x64 or ARM64). The NuGet package should automatically select the correct runtime assembly.

# Verify your RID
dotnet --info

Issue: "Encryption password required"

Solution: SharpCoreDB requires encryption for all databases. Always provide a strong password:

// [?] Wrong - no password
optionsBuilder.UseSharpCoreDB("./data.db");

// [?] Correct - password provided
optionsBuilder.UseSharpCoreDB("./data.db", "SecurePassword123!");

Issue: "Migration not applying"

Solution: Ensure database file is not locked by another process:

// Dispose context properly
using (var context = new AppDbContext())
{
    context.Database.Migrate();
} // Context disposed here

Examples

Complete Console App Example

using Microsoft.EntityFrameworkCore;
using SharpCoreDB.EntityFrameworkCore;

public class Program
{
    public static async Task Main(string[] args)
    {
        using var context = new AppDbContext();
        
        // Create database
        await context.Database.EnsureCreatedAsync();
        
        // Seed data
        if (!context.Users.Any())
        {
            var users = Enumerable.Range(1, 1000)
                .Select(i => new User 
                { 
                    Name = $"User{i}", 
                    Age = 20 + (i % 50),
                    Salary = 30000 + (i * 100)
                })
                .ToList();
            
            context.Users.AddRange(users);
            await context.SaveChangesAsync();
            Console.WriteLine($"Inserted {users.Count} users");
        }
        
        // Query data
        var avgSalary = await context.Users.AverageAsync(u => u.Salary);
        Console.WriteLine($"Average Salary: ${avgSalary:N2}");
        
        var highEarners = await context.Users
            .Where(u => u.Salary > 50000)
            .OrderByDescending(u => u.Salary)
            .Take(10)
            .ToListAsync();
        
        Console.WriteLine("\nTop 10 Earners:");
        foreach (var user in highEarners)
        {
            Console.WriteLine($"  {user.Name}: ${user.Salary:N2}");
        }
    }
}

public class AppDbContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSharpCoreDB(
            "./example.db", 
            "MySecurePassword123!",
            StorageEngine.PageBased
        );
    }
    
    public DbSet<User> Users { get; set; }
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
    public decimal Salary { get; set; }
}

Roadmap

[?] Version 1.0.0 (Current)

• [?] Full EF Core 10 provider implementation
• [?] LINQ query translation
• [?] Migrations support
• [?] Change tracking
• [?] Relationships and navigation properties
• [?] AES-256-GCM encryption
• [?] Multi-platform support (Windows/Linux/macOS/Android/iOS)

[ ] Version 1.1.0 (Q1 2026)

• Improved query optimization (2-3x faster SELECT)
• SIMD-accelerated deserialization
• Connection pooling
• Bulk operations API
• Advanced indexing strategies

[ ] Version 1.2.0 (Q2 2026)

• Distributed queries
• Replication support
• Advanced analytics functions
• Performance monitoring tools

Contributing

Contributions are welcome! Areas of interest:

1. Query optimization
2. Additional EF Core features
3. Performance benchmarks
4. Documentation improvements
5. Platform-specific optimizations

Repository: https://github.com/MPCoreDeveloper/SharpCoreDB

License

MIT License - see LICENSE file for details.

Resources

• NuGet Package: SharpCoreDB.EntityFrameworkCore
• Core Library: SharpCoreDB
• Documentation: GitHub Wiki
• Issues: GitHub Issues
• Discussions: GitHub Discussions

Support

• Bug Reports: GitHub Issues
• Questions: GitHub Discussions
• Email: support@sharpcoredb.com (for enterprise support)

Version: 1.0.1
Last Updated: January 2026
Compatibility: .NET 10.0+, EF Core 10.0.1+, SharpCoreDB 1.0.4+, C# 14
Platforms: Windows, Linux, macOS, Android, iOS, IoT (x64, ARM64)