UnitofWork<T> — Deep Dive

UnitofWork<T> is the primary transactional data-access component in BeepDM. It wraps an ObservableBindingList<T> (OBL) and a backing IDataSource to provide change-tracking, events, validation, undo/redo, export, and commit/rollback — all in a single, generic unit pattern.

It works in two modes:

• Connected mode — backed by a live IDataSource (SQL, file, REST, DataView, …). Changes are persisted on Commit().
• List mode — works purely in-memory on a pre-loaded ObservableBindingList<T>. No datasource I/O.

Architecture

UnitofWork<T> is split across multiple partial classes. Each partial owns a clearly scoped concern:

UnitofWork<T>  (partial classes)
│
├── UnitofWork.Core.cs           — properties, constructors, Units/FilteredUnits
├── UnitofWork.Core.Extensions.cs — events declarations, Commit, Rollback, AddRange, Delete(doc)
├── UnitofWork.Core.Utilities.cs — Clear, IsDirty, DocExist, Getindex, ItemPropertyChangedHandler
├── UnitofWork.CRUD.cs           — Get, Get(filters), GetQuery, New, Add, Update, Delete(predicate)
├── UnitofWork.OBLIntegration.cs — passthrough to OBL: Validation, Undo, Computed, Bookmarks,
│                                   ThreadSafe, Freeze, BatchUpdate, Aggregates, Navigation
│
├── Helpers/
│   ├── UnitofWorkEventHelper    — CreateEventParams, RaiseEvent
│   ├── UnitofWorkValidationHelper — ValidateEntity, ValidateForInsert/Update/Delete
│   ├── UnitofWorkStateHelper    — GetEntityState, SetEntityState, MarkFor*
│   ├── UnitofWorkDataHelper     — InsertDoc, UpdateDoc, GetDataInUnits
│   ├── UnitofWorkDefaultsHelper — ApplyInsertDefaults, ApplyUpdateDefaults
│   ├── UnitofWorkCollectionHelper — FilterCollection, pagination helpers
│   ├── UnitofWorkExportHelper   — ToDataTable, ToJsonAsync, ToCsvAsync, LoadFrom*
│   ├── UnitofWorkQueryHistory   — RecordQuery, GetQueryHistory
│   └── UnitofWorkStateHelper    — entity state management
│
├── Models/
│   ├── ChangeSummary            — inserted/updated/deleted counts + per-field summary
│   └── QueryHistoryEntry        — timestamp, filter params, row count
│
└── UnitOfWorkFactory            — runtime-type factory → IUnitOfWorkWrapper

Interfaces implemented

Constructors

// Connected — schema detected from datasource
using var uow = new UnitofWork<Customer>(dme, "SalesDB", "Customers");

// Connected — schema supplied (faster, avoids round-trip)
using var uow = new UnitofWork<Customer>(dme, "SalesDB", "Customers", entityStructure);

// List mode — in-memory only
var list = new ObservableBindingList<Customer>(existingCustomers);
using var uow = new UnitofWork<Customer>(dme, true, list);

Core Properties

Identity & data access

State & collection

Paging

Soft delete

Optimistic concurrency

Commit control

Entity States

State is tracked automatically by ObservableBindingList<T>. The UnitofWorkStateHelper provides a facade over OBL's internal GetTrackingItem(entity).

// Read the state of a specific item
var state = uow._stateHelper.GetEntityState(customer);

// Force-mark as modified (useful when bypassing property change notification)
uow._stateHelper.MarkAsModified(customer);

// Accept all changes (clears dirty flag, resets all states to Unchanged)
uow.Units.AcceptChanges();

Revert a single item

// Revert one item to its original values (before the last AcceptChanges)
bool reverted = uow.RevertItem(customer);

// Async overload
bool reverted = await uow.RevertItemAsync(customer, cts.Token);

CRUD Operations

Create

Read

Update

Delete

Events Reference

All events use EventHandler<UnitofWorkParams>. The UnitofWorkParams argument carries the entity, a cancellation flag, and a human-readable message. Setting args.Cancel = true in any Pre- handler aborts the operation.

