Code Examples

Data Model - EmployeeProps Click to view data model used in all examples
Tag with priority for categorization.
/// <summary>
/// Tag with priority for categorization.
/// </summary>
public class Tag
{
    public string Name { get; set; } = string.Empty;
    public int Priority { get; set; }
    public string? Description { get; set; }
}

/// <summary>
/// Project metrics for analytics.
/// </summary>
[RedbScheme("ProjectMetrics")]
public class ProjectMetricsProps
{
    public long ProjectId { get; set; }
    public long? TasksCompleted { get; set; }
    public long? TasksTotal { get; set; }
    public long? BugsFixed { get; set; }
    public double? Budget { get; set; }
    public long? TeamSize { get; set; }
    public Tag[]? Tags { get; set; }
    public string[]? Technologies { get; set; }
}

/// <summary>
/// Address with city, street and building details.
/// </summary>
public class Address
{
    public string City { get; set; } = string.Empty;
    public string Street { get; set; } = string.Empty;
    public BuildingInfo? Building { get; set; }
}

/// <summary>
/// Building information with floor and amenities.
/// </summary>
public class BuildingInfo
{
    public int Floor { get; set; }
    public string Name { get; set; } = string.Empty;
    public string[]? Amenities { get; set; }
    public int[]? AccessCodes { get; set; }
    public string[]? ParkingSpots { get; set; }
    public int[]? ElevatorFloors { get; set; }
}

/// <summary>
/// Contact detail key-value pair.
/// </summary>
public class ContactDetail
{
    public string Label { get; set; } = string.Empty;
    public string Value { get; set; } = string.Empty;
}

/// <summary>
/// Contact information (email, phone, etc).
/// </summary>
public class Contact
{
    public string Type { get; set; } = string.Empty;
    public string Value { get; set; } = string.Empty;
    public bool IsVerified { get; set; }
    public int[]? NotificationHours { get; set; }
    public ContactDetail[]? Metadata { get; set; }
}

/// <summary>
/// Department info with tags, metrics and nested budget data.
/// </summary>
public class Department
{
    public string Name { get; set; } = string.Empty;
    public int HeadCount { get; set; }
    public string[] Projects { get; set; } = [];
    public Tag[] Leaders { get; set; } = [];
    public Dictionary<string, int>? BudgetByYear { get; set; }
}

/// <summary>
/// Employee props - main model for examples.
/// Demonstrates all supported types:
/// - Simple types (int, string, DateTime, long, decimal)
/// - Arrays (string[], int[])
/// - Business classes (Address with nested BuildingInfo)
/// - Array of business classes (Contact[])
/// - RedbObject references (CurrentProject, PastProjects[])
/// - Dictionary types (various key and value types)
/// </summary>
[RedbScheme("Employee")]
public class EmployeeProps
{
    // Basic info
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;
    public int Age { get; set; }
    public DateTime HireDate { get; set; }
    public string Position { get; set; } = string.Empty;
    public decimal Salary { get; set; }
    public string Department { get; set; } = string.Empty;
    public string? EmployeeCode { get; set; }

    // Skills and certifications (arrays)
    public string[]? Skills { get; set; }
    public int[]? SkillLevels { get; set; }
    public string[]? Certifications { get; set; }
    public int[]? CertificationYears { get; set; }

    // Addresses (business classes)
    public Address? HomeAddress { get; set; }
    public Address? WorkAddress { get; set; }
    public Address? EmergencyAddress { get; set; }

    // Contacts (array of business classes)
    public Contact[]? Contacts { get; set; }

    // Project references (RedbObject)
    public RedbObject<ProjectMetricsProps>? CurrentProject { get; set; }
    public RedbObject<ProjectMetricsProps>[]? PastProjects { get; set; }

    // Phone directory: extension -> phone number
    public Dictionary<string, string>? PhoneDirectory { get; set; }

    // Office locations by city
    public Dictionary<string, Address>? OfficeLocations { get; set; }

    // Bonus history by year
    public Dictionary<int, decimal>? BonusByYear { get; set; }

    // Department details with complex nested data (Pro)
    public Dictionary<string, Department>? DepartmentHistory { get; set; }

    // Composite key: (year, quarter) -> performance score (Pro)
    public Dictionary<(int Year, string Quarter), string>? PerformanceReviews { get; set; }

    // Project metrics by code (Pro)
    public Dictionary<string, RedbObject<ProjectMetricsProps>>? ProjectMetrics { get; set; }
}

/// <summary>
/// Department props for tree examples (corporate hierarchy).
/// Used with TreeRedbObject for organizational structure.
/// Similar to CategoryTestProps in ConsoleTest.
/// </summary>
[RedbScheme("Department")]
public class DepartmentProps
{
    /// <summary>Department name (e.g. "IT Department Moscow").</summary>
    public string Name { get; set; } = string.Empty;

