Indiko.Blocks.DataAccess.EntityFramework 2.1.2

Indiko.Blocks.DataAccess.EntityFramework

Entity Framework Core implementation of the Indiko data access abstractions, providing full-featured ORM support for relational databases.

Overview

This package provides a complete Entity Framework Core implementation of the Indiko data access layer, supporting SQL Server, PostgreSQL, MySQL, SQLite, and other relational databases.

Features

• EF Core Integration: Full Entity Framework Core 9+ support
• Repository Implementation: Complete IRepository<TEntity, TIdType> implementation
• Unit of Work: Transaction management with EF Core
• DbContext: Base DbContext with automatic configuration
• Migrations Support: Full EF Core migrations support
• Change Tracking: Automatic entity state management
• Soft Delete: Built-in soft delete with query filters
• Design-Time Factory: Support for EF Core tools
• Model Builder: Fluent API configuration support
• Performance: No-tracking queries, compiled queries
• Multiple Databases: Support for SQL Server, PostgreSQL, MySQL, SQLite, Oracle

Installation

dotnet add package Indiko.Blocks.DataAccess.EntityFramework

Quick Start

Define Your DbContext

using Indiko.Blocks.DataAccess.EntityFramework;

public class AppDbContext : BaseDbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
    {
    }

    public DbSet<User> Users { get; set; }
    public DbSet<Order> Orders { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        
        // Apply entity configurations
        modelBuilder.ApplyConfigurationsFromAssembly(typeof(AppDbContext).Assembly);
    }
}

Configure Services

public class Startup : WebStartup
{
    public override void ConfigureServices(IServiceCollection services)
    {
        base.ConfigureServices(services);
        
        services.UseEntityFrameworkDataAccess<AppDbContext>(options =>
        {
            options.ConnectionString = Configuration.GetConnectionString("DefaultConnection");
            options.DatabaseType = DatabaseType.SqlServer;
        });
    }
}

Entity Configuration

public class User : BaseEntity<Guid>
{
    public string Name { get; set; }
    public string Email { get; set; }
    public virtual ICollection<Order> Orders { get; set; }
}

public class UserConfiguration : IEntityTypeConfiguration<User>
{
    public void Configure(EntityTypeBuilder<User> builder)
    {
        builder.ToTable("Users");
        builder.HasKey(u => u.Id);
        
        builder.Property(u => u.Name)
            .IsRequired()
            .HasMaxLength(200);
            
        builder.Property(u => u.Email)
            .IsRequired()
            .HasMaxLength(256);
            
        builder.HasIndex(u => u.Email).IsUnique();
        
        builder.HasMany(u => u.Orders)
            .WithOne(o => o.User)
            .HasForeignKey(o => o.UserId);
    }
}

Usage Examples

Basic CRUD

public class UserService
{
    private readonly IRepository<User, Guid> _userRepository;
    private readonly IUnitOfWork _unitOfWork;

    public UserService(IRepository<User, Guid> userRepository, IUnitOfWork unitOfWork)
    {
        _userRepository = userRepository;
        _unitOfWork = unitOfWork;
    }

    public async Task<User> CreateAsync(string name, string email)
    {
        var user = new User { Name = name, Email = email };
        await _userRepository.AddAsync(user);
        await _unitOfWork.SaveChangesAsync();
        return user;
    }

    public async Task<User> GetByIdAsync(Guid id)
    {
        return await _userRepository.ReadByIdAsync(id);
    }

    public async Task<IEnumerable<User>> GetActiveUsersAsync()
    {
        return await _userRepository.ReadManyByQueryAsync(u => u.Status == Status.Active);
    }
}

Eager Loading

// Load user with orders
var user = await _userRepository.ReadByIdAsync(
    userId,
    asNotracking: false,
    includes: u => u.Orders
);

// Load user with nested navigation properties
var user = await _userRepository.ReadByIdAsync(
    userId,
    asNotracking: true,
    includes: new Expression<Func<User, object>>[] 
    {
        u => u.Orders,
        u => u.Orders.Select(o => o.Items)
    }
);

// Using string-based includes
var users = await _userRepository.ReadManyByQueryWithIncludesAsync(
    where: u => u.IsActive,
    asNotracking: true,
    includes: "Orders", "Orders.Items", "Profile"
);

Queries with Projections