UnitofWorkParams

EventAction enum values

Event declarations

public event EventHandler<UnitofWorkParams> PreCreate;
public event EventHandler<UnitofWorkParams> PostCreate;
public event EventHandler<UnitofWorkParams> PreInsert;
public event EventHandler<UnitofWorkParams> PostInsert;
public event EventHandler<UnitofWorkParams> PreUpdate;
public event EventHandler<UnitofWorkParams> PostUpdate;
public event EventHandler<UnitofWorkParams> PreDelete;
public event EventHandler<UnitofWorkParams> PostDelete;
public event EventHandler<UnitofWorkParams> PreQuery;
public event EventHandler<UnitofWorkParams> PostQuery;
public event EventHandler<UnitofWorkParams> PreCommit;
public event EventHandler<UnitofWorkParams> PostCommit;
public event EventHandler<UnitofWorkParams> PostEdit;
public event EventHandler<UnitofWorkParams> OnItemReverted;

Subscribing to events

using var uow = new UnitofWork<Customer>(dme, "SalesDB", "Customers");

// ── Pre-events: inspect the record and optionally cancel ────────────────────

uow.PreCreate += (sender, args) =>
{
    var c = (Customer)args.Record;
    // Validate before the entity is added to Units
    if (string.IsNullOrWhiteSpace(c?.Name))
    {
        args.Cancel = true;
        args.Messege = "Customer name is required.";
    }
};

uow.PreInsert += (sender, args) =>
{
    var c = (Customer)args.Record;
    Console.WriteLine($"About to insert {c.Name} into datasource…");
    // Set args.Cancel = true to abort the INSERT to the datasource
};

uow.PreUpdate += (sender, args) =>
{
    var c = (Customer)args.Record;
    // Example: block updates for archived customers
    if (c.Status == "ARCHIVED")
    {
        args.Cancel = true;
        args.Messege = "Archived records cannot be modified.";
    }
};

uow.PreDelete += (sender, args) =>
{
    var c = (Customer)args.Record;
    Console.WriteLine($"Pre-Delete: {c.Name} (ID={c.ID})");
    // Example: require confirmation for premium customers
};

uow.PreQuery += (sender, args) =>
{
    Console.WriteLine("Loading data…");
    // args.Cancel = true would suppress the datasource round-trip
};

uow.PreCommit += (sender, args) =>
{
    // Final validation gate before any DB write
    if (!IsNetworkAvailable())
    {
        args.Cancel = true;
        args.Messege = "No database connection.";
    }
};

// ── Post-events: receive completed results ──────────────────────────────────

uow.PostCreate += (sender, args) =>
{
    var c = (Customer)args.Record;
    Console.WriteLine($"Entity created in memory: {c.Name}");
};

uow.PostInsert += (sender, args) =>
{
    var c = (Customer)args.Record;
    Console.WriteLine($"Inserted to DB: {c.Name}, new PK = {c.ID}");
};

uow.PostUpdate += (sender, args) =>
{
    var c = (Customer)args.Record;
    AuditLog.Record("UPDATE", c);
};

uow.PostDelete += (sender, args) =>
{
    var c = (Customer)args.Record;
    Console.WriteLine($"Deleted: {c.Name}");
};

uow.PostQuery += (sender, args) =>
{
    // sender is the Units collection after load
    Console.WriteLine($"Loaded {uow.Units.Count} rows.");
};

uow.PostCommit += (sender, args) =>
{
    Console.WriteLine("All changes committed — refreshing UI.");
    RefreshGrid();
};

// ── Property change ─────────────────────────────────────────────────────────
uow.PostEdit += (sender, args) =>
{
    Console.WriteLine($"Field '{args.PropertyName}' changed to '{args.PropertyValue}'");
    // Useful for live audit trails or conditional UI updates
};

// ── Revert notification ─────────────────────────────────────────────────────
uow.OnItemReverted += (sender, args) =>
{
    var c = (Customer)args.Record;
    Console.WriteLine($"Item reverted: {c.Name}");
};