    /// <summary>Description (e.g. "Software development team").</summary>
    public string Description { get; set; } = string.Empty;

    /// <summary>Is department active?</summary>
    public bool IsActive { get; set; } = true;

    /// <summary>Budget in USD.</summary>
    public decimal Budget { get; set; }

    /// <summary>Department code (e.g. "IT-MSK-DEV").</summary>
    public string Code { get; set; } = string.Empty;
}

/// <summary>
/// City props for list examples (linked objects).
/// Used as target object for RedbListItem.Object reference.
/// </summary>
[RedbScheme("City")]
public class CityProps
{
    /// <summary>City name.</summary>
    public string Name { get; set; } = string.Empty;
    
    /// <summary>Population count.</summary>
    public int Population { get; set; }
    
    /// <summary>Region or district.</summary>
    public string Region { get; set; } = string.Empty;
    
    /// <summary>Is capital city?</summary>
    public bool IsCapital { get; set; }
    
    /// <summary>GPS coordinates [lat, lon].</summary>
    public double[] Coordinates { get; set; } = [];
}

/// <summary>
/// Person props demonstrating ListItem fields.
/// Shows single ListItem and List of ListItems usage.
/// </summary>
[RedbScheme("Person")]
public class PersonProps
{
    /// <summary>Person name.</summary>
    public string Name { get; set; } = string.Empty;
    
    /// <summary>Age in years.</summary>
    public int Age { get; set; }
    
    /// <summary>Email address.</summary>
    public string Email { get; set; } = string.Empty;
    
    /// <summary>Single ListItem field (e.g. status from dictionary).</summary>
    public RedbListItem? Status { get; set; }
    
    /// <summary>Array of ListItems (e.g. roles from dictionary).</summary>
    public List<RedbListItem>? Roles { get; set; }
}

/// <summary>
/// Product with a unique business key (V4 [RedbUnique]): the SKU is unique per scheme,
/// enforced by the database over the hash of the canonical value. Used by E003.
/// </summary>
public class ProductProps
{
    /// <summary>Unique business key. NULL never participates in uniqueness.</summary>
    [RedbUnique]
    public string? Sku { get; set; }

    /// <summary>Display name (not unique).</summary>
    public string Title { get; set; } = string.Empty;

    /// <summary>Price in USD.</summary>
    public decimal Price { get; set; }
}

Unique Keys - nested, subtree and element keys, [RedbTags]

Unique keys beyond a root scalar (V4). Props are stored flat, one row per value, and the
storage already maintains a canonical hash for every nested class and collection - so
[RedbUnique] reaches four more shapes with the same database-enforced index:
1. A scalar INSIDE a nested class - a lambda path (d => d.Identity!.Serial) is the key.
2. A whole SUBTREE - the content of a nested class, in canonical form, is the key.
3. A whole COLLECTION - the ordered list is the key; the same numbers in another order differ.
4. ELEMENTS of a collection with a scope: UniqueScope.Collection forbids duplicates
inside one object's collection, UniqueScope.Scheme makes every element value unique
across all objects of the scheme (and probeable by GetByUniqueAsync).
Plus [RedbTags]: a free-form marker written to the scheme and structure metadata for
applications and extensions to read back.
await redb.SyncSchemeAsync<DeviceProps>();

// Unique per run so the example is rerunnable on a shared database.
var run = Guid.NewGuid().ToString("N")[..8];
var sw = Stopwatch.StartNew();

// 1. Key on a scalar inside a nested class: same rules as a root key.
var serial = $"SN-{run}";
var alphaId = await redb.SaveAsync(Device("alpha", d => d.Identity = new DeviceIdentity { Serial = serial, Vendor = "Acme" }));
var nestedDup = await Rejected(() => redb.SaveAsync(Device("alpha-dup", d => d.Identity = new DeviceIdentity { Serial = serial, Vendor = "Other" })));
var bySerial = await redb.GetByUniqueAsync<DeviceProps>(d => d.Identity!.Serial, serial);

// 2. Subtree key: the CONTENT of the nested class is the key. Same content - rejected;
//    one field different - a different key. The lookup canonicalises the probe object
//    the same way the save did.
var region = $"eu-{run}";
var betaId = await redb.SaveAsync(Device("beta", d => d.Config = new DeviceConfig { Region = region, Tier = 2 }));
var subtreeDup = await Rejected(() => redb.SaveAsync(Device("beta-dup", d => d.Config = new DeviceConfig { Region = region, Tier = 2 })));
await redb.SaveAsync(Device("beta-tier3", d => d.Config = new DeviceConfig { Region = region, Tier = 3 }));
var byConfig = await redb.GetByUniqueAsync<DeviceProps>(d => d.Config, new DeviceConfig { Region = region, Tier = 2 });

