UnitOfWork<T>

Signature-Verified Snapshot

public partial class UnitofWork<T>
    : IUnitofWork<T>, INotifyPropertyChanged,
      IRevertable, IBatchCommittable, IExportable, IImportable,
      IAggregatable, IUndoable, IMergeable, IUnitofWorkHistory
    where T : Entity, new()
{
    public UnitofWork();
    public UnitofWork(IDMEEditor dMEEditor, string datasourceName, string entityName);
    public UnitofWork(IDMEEditor dMEEditor, string datasourceName, string entityName, EntityStructure entityStructure);
    public UnitofWork(IDMEEditor dMEEditor, string datasourceName, string entityName, string primarykey);
    public UnitofWork(IDMEEditor dMEEditor, string datasourceName, string entityName, EntityStructure entityStructure, string primarykey);
    public UnitofWork(IDMEEditor dMEEditor, bool isInListMode, ObservableBindingList<T> ts);
    public UnitofWork(IDMEEditor dMEEditor, bool isInListMode, ObservableBindingList<T> ts, string primarykey);

    public bool IsDirty { get; }
    public bool IsLogging { get; set; }
    public string SoftDeleteFieldName { get; set; }
    public bool IncludeDeleted { get; set; }
    public ConcurrencyMode ConcurrencyMode { get; set; }
    public CommitOrder CommitOrder { get; set; }
}

Basic Constructor

public UnitofWork(IDMEEditor dMEEditor, string datasourceName, string entityName, string primarykey)

With Entity Structure

public UnitofWork(IDMEEditor dMEEditor, string datasourceName, string entityName, EntityStructure entityStructure, string primarykey)

List Mode Constructor

public UnitofWork(IDMEEditor dMEEditor, bool isInListMode, ObservableBindingList<T> ts, string primarykey)

Usage Examples

// Create UnitOfWork for Customer entities
var customerUoW = new UnitofWork<Customer>(dmeEditor, "SqlServer", "Customers", "CustomerID");

// Create UnitOfWork with entity structure
var orderUoW = new UnitofWork<Order>(dmeEditor, "MongoDB", "Orders", orderStructure, "OrderID");

// Create UnitOfWork in list mode (in-memory)
var tempCustomers = new ObservableBindingList<Customer>();
var listUoW = new UnitofWork<Customer>(dmeEditor, true, tempCustomers, "CustomerID");

Get All Entities

public virtual async Task<ObservableBindingList<T>> Get()

Retrieves all entities from the data source.

Get with Filters

public virtual async Task<ObservableBindingList<T>> Get(List<AppFilter> filters)

Retrieves entities with applied filters.

Custom Query

public virtual async Task<ObservableBindingList<T>> GetQuery(string query)

Executes a custom query and returns results.

Get by Primary Key

public virtual T Get(string primaryKeyId)

Gets a single entity by its primary key value.

Usage Examples

// Get all customers
var allCustomers = await customerUoW.Get();

// Get customers with filters
var filters = new List<AppFilter> 
{
    new AppFilter {FieldName = "Country", Operator = "=", FilterValue = "USA" },
    new AppFilter {FieldName = "Status", Operator = "=", FilterValue = "Active" }
};
var filteredCustomers = await customerUoW.Get(filters);

// Get customer by ID
var customer = customerUoW.Get("CUST001");

// Custom query
var queryResult = await customerUoW.GetQuery("SELECT * FROM Customers WHERE CreateDate > '2023-01-01'");

public void New()        // Creates a new entity and adds it to the collection
public void Add(T entity) // Adds an existing entity to the collection

public async Task<IErrorsInfo> InsertAsync(T doc)  // Async insert to data source
public IErrorsInfo InsertDoc(T doc)               // Sync insert to data source

public async Task<IErrorsInfo> UpdateAsync(T doc)  // Async update in data source
public IErrorsInfo Update(T entity)               // Update entity in collection