Commit & Rollback

Commit internals

During Commit(), OBL's CommitAllAsync is called with three async lambdas (insert, update, delete). The _defaultsHelper applies audit defaults just before each DB call:

// Simplified internal Commit flow:
// 1. Raise PreCommit — abort if Cancel = true
// 2. DataSource.BeginTransaction()
// 3. OBL.CommitAllAsync(
//        insertAsync: item => { ApplyInsertDefaults(item); InsertDoc(item); },
//        updateAsync: item => { ApplyUpdateDefaults(item); UpdateDoc(item); },
//        deleteAsync: item => { DataSource.DeleteEntity(entityName, item); },
//        CommitOrder)
// 4. If AllSucceeded → DataSource.Commit() → AcceptChanges per item
//    Else            → DataSource.EndTransaction() (rollback)
// 5. Clear InsertedKeys/UpdatedKeys/DeletedKeys
// 6. Raise PostCommit

// Typical commit with cancellable progress
var cts = new CancellationTokenSource();
var progress = new Progress<PassedArgs>(p =>
    Console.WriteLine($"Progress: {p.ParameterString1}"));

var result = await uow.Commit(progress, cts.Token);
if (result.Flag != Errors.Ok)
{
    Console.WriteLine("Commit failed: " + result.Message);
    await uow.Rollback();
}

Validation

Validation is powered by OBL's built-in validation framework, which combines Data Annotations ([Required], [MaxLength], …) with EntityStructure-based rules described in the schema metadata.

// Enable auto-validate so grid cells show errors live
uow.IsAutoValidateEnabled = true;

// Manual validation before commit
var result = uow.ValidateAll();
if (!result.IsValid)
{
    foreach (var error in result.Errors)
        Console.WriteLine($"{error.FieldName}: {error.Message}");
    return;
}

// Get errors for a specific item
var errors = uow.GetErrors(customer);
foreach (var e in errors)
    Console.WriteLine($"[{e.Severity}] {e.FieldName}: {e.Message}");

// Find all broken items
var invalid = uow.GetInvalidItems();
Console.WriteLine($"{invalid.Count} items have validation errors");

Undo / Redo

Undo/Redo records every property change, Add, and Remove on the collection. It is off by default; enable it after construction.

// Turn on undo at startup
uow.IsUndoEnabled = true;
uow.MaxUndoDepth  = 50;

// Or via the convenience method
uow.EnableUndo(true, maxDepth: 50);

// Edit + undo
uow.CurrentItem.Name = "Wrong Name";
Console.WriteLine($"CanUndo: {uow.CanUndo}"); // true
uow.Undo();
Console.WriteLine($"Name restored: {uow.CurrentItem.Name}");

// Redo the change
uow.Redo();

// Clear history (e.g. after a commit)
uow.ClearUndoHistory();

Computed Columns

Computed columns are evaluated on-demand per item. They are not persisted. Useful for display-only values derived from other fields.

// Register a computed full-name column
uow.RegisterComputed("FullLabel", c => $"{c.Name} ({c.Email})");

// Evaluate for a specific item
var label = (string)uow.GetComputed(customer, "FullLabel");

// Get all computed values in one call (for grid display)
foreach (var item in uow.Units)
{
    var computed = uow.GetAllComputed(item);
    Console.WriteLine(computed["FullLabel"]);
}

Bookmarks

Bookmarks save a named cursor position in the collection so you can return quickly (similar to classic desktop record navigation).

// Save position before a search
uow.SetBookmark("SearchStart");

// Navigate through results…
uow.GoToBookmark("SearchStart"); // jumps back

// Remove when done
uow.RemoveBookmark("SearchStart");

// Clear all
uow.ClearBookmarks();

Thread Safety, Freeze & Batch Update

// Batch insert 10 000 rows without 10 000 individual UI refreshes
using (uow.BeginBatchUpdate())
{
    foreach (var row in largeDataSet)
        uow.Add(row);
} // CollectionChanged fires once here