// Select specific properties
var userDtos = await _userRepository.ReadByQueryWithSelectorAsync(
    where: u => u.IsActive,
    selector: u => new UserDto
    {
        Id = u.Id,
        Name = u.Name,
        Email = u.Email,
        OrderCount = u.Orders.Count
    }
);

// Paged projection
var pagedUserNames = await _userRepository.ReadByQueryWithSelectorPagedAsync(
    where: u => u.IsActive,
    selector: u => u.Name,
    page: 1,
    pageSize: 50
);

Transactions

public async Task ProcessOrderAsync(Order order)
{
    await _unitOfWork.BeginTransactionAsync();
    
    try
    {
        var orderRepo = _manager.GetRepository<Order, Guid>();
        var inventoryRepo = _manager.GetRepository<InventoryItem, Guid>();
        
        // Add order
        await orderRepo.AddAsync(order);
        
        // Update inventory
        foreach (var item in order.Items)
        {
            var inventoryItem = await inventoryRepo.ReadByIdAsync(item.ProductId);
            inventoryItem.Quantity -= item.Quantity;
            await inventoryRepo.UpdateAsync(inventoryItem);
        }
        
        await _unitOfWork.SaveChangesAsync();
        await _unitOfWork.CommitTransactionAsync();
    }
    catch
    {
        await _unitOfWork.RollbackTransactionAsync();
        throw;
    }
}

Configuration Options

appsettings.json

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=localhost;Database=MyApp;Trusted_Connection=True;"
  },
  "DataAccess": {
    "DatabaseType": "SqlServer",
    "EnableSensitiveDataLogging": false,
    "CommandTimeout": 30,
    "MaxRetryCount": 3,
    "EnableDetailedErrors": false
  }
}

Code Configuration

services.UseEntityFrameworkDataAccess<AppDbContext>(options =>
{
    options.ConnectionString = Configuration.GetConnectionString("DefaultConnection");
    options.DatabaseType = DatabaseType.SqlServer;
    options.EnableSensitiveDataLogging = env.IsDevelopment();
    options.CommandTimeout = 60;
});

Migrations

Create Migration

dotnet ef migrations add InitialCreate --context AppDbContext

Apply Migration

dotnet ef database update --context AppDbContext

Generate SQL Script

dotnet ef migrations script --context AppDbContext --output migration.sql

Design-Time DbContext Factory

public class AppDbContextFactory : BaseDbContextDesignTimeFactory<AppDbContext>
{
    protected override AppDbContext CreateDbContext(DbContextOptions<AppDbContext> options)
    {
        return new AppDbContext(options);
    }
}

Soft Delete

Entities inheriting from BaseEntity support soft delete:

// Soft delete (sets Status = Deleted)
await _userRepository.DeleteAsync(userId, useSoftDelete: true);

// Hard delete (removes from database)
await _userRepository.DeleteAsync(userId, useSoftDelete: false);

// Query filters automatically exclude soft-deleted entities
var activeUsers = await _userRepository.ReadAllAsync(); // Excludes deleted

Performance Tips

No-Tracking Queries

// For read-only scenarios
var users = await _userRepository.ReadManyByQueryAsync(
    where: u => u.IsActive,
    asNotracking: true  // Faster, no change tracking overhead
);

AsQueryable for Complex Queries

var query = _userRepository.AsQueryable()
    .Where(u => u.IsActive)
    .Include(u => u.Orders)
    .ThenInclude(o => o.Items)
    .OrderByDescending(u => u.CreatedAt)
    .Take(10);

var users = await query.ToListAsync();

Batch Operations

// More efficient than individual operations
await _userRepository.AddRangeAsync(users);
await _unitOfWork.SaveChangesAsync();

Supported Databases

• SQL Server (2012+)
• PostgreSQL (10+)
• MySQL (5.7+)
• SQLite (3.7+)
• Oracle (11g+)
• MariaDB (10.2+)

Target Framework

• .NET 10

Dependencies

• Indiko.Blocks.DataAccess.Abstractions
• Microsoft.EntityFrameworkCore (9.0+)
• Microsoft.EntityFrameworkCore.Relational

License

See LICENSE file in the repository root.

Related Packages

• Indiko.Blocks.DataAccess.Abstractions - Core data access abstractions
• Indiko.Blocks.DataAccess.MongoDb - MongoDB implementation
• Indiko.Blocks.DataAccess.Marten - Event sourcing with Marten
• Microsoft.EntityFrameworkCore.SqlServer - SQL Server provider
• Npgsql.EntityFrameworkCore.PostgreSQL - PostgreSQL provider