public async Task<IErrorsInfo> DeleteAsync(T doc)  // Async delete from data source
public IErrorsInfo Delete(T entity)               // Delete entity from collection
public IErrorsInfo Delete(string id)              // Delete entity by primary key

Complete CRUD Example

using (var customerUoW = new UnitofWork<Customer>(dmeEditor, "SqlServer", "Customers", "CustomerID"))
{
    // Create new customer
    customerUoW.New();
    var newCustomer = customerUoW.CurrentItem;
    newCustomer.Name = "John Doe";
    newCustomer.Email = "john@example.com";

    // Add existing customer
    var existingCustomer = new Customer { Name = "Jane Smith" };
    customerUoW.Add(existingCustomer);

    // Insert to database
    var insertResult = await customerUoW.InsertAsync(newCustomer);
    if (insertResult.Flag == Errors.Ok)
    {
        Console.WriteLine("Customer inserted successfully");
    }

    // Update customer
    newCustomer.Email = "newemail@example.com";
    var updateResult = await customerUoW.UpdateAsync(newCustomer);

    // Delete customer
    var deleteResult = await customerUoW.DeleteAsync(newCustomer);

    // Delete by ID
    customerUoW.Delete("CUST001");
}

Commit Operations

public virtual async Task<IErrorsInfo> Commit()
public virtual async Task<IErrorsInfo> Commit(IProgress<PassedArgs> progress, CancellationToken token)

Commits all pending changes to the data source with optional progress reporting and cancellation support.

Rollback Operations

public Task<IErrorsInfo> Rollback()

Rolls back all uncommitted changes.

Transaction Example