// Thread-safe cross-thread scenario
uow.IsThreadSafe = true;
Task.Run(() =>
{
    uow.Add(new Customer { Name = "Background Insert" });
    // Safe — writer lock acquired internally
});

Export / Import

Provided by UnitofWorkExportHelper<T>, exposed as interface methods.

// Export to file
using var stream = File.Create("customers.json");
await uow.ToJsonAsync(stream, cts.Token);

// Export to CSV
using var csvStream = File.Create("customers.csv");
await uow.ToCsvAsync(csvStream, delimiter: ',', ct: cts.Token);

// Export to DataTable (e.g. for a WinForms grid)
DataTable dt = uow.ToDataTable();
dataGridView1.DataSource = dt;

// Import from JSON (clears existing data first)
using var jsonIn = File.OpenRead("new_customers.json");
int loaded = await uow.LoadFromJsonAsync(jsonIn, clearFirst: true);
Console.WriteLine($"Imported {loaded} customers");

// Import from CSV (append to existing)
using var csvIn = File.OpenRead("additional.csv");
int added = await uow.LoadFromCsvAsync(csvIn, delimiter: ',', clearFirst: false, hasHeaderRow: true);
Console.WriteLine($"Appended {added} rows from CSV");

Aggregates

decimal total   = uow.Sum("OrderAmount");
decimal average = uow.Average("OrderAmount");
int     active  = uow.Count(item => ((Order)item).IsActive);

Console.WriteLine($"Total: {total:C}  Average: {average:C}  Active: {active}");

Batch Operations

// Efficient bulk insert
var newOrders = GenerateOrders(5000);
await uow.AddRange(newOrders);

// Batch commit (200 items per transaction)
var batchResult = await uow.CommitBatchAsync(
    batchSize: 200,
    progress: new Progress<CommitBatchProgress>(p =>
        Console.WriteLine($"Batch {p.BatchNumber}: {p.ItemsCommitted}/{p.TotalItems}")),
    ct: cts.Token);

Console.WriteLine($"All succeeded: {batchResult.AllSucceeded}");

// Server refresh — discard local changes, use server data
bool refreshed = await uow.RefreshAsync(
    filters: null,
    conflictMode: ConflictMode.ServerWins,
    ct: cts.Token);

Factory & Wrapper

Use the UnitOfWorkFactory when the entity type is only known at runtime (e.g. plugin-loaded entities or reflection-driven UI). For compile-time known types, use the generic constructors directly.

// Runtime type (e.g. discovered via plugin)
Type entityType = pluginAssembly.GetType("Acme.Products.Order");

if (UnitOfWorkFactory.TryCreateUnitOfWork(
        entityType, dme, "OrdersDB", "Orders",
        out var wrapper, out string error))
{
    wrapper.Get().GetAwaiter().GetResult();
    Console.WriteLine($"Loaded {wrapper.Units.Count} orders");
}
else
{
    Console.WriteLine("Could not create UOW: " + error);
}

UnitOfWorkWrapper

UnitOfWorkWrapper wraps a dynamic UnitofWork instance and provides safe property access with fallback defaults (GetPropertySafely). It implements IUnitOfWorkWrapper which exposes all core operations through a non-generic contract — suitable for framework-level code that must work with heterogeneous entity types.

Advanced Features

DefaultsManager integration

When DefaultsManager is initialised, _defaultsHelper.ApplyInsertDefaults(entity) is called in New() and Add(), and _defaultsHelper.ApplyUpdateDefaults(entity) is called in Update() and inside the Commit insert/update lambdas. This automatically populates audit fields like CreatedDate, CreatedBy, ModifiedDate, etc.

// Configure once at app startup
DefaultsManager.Initialize(dme);
DefaultsManager.SetColumnDefault(dme, "SalesDB", "Customers", "CreatedDate",  "NOW",      isRule: true);
DefaultsManager.SetColumnDefault(dme, "SalesDB", "Customers", "CreatedBy",    "USERNAME", isRule: true);
DefaultsManager.SetColumnDefault(dme, "SalesDB", "Customers", "ModifiedDate", "NOW",      isRule: true);
DefaultsManager.SetColumnDefault(dme, "SalesDB", "Customers", "IsActive",     "true",     isRule: false);

