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.
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;
}
}