TinyHelpers.EntityFrameworkCore 3.0.76

Tiny Helpers for Entity Framework Core

TinyHelpers.EntityFrameworkCore is a small collection of practical helpers for Entity Framework Core applications: value converters, value comparers, global query filters, transaction helpers, and vector-column mapping.

The package is designed to reduce repetitive configuration and keep the intent of your EF Core model close to the entity type that uses it.

Compatibility

The package targets:

• .NET 8
• .NET 9
• .NET 10

Some features are framework-specific:

• Named query filters are available only on .NET 10+
• The package focuses on EF Core model configuration, conversions, and transaction helpers

Installation

Install the package from NuGet:

dotnet add package TinyHelpers.EntityFrameworkCore

Or search for TinyHelpers.EntityFrameworkCore in the Visual Studio Package Manager.

Contents

• Converters and comparers
• Property builder helpers
• Query filters
• Transaction helpers
• Vector columns
• Quick examples
• Contribute

Converters and comparers

This area contains helpers for storing common CLR shapes in a single database column while keeping EF Core change tracking aligned with the persisted representation.

JsonStringConverter<T>

Converts a CLR object graph to and from a JSON string.

Use it when you want to store a complex type in a text column without manually handling serialization in every entity configuration.

JsonStringComparer<T>

Compares values by their JSON representation.

Use it together with JsonStringConverter<T> so EF Core detects changes based on serialized content instead of object reference identity.

StringArrayConverter

Converts a sequence of strings to a single delimiter-separated value.

Use it when a small string collection should be stored in one column and you do not need a separate relational table.

StringArrayComparer

Compares string sequences by content and order.

Use it together with StringArrayConverter so EF Core treats two collections as equal when they contain the same values in the same order.

StringEmptyToNullConverter

Normalizes blank strings to null before persistence.

Use it when an empty or whitespace-only value should be treated as the absence of data.

StringEmptyToNullTrimConverter

Normalizes blank strings to null and trims meaningful values before persistence.

Use it when user input should not preserve incidental leading or trailing whitespace.

Property builder helpers

PropertyBuilderExtensions

These helpers keep the most common EF Core configuration patterns in one place.

Example

using Microsoft.EntityFrameworkCore;
using TinyHelpers.EntityFrameworkCore.Extensions;

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>(builder =>
    {
        builder.Property(x => x.Metadata).HasJsonConversion();
        builder.Property(x => x.Tags).HasArrayConversion(",");
        builder.Property(x => x.Embedding).IsVector(1536);
    });
}

Query filters

ModelBuilderExtensions

These helpers make it easier to apply the same global filter to multiple entity types.

Example

using Microsoft.EntityFrameworkCore;
using TinyHelpers.EntityFrameworkCore.Extensions;

public abstract class DeletableEntity
{
    public bool IsDeleted { get; set; }
}

public interface ISoftDeletable
{
    bool IsDeleted { get; set; }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.ApplyQueryFilter<DeletableEntity>(e => !e.IsDeleted);
    modelBuilder.ApplyQueryFilter<ISoftDeletable>(e => !e.IsDeleted);
}

.NET 10 named filters

Starting with .NET 10, named filters let you attach a name to each query filter and disable only the ones you need:

modelBuilder.ApplyQueryFilter<ISoftDeletable>("SoftDelete", e => !e.IsDeleted);
modelBuilder.ApplyQueryFilter<ITenantEntity>("TenantFilter", e => e.TenantId == currentTenantId);

Later, you can disable just one filter:

var items = await context.Set<Order>().IgnoreQueryFilters(["SoftDelete"]).ToListAsync();

Transaction helpers

DbContextExtensions

These helpers wrap EF Core execution strategies and transactions so the retry behavior stays consistent.

Example

using TinyHelpers.EntityFrameworkCore.Extensions;

await context.ExecuteTransactionAsync(async cancellationToken =>
{
    context.Add(new Order { Id = 1 });
    await context.SaveChangesAsync(cancellationToken);
});

Vector columns

VectorAttribute

Marks a property or field as a vector column.

Use it when your database provider supports vector types and you want the mapping intent to live directly on the entity member.

Example

using System.ComponentModel.DataAnnotations.Schema;

public sealed class Document
{
    public int Id { get; set; }

    [Vector(1536)]
    public float[] Embedding { get; set; } = [];
}

Quick examples

JSON-backed property mapping

using Microsoft.EntityFrameworkCore;
using TinyHelpers.EntityFrameworkCore.Extensions;

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>(builder =>
    {
        builder.Property(x => x.Metadata).HasJsonConversion();
    });
}

String collection mapping

using Microsoft.EntityFrameworkCore;
using TinyHelpers.EntityFrameworkCore.Extensions;

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>(builder =>
    {
        builder.Property(x => x.Tags).HasArrayConversion(",");
    });
}

Global soft-delete filter

using Microsoft.EntityFrameworkCore;
using TinyHelpers.EntityFrameworkCore.Extensions;

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.ApplyQueryFilter<ISoftDeletable>(e => !e.IsDeleted);
}

Contribute

The project is continuously evolving. Contributions, issues, and pull requests are welcome.