// Now New()/Add()/Update() automatically fill these fields
uow.New();
var c = uow.CurrentItem;
c.Name = "Alice";
// c.CreatedDate → DateTime.UtcNow, c.CreatedBy → Window user, c.IsActive → true

Change summary & query history

// Get a snapshot of all pending changes
ChangeSummary summary = uow.GetChangeSummary();
Console.WriteLine($"Inserts: {summary.InsertedCount}");
Console.WriteLine($"Updates: {summary.UpdatedCount}");
Console.WriteLine($"Deletes: {summary.DeletedCount}");

// Query history (audit trail of all Get() calls)
var history = uow.GetQueryHistory();
foreach (var entry in history)
    Console.WriteLine($"{entry.Timestamp:u} — {entry.RowCount} rows — filters: {entry.FilterSummary}");

// Clear history
uow.ClearQueryHistory();

Clone an item

// Shallow clone
var copy = (Customer)uow.CloneItem(customer, deep: false);
copy.Name = "Copy of " + customer.Name;
uow.Add(copy);

Soft delete workflow

uow.SoftDeleteFieldName = "IsDeleted";  // marks the record instead of removing it
uow.IncludeDeleted      = false;        // hide soft-deleted records in Get()

uow.Delete(customer);      // sets customer.IsDeleted = true, does NOT remove from collection

// To see all records including deleted:
uow.IncludeDeleted = true;
await uow.Get();

Optimistic concurrency

uow.ConcurrencyMode      = ConcurrencyMode.ThrowOnConflict;
uow.ConcurrencyFieldName = "RowVersion";

// If the server row has been modified since the item was loaded,
// Commit() will throw / return Errors.Failed with a concurrency violation message.

try
{
    var result = await uow.Commit();
    if (result.Flag != Errors.Ok)
        Console.WriteLine("Concurrency conflict: " + result.Message);
}
catch (Exception ex)
{
    Console.WriteLine("Concurrency: " + ex.Message);
    await uow.Rollback();
}

Examples

Example 1 — Basic CRUD with events

using var uow = new UnitofWork<Customer>(dme, "SalesDB", "Customers");

// Hook all lifecycle events
uow.PreCreate  += (_, args) => Console.WriteLine("Creating…");
uow.PostCreate += (_, args) => Console.WriteLine($"Created: {((Customer)args.Record).Name}");
uow.PreInsert  += (_, args) => Console.WriteLine("Writing to DB…");
uow.PostInsert += (_, args) => Console.WriteLine($"Inserted. New PK={((Customer)args.Record).ID}");
uow.PreUpdate  += (_, args) => { /* validate */ };
uow.PostUpdate += (_, args) => AuditLog.Record("UPDATE", args.Record);
uow.PreDelete  += (_, args) =>
{
    if (((Customer)args.Record).IsVIP)
    { args.Cancel = true; args.Messege = "VIP customers cannot be deleted."; }
};
uow.PostDelete += (_, args) => Console.WriteLine("Deleted.");
uow.PostEdit   += (_, args) => Console.WriteLine($"Field '{args.PropertyName}' → '{args.PropertyValue}'");
uow.PreCommit  += (_, args) => Console.WriteLine("Beginning transaction…");
uow.PostCommit += (_, args) => Console.WriteLine("All changes saved.");

// Load
await uow.Get();

// Create
uow.New();
uow.CurrentItem.Name  = "Alice";
uow.CurrentItem.Email = "alice@example.com";

// Update first loaded record
if (uow.Units.Count > 1)
{
    uow.Units[1].Name = "Updated Name";
    uow.Update(uow.Units[1]);
}

// Delete
uow.Delete(uow.Units.FirstOrDefault(c => c.Status == "INACTIVE"));

