Início / coding / Perguntas / 76919610
Accepted
astralwaters
Asked: 2023-08-17 16:14:42 +0800 CST

Como posso melhorar essa interface de validação no .NET?

  • 772

Eu queria saber se existe alguma maneira de melhorar essa validação de interface, antes de começarmos a implementá-la. Em resumo, este código define uma interface e métodos relacionados para validar conexões, focando especificamente na validação de parâmetros e validação específica de conexão.

public interface IConnValidation
{
    Task<ResultTuple> Validate(ConnectionSide side)
    {
        ResultTuple result = ValidateParameters(side);

        return result.Ok
                    ? ValidateConnection(side)
                    : result.ToTask();
    }

    ResultTuple ValidateParameters(ConnectionSide side)
    {
        try
        {
            return ValidateParametersInternal(side);
        }
        catch (Exception ex)
        {
            string message = $"{INTERNAL_ERROR} {ex.ToReport(false)}";
            return ResultTuple.Failure(message);
        }
    }

    async Task<ResultTuple> ValidateConnection(ConnectionSide side)
    {
        try
        {
            //DO NOT return the internal task as we need to handle the failure in this method
            ResultTuple result = await ValidateConnectionInternal(side);
            return result;
        }
        catch (Exception ex)
        {
            string message = $"{INTERNAL_ERROR} {ex.ToReport(false)}";
            return ResultTuple.Failure(message);
        }
    }

    protected ResultTuple ValidateParametersInternal(ConnectionSide side);

    protected Task<ResultTuple> ValidateConnectionInternal(ConnectionSide side);
}

Eu tentei algo assim:

public interface IConnValidation
{
    Task<ResultTuple> Validate(ConnectionSide side);
}

public class ConcreteConnValidation : IConnValidation
{
    public async Task<ResultTuple> Validate(ConnectionSide side)
    {
        try
        {
            ResultTuple parameterValidationResult = await ValidateParameters(side);

            if (!parameterValidationResult.Ok)
            {
                return parameterValidationResult;
            }

            return await ValidateConnection(side);
        }
        catch (Exception ex)
        {
            string message = $"{INTERNAL_ERROR} {ex.ToReport(false)}";
            return ResultTuple.Failure(message);
        }
    }

    protected virtual Task<ResultTuple> ValidateParameters(ConnectionSide side)
    {
        try
        {
            // Validate parameters asynchronously and return ResultTuple
        }
        catch (Exception ex)
        {
            string message = $"{INTERNAL_ERROR} {ex.ToReport(false)}";
            return Task.FromResult(ResultTuple.Failure(message));
        }
    }

    protected virtual async Task<ResultTuple> ValidateConnection(ConnectionSide side)
    {
        try
        {
            // Validate connection asynchronously and return ResultTuple
        }
        catch (Exception ex)
        {
            string message = $"{INTERNAL_ERROR} {ex.ToReport(false)}";
            return ResultTuple.Failure(message);
        }
    }
}

Mas eu queria saber se existe alguma abordagem melhor?

c#

1 respostas

  1. Best Answer

    Você pode estar melhor com uma classe base abstrata em vez de uma interface. As classes de validação concretas herdariam a classe base, substituindo os métodos de validação internos. A classe base ficaria mais ou menos assim:

    public abstract class ConnValidationBase
{
    public async Task<ResultTuple> Validate(ConnectionSide side)
    {
        var result = ValidateParameters(side);

        return result.Ok
            ? await ValidateConnection(side)
            : await result.ToTask();
    }

    private ResultTuple ValidateParameters(ConnectionSide side)
    {
        try
        {
            return ValidateParametersInternal(side);
        }
        catch (Exception ex)
        {
            var message = $"{INTERNAL_ERROR} {ex.ToReport(false)}";
            return ResultTuple.Failure(message);
        }
    }

    private async Task<ResultTuple> ValidateConnection(ConnectionSide side)
    {
        try
        {
            //DO NOT return the internal task as we need to handle the failure in this method
            var result = await ValidateConnectionInternal(side);
            return result;
        }
        catch (Exception ex)
        {
            var message = $"{INTERNAL_ERROR} {ex.ToReport(false)}";
            return ResultTuple.Failure(message);
        }
    }

    protected abstract ResultTuple ValidateParametersInternal(ConnectionSide side);

    protected abstract Task<ResultTuple> ValidateConnectionInternal(ConnectionSide side);
}

    A implementação concreta poderia ser assim:

    public sealed class ConcreteConnValidation : ConnValidationBase
{
    protected override ResultTuple ValidateParametersInternal(ConnectionSide side)
    {
        // Validate parameters asynchronously and return ResultTuple
    }

    protected override Task<ResultTuple> ValidateConnectionInternal(ConnectionSide side)
    {
        // Validate connection asynchronously and return ResultTuple
    }
}

    E a validação concreta seria chamada assim (ou similar):

    var validator = new ConcreteConnValidation();
var connection = new ConnectionSide();
var result = await validator.Validate(connection);
    • 0

relate perguntas