// 3. Subtree key on a collection: the ordered list is the key.
var basePort = Random.Shared.Next(10_000, 60_000);
List<long> ports = [basePort, basePort + 1, basePort + 2];
await redb.SaveAsync(Device("gamma", d => d.Ports = ports));
var listDup = await Rejected(() => redb.SaveAsync(Device("gamma-dup", d => d.Ports = [.. ports])));
await redb.SaveAsync(Device("gamma-reversed", d => d.Ports = [basePort + 2, basePort + 1, basePort]));

// 4. Element keys, Collection scope: no duplicate label inside ONE device. Another device
//    may carry the same label - the scope is the collection, not the scheme.
await redb.SaveAsync(Device("delta", d => d.Labels = ["rack-1", "spare"]));
await redb.SaveAsync(Device("delta-twin", d => d.Labels = ["rack-1"]));
var elementDup = await Rejected(() => redb.SaveAsync(Device("delta-dup", d => d.Labels = ["rack-1", "rack-1"])));

// 5. Element keys, Scheme scope: a MAC address belongs to one device in the whole scheme,
//    and the holder is found by the element value.
var mac = $"02:{run[..2]}:{run[2..4]}:{run[4..6]}:00:01";
// The second address comes from the same run characters as the first: the key is unique across the
// scheme, and two characters alone (256 values) collide with earlier runs of this example.
var epsilonId = await redb.SaveAsync(Device("epsilon", d => d.MacAddresses = [mac, $"02:{run[..2]}:{run[2..4]}:{run[4..6]}:00:02"]));
var macDup = await Rejected(() => redb.SaveAsync(Device("epsilon-dup", d => d.MacAddresses = [mac])));
var byMac = await redb.GetByUniqueAsync<DeviceProps>(d => d.MacAddresses, mac);

// 6. [RedbTags]: the markers are metadata - read them back from the synced scheme.
var scheme = await redb.GetSchemeByTypeAsync<DeviceProps>();
var schemeTags = scheme?.Tags;
var macTags = scheme?.GetStructureByName(nameof(DeviceProps.MacAddresses))?.Tags;

sw.Stop();

// The example is a contract probe: a duplicate that slipped through, a lookup that missed
// or a tag that did not land is a FAIL, not a line in the report.
var problems = new List<string>();
if (!nestedDup.StartsWith("rejected")) problems.Add("nested key: duplicate was not rejected");
if (bySerial?.Id != alphaId) problems.Add("nested key: lookup by lambda path missed");
if (!subtreeDup.StartsWith("rejected")) problems.Add("subtree key: duplicate content was not rejected");
if (byConfig?.Id != betaId) problems.Add("subtree key: lookup by content missed");
if (!listDup.StartsWith("rejected")) problems.Add("collection key: duplicate list was not rejected");
if (!elementDup.StartsWith("rejected")) problems.Add("element key (Collection): duplicate inside one device was not rejected");
if (!macDup.StartsWith("rejected")) problems.Add("element key (Scheme): duplicate across devices was not rejected");
if (byMac?.Id != epsilonId) problems.Add("element key (Scheme): lookup by element value missed");
if (schemeTags != "examples,e004") problems.Add($"[RedbTags] on the scheme did not land: '{schemeTags}'");
if (macTags != "network") problems.Add($"[RedbTags] on the structure did not land: '{macTags}'");
if (problems.Count > 0)
    return Fail("E004", "Unique Keys - nested, subtree and element keys, [RedbTags]", ExampleTier.Free, sw.ElapsedMilliseconds, string.Join("; ", problems));
Device
private static RedbObject<DeviceProps> Device(string title, Action<DeviceProps> configure)
{
    var props = new DeviceProps { Title = title };
    configure(props);
    return new RedbObject<DeviceProps> { name = $"e004-{title}", Props = props };
}
Rejected
private static async Task<string> Rejected(Func<Task<long>> save)
{
    try
    {
        await save();
        return "NOT rejected - this line must never print";
    }
    catch (RedbUniqueViolationException ex)
    {
        return $"rejected ({ex.Kind}, {ex.PropertyName})";
    }
}
UniqueRedbUniqueUniqueScopeRedbTagsGetByUniqueAsyncIRedbService.GetByUniqueAsyncIRedbService.SaveAsyncIRedbService.GetSchemeByTypeAsync
PG Pro 1354ms(9)
postgres.pro.repeat 1292ms(9)
postgres.pro.cache 1275ms(9)
MS Pro 970ms(9)
mssql.pro.repeat 1258ms(9)
mssql.pro.cache 873ms(9)
sqlite.pro 57ms(9)
sqlite.pro.repeat 74ms(9)
sqlite.pro.cache 36ms(9)