Console.WriteLine($"Pending changes: {uow.IsDirty}");
var result = await uow.Commit();
Console.WriteLine($"Commit: {result.Flag} — {result.Message}");

Example 2 — Cancelling an operation from a Pre-event

using var uow = new UnitofWork<Order>(dme, "OrdersDB", "Orders");

// Block deletes of confirmed orders
uow.PreDelete += (sender, args) =>
{
    var order = (Order)args.Record;
    if (order.Status == "CONFIRMED")
    {
        args.Cancel  = true;
        args.Messege = $"Order #{order.ID} is confirmed and cannot be deleted.";
    }
};

var confirmed = uow.Units.FirstOrDefault(o => o.Status == "CONFIRMED");
var result    = uow.Delete(confirmed);

if (result.Flag != Errors.Ok)
    MessageBox.Show(result.Message); // "Order #42 is confirmed and cannot be deleted."

Example 3 — Undo / Redo in a WinForms form

public class OrderForm : Form
{
    private UnitofWork<Order> _uow;

    public OrderForm(IDMEEditor dme)
    {
        _uow = new UnitofWork<Order>(dme, "OrdersDB", "Orders");
        _uow.IsUndoEnabled = true;
        _uow.MaxUndoDepth  = 30;
        
        _uow.PostEdit += (_, _) => UpdateUndoButtons();
    }

    private void UpdateUndoButtons()
    {
        btnUndo.Enabled = _uow.CanUndo;
        btnRedo.Enabled = _uow.CanRedo;
    }

    private void btnUndo_Click(object sender, EventArgs e)
    {
        if (_uow.Undo()) UpdateUndoButtons();
    }

    private void btnRedo_Click(object sender, EventArgs e)
    {
        if (_uow.Redo()) UpdateUndoButtons();
    }

    private async void btnSave_Click(object sender, EventArgs e)
    {
        var result = await _uow.Commit();
        if (result.Flag == Errors.Ok)
        {
            _uow.ClearUndoHistory();
            UpdateUndoButtons();
        }
    }
}

Example 4 — Export to JSON and reload

using var uow = new UnitofWork<Product>(dme, "CatalogDB", "Products");
await uow.Get();

// Export snapshot
string path = Path.Combine(Path.GetTempPath(), "products_snapshot.json");
await using (var stream = File.Create(path))
    await uow.ToJsonAsync(stream, CancellationToken.None);

Console.WriteLine($"Exported {uow.Units.Count} products to {path}");

// Later — restore from snapshot
await using (var stream = File.OpenRead(path))
{
    int count = await uow.LoadFromJsonAsync(stream, clearFirst: true);
    Console.WriteLine($"Reloaded {count} products");
}

Example 5 — Large batch import with progress

using var uow = new UnitofWork<Transaction>(dme, "LedgerDB", "Transactions");

// Import from CSV
await using var file = File.OpenRead("import_10k.csv");
int loaded = await uow.LoadFromCsvAsync(file, delimiter: ',', clearFirst: true, hasHeaderRow: true);
Console.WriteLine($"Loaded {loaded} rows for import");

// Commit in batches of 500 with progress
var cts = new CancellationTokenSource(TimeSpan.FromMinutes(5));
var progress = new Progress<CommitBatchProgress>(p =>
    Console.WriteLine($"Batch {p.BatchNumber}: {p.ItemsCommitted}/{p.TotalItems} committed"));

var batchResult = await uow.CommitBatchAsync(
    batchSize: 500,
    progress: progress,
    ct: cts.Token);

Console.WriteLine($"Import done. Succeeded: {batchResult.AllSucceeded}, Failed: {batchResult.FailedCount}");

Example 6 — Validation + BlockCommit

using var uow = new UnitofWork<Invoice>(dme, "BillingDB", "Invoices");
uow.IsAutoValidateEnabled      = true;
uow.BlockCommitOnValidationError = true;  // default

await uow.Get();

// Introduce a bad record
uow.New();
uow.CurrentItem.Amount = -500; // violates [Range(0, double.MaxValue)]
uow.CurrentItem.DueDate = DateTime.MinValue;

