👁 Image
RCommon.Entities 2.4.1

RCommon.Entities

Domain entity base classes for the RCommon framework, providing a strongly-typed BusinessEntity<TKey> base with built-in transactional event tracking, auditing support via AuditedEntity, and an IEntityEventTracker that collects and emits entity events through the event routing infrastructure.

Features

• BusinessEntity and BusinessEntity<TKey> abstract base classes with composite and single-key support
• Built-in transactional (local) event accumulation on entities via AddLocalEvent, RemoveLocalEvent, and ClearLocalEvents
• Entity-level event notifications (TransactionalEventAdded, TransactionalEventRemoved, TransactionalEventsCleared) for observing event changes
• AuditedEntity base classes that track CreatedBy, DateCreated, LastModifiedBy, and DateLastModified with flexible user types
• ITrackedEntity interface for opting entities into event tracking
• IEntityEventTracker and InMemoryEntityEventTracker for collecting entity events across object graphs and routing them through IEventRouter
• Soft delete -- ISoftDelete opt-in interface for logical deletion (IsDeleted flag) instead of physical removal
• Multitenancy -- IMultiTenant opt-in interface for tenant-scoped entities (TenantId property)
• EntityNotFoundException for consistent "entity not found" error handling with type and ID context

Installation

dotnet add package RCommon.Entities

Usage

using RCommon.Entities;
using RCommon.Models.Events;

// Define a domain entity with a GUID key
public class Order : BusinessEntity<Guid>
{
 public string ProductName { get; set; }
 public int Quantity { get; set; }

 public void Submit()
 {
 // Add a transactional event that will be emitted on persistence
 AddLocalEvent(new OrderSubmittedEvent { OrderId = Id });
 }
}

// Define an audited entity tracking who created/modified it
public class Invoice : AuditedEntity<Guid, string, string>
{
 public decimal Amount { get; set; }
 public string Currency { get; set; }
}

// Emit entity events through the event router
public class OrderService
{
 private readonly IEntityEventTracker _eventTracker;

 public OrderService(IEntityEventTracker eventTracker)
 {
 _eventTracker = eventTracker;
 }

 public async Task ProcessOrderAsync(Order order)
 {
 order.Submit();
 _eventTracker.AddEntity(order);
 await _eventTracker.EmitTransactionalEventsAsync();
 }
}

Soft Delete

Implement ISoftDelete to opt an entity into logical deletion. Repositories will set IsDeleted = true and perform an UPDATE instead of a physical DELETE:

using RCommon.Entities;

public class Customer : BusinessEntity<int>, ISoftDelete
{
 public string Name { get; set; }
 public bool IsDeleted { get; set; }
}

// Soft delete — sets IsDeleted = true, performs UPDATE
await repository.DeleteAsync(customer, isSoftDelete: true);

// Physical delete — removes the record entirely
await repository.DeleteAsync(customer, isSoftDelete: false);

Entities implementing ISoftDelete are automatically filtered on read operations -- soft-deleted records are excluded from query results by default.

Multitenancy

Implement IMultiTenant to scope an entity to a specific tenant. Repositories will automatically stamp the TenantId on add operations and filter reads to only return records for the current tenant:

using RCommon.Entities;

public class Product : BusinessEntity<int>, IMultiTenant
{
 public string Name { get; set; }
 public string? TenantId { get; set; }
}

When both interfaces are combined, the entity supports soft delete and tenant isolation:

public class Invoice : BusinessEntity<Guid>, ISoftDelete, IMultiTenant
{
 public decimal Amount { get; set; }
 public bool IsDeleted { get; set; }
 public string? TenantId { get; set; }
}

Key Types

Documentation

For full documentation, visit rcommon.com.

Related Packages

• RCommon.Core - Foundation package with event bus, builder pattern, guards, and extensions
• RCommon.Models - Shared models for CQRS commands, queries, events, pagination, and execution results

License

Licensed under the Apache License, Version 2.0.