Configuration Reference¶

services.AddDbContext<AppDbContext>(options =>
{
    options.UseSqlServer(connectionString);
    options.UseDtde();  // Default configuration
});

services.AddDbContext<AppDbContext>(options =>
{
    options.UseSqlServer(connectionString);
    options.UseDtde(dtde =>
    {
        // Performance settings
        dtde.SetMaxParallelShards(10);

        // Debugging
        dtde.EnableDiagnostics();

        // Testing
        dtde.EnableTestMode();

        // Default temporal context
        dtde.SetDefaultTemporalContext(() => DateTime.UtcNow);

        // Shard definitions
        dtde.AddShard(s => s.WithId("shard1")...);
        dtde.AddShardsFromConfig("shards.json");
    });
});

public sealed class DtdeOptions
{
    /// <summary>
    /// Gets the list of configured shards.
    /// </summary>
    public IList<IShardMetadata> Shards { get; }

    /// <summary>
    /// Gets or sets the default temporal context provider.
    /// </summary>
    public Func<DateTime>? DefaultTemporalContextProvider { get; set; }

    /// <summary>
    /// Gets or sets the maximum number of shards to query in parallel.
    /// Default: 10
    /// </summary>
    public int MaxParallelShards { get; set; }

    /// <summary>
    /// Gets or sets whether diagnostics are enabled.
    /// Default: false
    /// </summary>
    public bool EnableDiagnostics { get; set; }

    /// <summary>
    /// Gets or sets whether test mode is enabled.
    /// Default: false
    /// </summary>
    public bool EnableTestMode { get; set; }

    /// <summary>
    /// Gets or sets the metadata registry.
    /// </summary>
    public IMetadataRegistry MetadataRegistry { get; set; }

    /// <summary>
    /// Gets or sets the shard registry.
    /// </summary>
    public IShardRegistry ShardRegistry { get; set; }

    /// <summary>
    /// Gets or sets the temporal context.
    /// </summary>
    public ITemporalContext TemporalContext { get; set; }
}

dtde.SetMaxParallelShards(10);

dtde.EnableDiagnostics();

dtde.EnableTestMode();

dtde.AddShard(s => s
    .WithId("shard-eu")
    .WithName("European Data")
    .WithShardKeyValue("EU")
    .WithTable("Customers_EU", "dbo")
    .WithTier(ShardTier.Hot)
    .WithPriority(100));

// Table shard
var tableShard = ShardMetadata.ForTable(
    shardId: "shard-2024",
    tableName: "Orders_2024",
    shardKeyValue: "2024",
    schemaName: "dbo");

// Database shard
var dbShard = ShardMetadata.ForDatabase(
    shardId: "shard-eu",
    name: "EU Database",
    connectionString: "Server=eu.db.com;...",
    shardKeyValue: "EU");

dtde.AddShard(tableShard);
dtde.AddShard(dbShard);

public enum ShardTier
{
    Hot,        // Active data, SSD/fast storage
    Warm,       // Less active, standard storage
    Cold,       // Archived, slow storage
    Archive     // Long-term, cheapest storage
}

modelBuilder.Entity<Customer>(entity =>
{
    entity.ShardBy(c => c.Region)
          .WithStorageMode(ShardStorageMode.Tables);
});

modelBuilder.Entity<Customer>(entity =>
{
    entity.ShardByHash(c => c.Id, shardCount: 8)
          .WithStorageMode(ShardStorageMode.Tables);
});

modelBuilder.Entity<Order>(entity =>
{
    entity.ShardByDate(o => o.CreatedAt, DateShardInterval.Year)
          .WithStorageMode(ShardStorageMode.Tables);
});

entity.HasTemporalValidity(
    validFrom: e => e.EffectiveDate,
    validTo: e => e.ExpirationDate);

entity.HasTemporalValidity(e => e.ValidFrom, e => e.ValidTo)
      .WithVersioningMode(VersioningMode.SoftVersion);

entity.HasTemporalValidity(e => e.ValidFrom, e => e.ValidTo)
      .WithVersioningMode(VersioningMode.AuditTrail)
      .WithHistoryTable("ContractHistory");

entity.HasTemporalValidity(e => e.ValidFrom, e => e.ValidTo)
      .WithOpenEndedValue(DateTime.MaxValue);

options.UseDtde(dtde =>
{
    dtde.AddShardsFromConfig("shards.json");
});

var connectionString = Environment.GetEnvironmentVariable("DTDE_CONNECTION_STRING")
    ?? configuration.GetConnectionString("Default");

var shardConfigPath = Environment.GetEnvironmentVariable("DTDE_SHARD_CONFIG")
    ?? "shards.json";

dtde.AddShardsFromConfig(shardConfigPath);

// appsettings.Development.json
{
  "Dtde": {
    "MaxParallelShards": 4,
    "EnableDiagnostics": true
  }
}

// appsettings.Production.json
{
  "Dtde": {
    "MaxParallelShards": 20,
    "EnableDiagnostics": false
  }
}

var dtdeConfig = configuration.GetSection("Dtde");

options.UseDtde(dtde =>
{
    dtde.SetMaxParallelShards(dtdeConfig.GetValue<int>("MaxParallelShards", 10));

    if (dtdeConfig.GetValue<bool>("EnableDiagnostics"))
    {
        dtde.EnableDiagnostics();
    }
});

// Throws if shard IDs are duplicated
dtde.AddShard(s => s.WithId("shard1")...);
dtde.AddShard(s => s.WithId("shard1")...); // Error!

// Throws if required properties missing
dtde.AddShard(s => s.WithTable("MyTable")); // Error: No ID

// Check shard exists before query
var shardExists = context.ShardRegistry.GetShard("my-shard") != null;

// Validate entity has sharding configured
var hasSharding = context.MetadataRegistry.GetEntityMetadata<Customer>()
    ?.ShardingConfiguration != null;

// Program.cs
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<AppDbContext>(options =>
{
    options.UseSqlServer(builder.Configuration.GetConnectionString("Default"));
    options.UseDtde(dtde =>
    {
        // Performance
        dtde.SetMaxParallelShards(
            builder.Configuration.GetValue<int>("Dtde:MaxParallelShards", 10));

        // Diagnostics (development only)
        if (builder.Environment.IsDevelopment())
        {
            dtde.EnableDiagnostics();
        }

        // Load shards from config
        var shardConfig = builder.Configuration.GetValue<string>("Dtde:ShardConfigPath");
        if (!string.IsNullOrEmpty(shardConfig))
        {
            dtde.AddShardsFromConfig(shardConfig);
        }

        // Programmatic shards
        dtde.AddShard(s => s
            .WithId("default")
            .WithTable("Entities", "dbo")
            .WithTier(ShardTier.Hot)
            .WithPriority(0));
    });
});