var allResult = uow.ValidateAll();
if (!allResult.IsValid)
{
    Console.WriteLine("Errors before commit:");
    foreach (var err in allResult.Errors)
        Console.WriteLine($"  {err.FieldName}: {err.Message}");
}

// Commit will skip the invalid record but commit all valid ones
var result = await uow.Commit();
Console.WriteLine(result.Message); // e.g. "Committed 5 of 6 items (1 skipped — validation errors)"

Full API Reference — UnitofWork<T>

Source File Map (20 files)

All 6 Helper Interfaces (from DataManagementModelsStandard)

IUnitofWorkStateHelper<T>

public interface IUnitofWorkStateHelper<T> where T : Entity, new()
{
    EntityState GetEntityState(T entity);
    void SetEntityState(T entity, EntityState state);
    void MarkForDeletion(T entity);
    void MarkAsModified(T entity);
    void MarkAsAdded(T entity);
    void ResetState(T entity);
    void ClearAllStates();
    IEnumerable<int> GetIndicesByState(EntityState state);
    bool HasPendingChanges();
}

IUnitofWorkDataHelper<T>

public interface IUnitofWorkDataHelper<T> where T : Entity, new()
{
    T CloneEntity(T entity);
    T ConvertToEntity(object source);
    Dictionary<string, object> GetEntityValues(T entity);
    void SetEntityValues(T entity, Dictionary<string, object> values);
    Dictionary<string, (object oldValue, object newValue)> CompareEntities(T original, T current);
}

IUnitofWorkCollectionHelper<T>

public interface IUnitofWorkCollectionHelper<T> where T : Entity, new()
{
    void SynchronizeCollections(ObservableBindingList<T> source, ObservableBindingList<T> target);
    ObservableBindingList<T> FilterCollection(ObservableBindingList<T> collection, List<AppFilter> filters);
    ObservableBindingList<T> ApplyPaging(ObservableBindingList<T> collection, int pageIndex, int pageSize);
    ObservableBindingList<T> SortCollection(ObservableBindingList<T> collection, string sortField, bool ascending);
}

IUnitofWorkValidation<T>

public interface IUnitofWorkValidation<T> where T : Entity, new()
{
    IErrorsInfo ValidateEntity(T entity);
    IErrorsInfo ValidateForInsert(T entity);
    IErrorsInfo ValidateForUpdate(T entity);
    IErrorsInfo ValidateForDelete(T entity);
    IErrorsInfo ValidatePrimaryKey(T entity);
    IErrorsInfo ValidateRequiredFields(T entity);
}

IUnitofWorkEventHelper<T>

public interface IUnitofWorkEventHelper<T> where T : Entity, new()
{
    UnitofWorkParams CreateEventParams(T entity, EventAction action);
    UnitofWorkParams CreatePropertyChangeParams(T entity, string propertyName, object newValue);
    void HandlePropertyChanged(T entity, string propertyName, object oldValue, object newValue);
    bool RaiseEntityEvent(T entity, EventAction action, bool isPreEvent);
    bool RaiseEvent(EventHandler<UnitofWorkParams> handler, object sender, T entity, EventAction action);
}

IUnitofWorkDefaults<T>

public interface IUnitofWorkDefaults<T> where T : Entity, new()
{
    void ApplyDefaults(T entity, DefaultValueContext context);
    Task<T> ApplyDefaultsAsync(T entity, DefaultValueContext context);
    bool HasDefaults(string fieldName);
    DefaultValue GetDefaultForField(string fieldName);
    void ApplyInsertDefaults(T entity);
    void ApplyUpdateDefaults(T entity);
    IErrorsInfo ValidateAppliedDefaults(T entity);
}

7 Capability Interfaces (IUnitofWorkCapabilities.cs)

public interface IRevertable
{
    bool RevertItem(object item);
    Task<bool> RevertItemAsync(object item, CancellationToken ct = default);
}

public interface IBatchCommittable
{
    Task<CommitBatchResult> CommitBatchAsync(int batchSize = 200,
        IProgress<CommitBatchProgress> progress = null, CancellationToken ct = default);
}