try
{
    // Make multiple changes
    customerUoW.New();
    var customer1 = customerUoW.CurrentItem;
    customer1.Name = "Customer 1";
    
    customerUoW.New();
    var customer2 = customerUoW.CurrentItem;
    customer2.Name = "Customer 2";
    
    // Commit all changes
    var result = await customerUoW.Commit();
    
    if (result.Flag == Errors.Ok)
    {
        Console.WriteLine("All changes committed");
    }
    else
    {
        Console.WriteLine($"Commit failed: {result.Message}");
        await customerUoW.Rollback();
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
    await customerUoW.Rollback();
}

Change Tracking Methods

public IEnumerable<int> GetAddedEntities()      // Get indexes of added entities
public IEnumerable<int> GetModifiedEntities()   // Get indexes of modified entities
public IEnumerable<T> GetDeletedEntities()      // Get deleted entities
public bool GetIsDirty()                        // Check if there are uncommitted changes

Change Tracking Example

// Check for changes
if (customerUoW.IsDirty)
{
    var added = customerUoW.GetAddedEntities();
    var modified = customerUoW.GetModifiedEntities();
    var deleted = customerUoW.GetDeletedEntities();
    
    Console.WriteLine($"Changes: Added={added.Count()}, Modified={modified.Count()}, Deleted={deleted.Count()}");
    
    // Detailed tracking
    foreach (var addedIndex in added)
    {
        var entity = customerUoW.Units[addedIndex];
        Console.WriteLine($"Added: {entity.Name}");
    }
}

Navigation API

public void MoveFirst()           // Move to first entity
public void MoveNext()            // Move to next entity
public void MovePrevious()        // Move to previous entity
public void MoveLast()            // Move to last entity
public void MoveTo(int index)     // Move to specific position

Navigation Example

// Navigate through records
customerUoW.MoveFirst();
Console.WriteLine($"First customer: {customerUoW.CurrentItem.Name}");

customerUoW.MoveNext();
Console.WriteLine($"Next customer: {customerUoW.CurrentItem.Name}");

// Move to specific position
customerUoW.MoveTo(5);
Console.WriteLine($"Customer at position 5: {customerUoW.CurrentItem.Name}");

// Check current position
Console.WriteLine($"Current position: {customerUoW.Units.IndexOf(customerUoW.CurrentItem)}");
Console.WriteLine($"Total records: {customerUoW.Units.Count}");

Event Handling Example

// Subscribe to validation events
customerUoW.PreInsert += (sender, args) => 
{
    var customer = (Customer)sender;
    if (string.IsNullOrEmpty(customer.Name))
    {
        args.Cancel = true;
        args.ErrorMessage = "Customer name is required";
    }
};

// Track property changes
customerUoW.PostEdit += (sender, args) => 
{
    Console.WriteLine($"Property {args.PropertyName} changed to {args.PropertyValue}");
    
    // Log to audit trail
    auditService.LogChange(customerUoW.CurrentItem.CustomerID, args.PropertyName, args.PropertyValue);
};

// Final validation before commit
customerUoW.PreCommit += (sender, args) => 
{
    if (!ValidateAllCustomers())
    {
        args.Cancel = true;
        args.ErrorMessage = "Validation failed - please fix errors before saving";
    }
};

// Success notification
customerUoW.PostCommit += (sender, args) => 
{
    MessageBox.Show("Changes saved successfully!");
    RefreshUI();
};

Undo Methods

public void UndoLastChange()    // Undoes the last change made to the collection
public void UndoDelete()         // Undoes the most recent delete operation

Undo Example

// Make a change
var customer = customerUoW.CurrentItem;
var originalName = customer.Name;
customer.Name = "New Name";

Console.WriteLine($"Changed name from '{originalName}' to '{customer.Name}'");

// Undo the change
customerUoW.UndoLastChange();
Console.WriteLine($"Name restored to: '{customer.Name}'");

// Delete and undo example
var customerToDelete = customerUoW.CurrentItem;
customerUoW.Delete(customerToDelete);
Console.WriteLine($"Customer {customerToDelete.Name} deleted");

// Restore deleted customer
customerUoW.UndoDelete();
Console.WriteLine($"Customer {customerToDelete.Name} restored");

Logging Properties & Methods

public bool IsLogging { get; set; }           // Enable/disable change logging
public bool SaveLog(string pathandname)       // Save change log to JSON file

Logging Example

// Enable logging
customerUoW.IsLogging = true;

// Make changes
customerUoW.New();
var customer = customerUoW.CurrentItem;
customer.Name = "John Doe";
customer.Email = "john@example.com";

customerUoW.CurrentItem.Name = "John Smith"; // This change will be logged

// Save log to file
var logPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), 
                          "MyApp", "Logs", $"customer_changes_{DateTime.Now:yyyyMMdd}.json");

Directory.CreateDirectory(Path.GetDirectoryName(logPath));

var success = customerUoW.SaveLog(logPath);
if (success)
{
    Console.WriteLine($"Change log saved to: {logPath}");
}

Runtime Capability Detection

IUnitofWork uow = GetUnitOfWork(blockName); // returns non-generic IUnitofWork

// Detect and use capabilities safely
if (uow is IBatchCommittable batchable)
{
    var result = await batchable.CommitBatchAsync(batchSize: 50);
    Console.WriteLine($"Committed {result.TotalCommitted} records.");
}

if (uow is IExportable exportable)
{
    using var stream = File.Create("export.json");
    await exportable.ToJsonAsync(stream);
}

if (uow is IUnitofWorkHistory hist)
{
    var summary = hist.GetChangeSummary();
    Console.WriteLine($"Inserted: {summary.InsertedCount}, Updated: {summary.UpdatedCount}, Deleted: {summary.DeletedCount}");
}

Signature

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

CommitBatchResult Properties

public class CommitBatchResult
{
    public bool Success { get; set; }         // Overall success flag
    public int TotalCommitted { get; set; }   // Records persisted
    public List<string> Errors { get; set; } // Per-batch error messages
}

Example — Import 10,000 Records in Batches of 200

// Add a large number of entities
for (int i = 0; i < 10_000; i++)
    uow.Add(new Product { Name = $"Product {i}", Price = i * 1.5m });

