Como especificar um decimal mínimo, mas não decimal máximo, usando o atributo de anotação de dados do intervalo?

Gostaria de especificar que um campo decimal para um preço deve ser> = 0, mas não quero impor um valor máximo.

Aqui está o que tenho até agora ... Não sei qual é a maneira correta de fazer isso.

[Range(typeof(decimal), "0", "??"] public decimal Price { get; set; }

Que tal algo como isso:

[Range(0.0, Double.MaxValue, ErrorMessage = "The field {0} must be greater than {1}.")]

Isso deve fazer o que você está procurando e pode evitar o uso de strings.

Se você está preocupado com a aparência da string, você pode fazer o seguinte:

    [Range(0, Double.PositiveInfinity)]

Isso terá uma mensagem de erro padrão de:

O campo SuchAndSuch deve estar entre 0 e Infinito.

Parece que não há escolha a não ser colocar o valor máximo manualmente. Eu esperava que houvesse algum tipo de sobrecarga em que você não precisasse especificar um.

[Range(typeof(decimal), "0", "79228162514264337593543950335")]
public decimal Price { get; set; }

Você pode usar:

[Min(0)]

Isso imporá um valor mínimo necessário de 0 (zero) e nenhum valor máximo.

Você precisa DataAnnotationsExtensions para usar isso.

Se você trabalha com preços, tenho certeza de que pode assumir com segurança que nada custará mais de 1 trilhão de dólares.

Eu usaria:

[Range(0.0, 1000000000000)]

Ou, se você realmente precisar, basta colar o valor de Decimal.MaxValue(sem vírgulas):79,228,162,514,264,337,593,543,950,335

Qualquer um deles funcionará bem se você não for do Zimbábue.

Você pode usar a validação personalizada:

    [CustomValidation(typeof(ValidationMethods), "ValidateGreaterOrEqualToZero")]
    public int IntValue { get; set; }

    [CustomValidation(typeof(ValidationMethods), "ValidateGreaterOrEqualToZero")]
    public decimal DecValue { get; set; }

Tipo de métodos de validação:

public class ValidationMethods
{
    public static ValidationResult ValidateGreaterOrEqualToZero(decimal value, ValidationContext context)
    {
        bool isValid = true;

        if (value < decimal.Zero)
        {
            isValid = false;
        }

        if (isValid)
        {
            return ValidationResult.Success;
        }
        else
        {
            return new ValidationResult(
                string.Format("The field {0} must be greater than or equal to 0.", context.MemberName),
                new List<string>() { context.MemberName });
        }
    }
}

Eu tentaria algo assim:

[Range(typeof(decimal), ((double)0).ToString(), ((double)decimal.MaxValue).ToString(), ErrorMessage = "Amount must be greater than or equal to zero.")]

O problema de fazer isso, porém, é que o compilador deseja uma expressão constante, o que não permite ((double)0).ToString(). O compilador irá assumir

[Range(0d, (double)decimal.MaxValue, ErrorMessage = "Amount must be greater than zero.")]

usando Range com

[Range(typeof(Decimal), "0", "9999", ErrorMessage = "{0} must be a decimal/number between {1} and {2}.")]

[Range(typeof(Decimal),"0.0", "1000000000000000000"]

Espero que ajude

[Intervalo (0,01,100000000, ErrorMessage = "O preço deve ser maior que zero!")]

Eu diria que, decimal.MaxValue.ToString()como esse é o teto efetivo para o tipo decmial, é equivalente a não ter um limite superior.