Código

Basado en el Reloj de Cobranza que diseñé en Totalplay

Motor de enrutamiento de cobranza

Un millón de cuentas por ciclo, en paralelo y escalado horizontalmente.

C# 96%MSBuild 4%14 archivos710 líneas de código 12/12 pruebas
using System.Collections.Concurrent;
using System.Runtime.CompilerServices;
using CollectionRouter.Domain;

namespace CollectionRouter.Infrastructure;

/// <summary>Genera cuentas sintéticas reproducibles (misma semilla = mismas cuentas).</summary>
public sealed class SyntheticAccountSource : IAccountSource
{
    private readonly int _count;
    private readonly int _seed;

    public SyntheticAccountSource(int count, int seed = 2016)
    {
        _count = count;
        _seed = seed;
    }

    public async IAsyncEnumerable<Account> ReadAsync([EnumeratorCancellation] CancellationToken cancellationToken)
    {
        var random = new Random(_seed);
        for (var i = 1; i <= _count; i++)
        {
            cancellationToken.ThrowIfCancellationRequested();
            var segmentRoll = random.Next(100);
            yield return new Account(
                Id: 10_000_000 + i,
                Segment: segmentRoll < 85 ? Segment.Residential : segmentRoll < 97 ? Segment.SmallBusiness : Segment.Enterprise,
                PastDueAmount: Math.Round((decimal)(random.NextDouble() * 12_000), 2),
                DaysPastDue: random.Next(-5, 180),
                FailedContactsThisCycle: random.Next(0, 6),
                HasActivePaymentPromise: random.Next(100) < 8,
                IsDisputed: random.Next(1000) < 5);

            if (i % 10_000 == 0) await Task.Yield();
        }
    }
}

/// <summary>Simula la latencia de una consulta remota por cuenta (historial de contactos, etc.).</summary>
public sealed class SimulatedLatencyEnricher : IAccountEnricher
{
    private readonly TimeSpan _latency;

    public SimulatedLatencyEnricher(TimeSpan latency) => _latency = latency;

    public async ValueTask<Account> EnrichAsync(Account account, CancellationToken cancellationToken)
    {
        if (_latency > TimeSpan.Zero) await Task.Delay(_latency, cancellationToken);
        return account;
    }
}

/// <summary>Destino en memoria, idempotente: una clave repetida no genera una segunda gestión.</summary>
public sealed class InMemoryDecisionSink : IDecisionSink
{
    private readonly ConcurrentDictionary<string, RoutingDecision> _decisions = new();
    private int _duplicates;

    public int Count => _decisions.Count;
    public int Duplicates => _duplicates;
    public IReadOnlyCollection<RoutingDecision> Decisions => _decisions.Values.ToArray();

    public Task WriteBatchAsync(IReadOnlyList<RoutingDecision> batch, CancellationToken cancellationToken)
    {
        foreach (var decision in batch)
        {
            if (!_decisions.TryAdd(decision.IdempotencyKey, decision))
                Interlocked.Increment(ref _duplicates);
        }
        return Task.CompletedTask;
    }
}