public interface IExportable
{
    DataTable ToDataTable();
    Task ToJsonAsync(Stream stream, CancellationToken ct = default);
    Task ToCsvAsync(Stream stream, char delimiter = ',', CancellationToken ct = default);
}

public interface IImportable
{
    Task<int> LoadFromJsonAsync(Stream stream, bool clearFirst = true, CancellationToken ct = default);
    Task<int> LoadFromCsvAsync(Stream stream, char delimiter = ',', bool clearFirst = true, bool hasHeaderRow = true, CancellationToken ct = default);
}

public interface IAggregatable
{
    decimal Sum(string numericFieldName);
    decimal Average(string numericFieldName);
    int Count(Func<object, bool> predicate = null);
}

public interface IUndoable
{
    bool CanUndo { get; }
    bool CanRedo { get; }
    bool UndoLastAction();
    bool RedoLastAction();
    void EnableUndo(bool enable, int maxDepth = 50);
}

public interface IMergeable
{
    Task<bool> RefreshAsync(List<AppFilter> filters = null,
        ConflictMode conflictMode = ConflictMode.ServerWins, CancellationToken ct = default);
}

public interface IUnitofWorkHistory
{
    ChangeSummary GetChangeSummary();
    IReadOnlyList<QueryHistoryEntry> GetQueryHistory();
    void ClearQueryHistory();
    object CloneItem(object item, bool deep = false);
}

UnitOfWorkWrapperExtensions — Full API

public static class UnitOfWorkWrapperExtensions
{
    // Iterate all records asynchronously
    public static Task<int> ForEachRecordAsync(this IUnitOfWorkWrapper wrapper,
        Func<dynamic, Task<bool>> processor);

    // Create/Find
    public static dynamic CreateNewRecord(this IUnitOfWorkWrapper wrapper);
    public static bool TryCreateNewRecord(this IUnitOfWorkWrapper wrapper, out dynamic record);
    public static dynamic FindRecord(this IUnitOfWorkWrapper wrapper, Func<dynamic, bool> predicate);
    public static List<dynamic> GetAllRecords(this IUnitOfWorkWrapper wrapper);
    public static bool NavigateToRecord(this IUnitOfWorkWrapper wrapper, string primaryKeyValue);

    // Position info
    public static RecordPositionInfo GetPositionInfo(this IUnitOfWorkWrapper wrapper);

    // Batch insert
    public static Task<BatchOperationResult> BatchInsertAsync(this IUnitOfWorkWrapper wrapper,
        IEnumerable<dynamic> records, IProgress<BatchProgress> progress = null);
    public static Task<BatchOperationResult> BatchInsertAsync(this IUnitOfWorkWrapper wrapper,
        IEnumerable<dynamic> records, IProgress<BatchProgress> progress,
        CancellationToken cancellationToken, bool stopOnFirstFailure = false);

    // State checks
    public static bool HasRecords(this IUnitOfWorkWrapper wrapper);

    // Field value accessors
    public static T GetCurrentFieldValue<T>(this IUnitOfWorkWrapper wrapper,
        string fieldName, T defaultValue = default);
    public static bool SetCurrentFieldValue(this IUnitOfWorkWrapper wrapper,
        string fieldName, object value);
}

// Supporting types
public class RecordPositionInfo
{
    public int CurrentIndex { get; }
    public int TotalCount { get; }
    public bool IsAtFirst { get; }
    public bool IsAtLast { get; }
    public bool HasRecords { get; }
    public dynamic CurrentRecord { get; }
    public string Summary { get; }
}

public class BatchOperationResult
{
    public int TotalRecords { get; }
    public int ProcessedRecords { get; }
    public int SuccessfulRecords { get; }
    public int FailedRecords { get; }
    public List<string> Errors { get; }
    public TimeSpan Duration { get; }
    public bool IsSuccess { get; }
    public double SuccessRate { get; }
}

UnitofWork<T> — Complete Method Index

OBL Integration Features