var progress = new Progress<CommitBatchProgress>(p =>
    Console.WriteLine($"Batch {p.BatchNumber}/{p.TotalBatches} — {p.Committed} committed"));

var result = await uow.CommitBatchAsync(batchSize: 200, progress, CancellationToken.None);

if (result.Success)
    Console.WriteLine($"Done — {result.TotalCommitted} records saved.");
else
    foreach (var err in result.Errors)
        Console.Error.WriteLine(err);

Example — Per-Item Delta Report

await customerUoW.Get();

var customer = customerUoW.Units.First();
customer.Name   = "Updated Name";
customer.Status = "Premium";

// Field-level inspection
var changedFields = customerUoW.Units.GetChangedFields(customer);
foreach (var field in changedFields)
{
    var delta = customerUoW.Units.GetFieldDelta(customer, field);
    Console.WriteLine($"{field}: '{delta.OriginalValue}' → '{delta.CurrentValue}'");
}

// Summary
var summary = customerUoW.Units.GetChangeSetSummary();
Console.WriteLine($"Inserted={summary.InsertedCount}, Updated={summary.UpdatedCount}, Deleted={summary.DeletedCount}");

// Strongly typed (compile-time)
bool ok = customerUoW.RevertItem(customer);
await customerUoW.RevertItemAsync(customer);

// Via non-generic IUnitofWork (runtime cast)
if (uow is IRevertable r)
    r.RevertItem(customer); // object overload

// Re-fetch and merge with conflict resolution
var result = await customerUoW.RefreshAsync(
    filters: null,
    conflictMode: ConflictMode.ServerWins,  // or ClientWins / KeepBoth / ThrowOnConflict
    ct: CancellationToken.None);

if (result.Flag == Errors.Ok)
    Console.WriteLine("Data refreshed — server values applied to conflicting records.");

Example — Audit Dashboard

// Summary stats
var summary = customerUoW.GetChangeSummary();
Console.WriteLine($"Session changes: +{summary.InsertedCount} / ~{summary.UpdatedCount} / -{summary.DeletedCount}");

// Query history
foreach (var entry in customerUoW.GetQueryHistory())
    Console.WriteLine($"[{entry.ExecutedAt:HH:mm:ss}] {entry.QueryText}");

// Clone before editing (non-destructive preview)
var original = customerUoW.CloneItem(customerUoW.CurrentItem, deep: true);
customerUoW.CurrentItem.Status = "Suspended";
// cancel? restore original
// customerUoW.Units[idx] = original;

Export API

DataTable dt  = customerUoW.ToDataTable();

using var js  = File.Create("customers.json");
await customerUoW.ToJsonAsync(js);

using var csv = File.Create("customers.csv");
await customerUoW.ToCsvAsync(csv, delimiter: ',');

Import API

// Import from JSON
using var js = File.OpenRead("customers.json");
int imported = await customerUoW.LoadFromJsonAsync(js, clearFirst: true);
Console.WriteLine($"{imported} records imported from JSON");

// Import from CSV
using var csv = File.OpenRead("customers.csv");
imported = await customerUoW.LoadFromCsvAsync(
    csv, delimiter: ',', clearFirst: false, hasHeaderRow: true);
Console.WriteLine($"{imported} records appended from CSV");

Example — Order Summary Statistics

await orderUoW.Get();

decimal totalRevenue    = orderUoW.Sum("Total");
decimal avgOrder        = orderUoW.Average("Total");
decimal bigOrderRevenue = orderUoW.SumWhere("Total", o => o.Total > 500m);
int     bigOrderCount   = orderUoW.CountWhere(o => o.Total > 500m);
var     byCountry       = orderUoW.GroupBy("ShipCountry");

Console.WriteLine($"Revenue: {totalRevenue:C}  Avg: {avgOrder:C}  Big orders: {bigOrderCount}");
foreach (var (country, orders) in byCountry)
    Console.WriteLine($"  {country}: {orders.Count} orders");