TinyHelpers.EntityFrameworkCore 3.0.78

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 persistence intent of your Entity Framework Core model close to the entity type or model configuration 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 Entity Framework 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 Entity Framework Core change tracking aligned with the persisted representation.

JsonStringConverter<T>

Converts a CLR object graph to and from a JSON string for storage in a text column.

Use it when a value object or small object graph belongs to the entity and should live in one 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 Entity Framework Core detects changes based on serialized content instead of object reference identity, avoiding redundant updates when two values serialize to the same payload.

StringArrayConverter

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

Use it when a small string collection should stay on the entity row and does not need independent relational querying.

StringArrayComparer

Compares string sequences by content and order.

Use it together with StringArrayConverter so Entity Framework Core treats two collections as equal when they contain the same values in the same order, even when the collection instances are different.

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 conversion and comparison pieces together so model configuration can state persistence intent once while Entity Framework Core still receives the metadata it needs for materialization and change tracking.

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 centralize model-wide conventions such as soft delete, tenant isolation, or visibility rules so each entity type does not need duplicate configuration.

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 Entity Framework Core execution strategies and explicit transactions so retry behavior stays consistent and transaction boilerplate stays out of repositories and services.

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.