API de Skills — Patrones Backend C# Producción

public async Task<Result<Skill>> CreateAsync(
    CreateSkillRequest request,
    CancellationToken ct = default)
{
    // 1. Validar entrada con FluentValidation
    var validation = await _validator.ValidateAsync(request, ct);
    if (!validation.IsValid)
        return Result<Skill>.Failure(
            validation.Errors[0].ErrorMessage,
            "VALIDATION_ERROR");

    // 2. Regla de negocio: slug único
    var existing = await _repo.GetBySlugAsync(request.Slug, ct);
    if (existing != null)
        return Result<Skill>.Failure(
            $"Slug '{request.Slug}' ya existe",
            "DUPLICATE_SLUG");

    // 3. Crear entidad
    var skill = new Skill {
        Id   = Guid.NewGuid().ToString("N"),
        Slug = request.Slug,
        Name = request.Name,
        // ...
    };

    var created = await _repo.CreateAsync(skill, ct);
    return Result<Skill>.Success(created);
}

public static IServiceCollection AddCultivaServices(
    this IServiceCollection services,
    IConfiguration config)
{
    // Scoped: por request
    services.AddScoped<ISkillService, SkillService>();
    services.AddScoped<ISolicitudService, SolicitudService>();

    // Singleton: Redis connection
    services.AddSingleton<IConnectionMultiplexer>(_ =>
        ConnectionMultiplexer.Connect(
            config["Redis:Connection"]!));

    // Keyed DI .NET 8: repositorio dual
    services.AddKeyedScoped<ISkillRepository,
        DapperSkillRepository>("read");
    services.AddKeyedScoped<ISkillRepository,
        EfCoreSkillRepository>("write");

    // Options
    services.Configure<SkillCatalogOptions>(
        config.GetSection(SkillCatalogOptions.Section));

    services.AddMemoryCache();
    services.AddStackExchangeRedisCache(o =>
        o.Configuration = config["Redis:Connection"]);

    return services;
}

// Lectura: Dapper — máxima performance
public async Task<IReadOnlyList<Skill>> SearchAsync(
    SkillSearchRequest req, CancellationToken ct)
{
    var where = new List<string> { "Activo = 1" };
    var p = new DynamicParameters();

    if (req.Servicio is { }) {
        where.Add("Servicio = @Servicio");
        p.Add("Servicio", req.Servicio);
    }
    if (req.PrecioMax is { }) {
        where.Add("Precio <= @PrecioMax");
        p.Add("PrecioMax", req.PrecioMax);
    }
    if (req.Acceso is { }) {
        where.Add("Acceso = @Acceso");
        p.Add("Acceso", req.Acceso);
    }

    // Paginación en una sola consulta
    var sql = $"""
        SELECT COUNT(*) FROM Skills WHERE {where.Join(" AND ")};
        SELECT Id, Nombre, Slug, Servicio, Precio, Nivel, Acceso
        FROM Skills WHERE {where.Join(" AND ")}
        ORDER BY Nombre
        OFFSET @Skip ROWS FETCH NEXT @Take ROWS ONLY;
        """;

    p.Add("Skip", (req.Page - 1) * req.PageSize);
    p.Add("Take", req.PageSize);

    using var multi = await _conn.QueryMultipleAsync(
        new CommandDefinition(sql, p, cancellationToken: ct));

    _ = await multi.ReadSingleAsync<int>();
    return (await multi.ReadAsync<Skill>()).ToList();
}

// Escritura: EF Core — change tracking + validaciones
public async Task<Skill> CreateAsync(
    Skill skill, CancellationToken ct)
{
    _context.Skills.Add(skill);
    await _context.SaveChangesAsync(ct);
    return skill;
}

// Configuración de entidad
public class SkillConfiguration
    : IEntityTypeConfiguration<Skill>
{
    public void Configure(EntityTypeBuilder<Skill> b)
    {
        b.ToTable("Skills");
        b.HasKey(s => s.Id);
        b.Property(s => s.Nombre)
            .HasMaxLength(200).IsRequired();
        b.Property(s => s.Precio)
            .HasPrecision(10, 2);
        // Índice único en slug
        b.HasIndex(s => s.Slug).IsUnique();
        // Índice compuesto búsqueda
        b.HasIndex(s => new {s.Servicio, s.Nivel});
        // Soft delete global filter
        b.HasQueryFilter(s => s.Activo);
    }
}

public class SkillServiceTests
{
    private readonly Mock<ISkillRepository> _repo;
    private readonly Mock<ICacheService>       _cache;
    private readonly SkillService                   _sut;

    public SkillServiceTests()
    {
        _repo  = new Mock<ISkillRepository>();
        _cache = new Mock<ICacheService>();
        _sut   = new SkillService(_repo.Object, _cache.Object);
    }

    [Fact]
    public async Task CreateAsync_SlugDuplicado_RetornaFailure()
    {
        // Arrange
        _repo.Setup(r => r.GetBySlugAsync(
                "cold-email", It.IsAny<CancellationToken>()))
            .ReturnsAsync(new Skill { Slug = "cold-email" });

        var req = new CreateSkillRequest(
            Nombre: "Cold Email", Slug: "cold-email",
            Precio: 0m, Servicio: "Marketing", Nivel: "basico");

        // Act
        var result = await _sut.CreateAsync(req);

        // Assert
        Assert.False(result.IsSuccess);
        Assert.Equal("DUPLICATE_SLUG", result.ErrorCode);
        _repo.Verify(
            r => r.CreateAsync(
                It.IsAny<Skill>(),
                It.IsAny<CancellationToken>()),
            Times.Never);
    }

    [Theory]
    [InlineData("")]
    [InlineData(null)]
    [InlineData("  ")]
    public async Task CreateAsync_SlugInvalido_RetornaValidationError(
        string? slug)
    {
        var req = new CreateSkillRequest(
            Nombre: "Test", Slug: slug!,
            Precio: 5m, Servicio: "Web", Nivel: "avanzado");

        var result = await _sut.CreateAsync(req);

        Assert.False(result.IsSuccess);
        Assert.Equal("VALIDATION_ERROR", result.ErrorCode);
    }
}

// Test de integración con WebApplicationFactory
[Fact]
public async Task GET_Skills_ConFiltroServicio_Retorna200()
{
    // Act
    var resp = await _client.GetAsync(
        "/api/skills?servicio=Marketing");

    // Assert
    resp.EnsureSuccessStatusCode();
    var body = await resp.Content
        .ReadFromJsonAsync<PagedResult<Skill>>();
    Assert.NotEmpty(body!.Items);
    Assert.All(body.Items,
        s => Assert.Equal("Marketing", s.Servicio));
}