Best Data annotation for a Decimal(18,2)

Question

I have a column inside my sql server 2008 wih type of Decimal(18,2). But on entity framework what is the best data annotation validation I can apply to this property, inside my asp.net MVC web application ?

Answer 1

There is no explicit data annotation for a decimal so you need to use two separate ones to add constraints.

Two Decimal Points

[RegularExpression(@"^\d+(\.\d{1,2})?$")]

This regular expression will make sure that the property has at most two decimal places.

Max 18 digits

[Range(0, 9999999999999999.99)]

Assuming you aren't accepting any negative numbers. Otherwise, replace 0 with -9999999999999999.99.

Result

[RegularExpression(@"^\d+(\.\d{1,2})?$")]
[Range(0, 9999999999999999.99)]
public decimal Property { get; set; }

Answer 2

I think @jumpingcode's answer can be combined into one RegularExpressionAttribute.

[RegularExpression(@"^(0|-?\d{0,16}(\.\d{0,2})?)$")]
public decimal Property
{
    get;
    set;
}

This can be used for any precision and scale. The 16 is replaced by precision - scale and the 2 is replaced by the scale. The regular expression should match numbers entered like ###, 0.##, .##, 0, and ###.## as well as negative values.

Answer 3

In EF Core 6

You can simply use:

[Precision(18,2)]
public decimal Property{ get; set; }

Answer 4

If you write the 'column' annotation, will work fine

    [Required]
    [Column(TypeName = "decimal(18, 6)")]
    public decimal Foo { get; set; }

Answer 5

For a different approach which some may consider more readable, you can override the OnModelCreating method of your DbContext to set precision, like so:

protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {

           modelBuilder.Entity<YourEntity>()
                    .Property(x => x.TheProprty)
                    .HasPrecision(18, 2);
    }

Advantage: strongly typed vs custom regular expression

Disadvantage: can't see it on the class with just a scan

Answer 6

This seems to be the correct answer ( the above answers either restrict valid numbers that can be inserted into a data type of Decimal(18,2) or cause compile errors if you apply them to your code -- please confirm for yourself):

Use the following two constraints together:

Two Decimal Points

[RegularExpression(@"^\d+.?\d{0,2}$", ErrorMessage = "Invalid Target Price; Maximum Two Decimal Points.")]

Max 18 digits

  [Range(0, 9999999999999999.99, ErrorMessage = "Invalid Target Price; Max 18 digits")]

Answer 7

Following on from @Schmalls example (and comment re building it into an attribute) I've created a working example (uses C# 6 string interpolation):

public class PrecisionAndScaleAttribute : RegularExpressionAttribute
{
    public PrecisionAndScaleAttribute(int precision, int scale) : base($@"^(0|-?\d{{0,{precision - scale}}}(\.\d{{0,{scale}}})?)$")
    {

    }
}

Usage:

[PrecisionAndScale(6, 2, ErrorMessage = "Total Cost must not exceed $9999.99")]
public decimal TotalCost { get; set; }

Answer 8

.net core/5/6 solution that works 2021

using System;
using System.ComponentModel.DataAnnotations;
using System.Text.RegularExpressions;

[AttributeUsage(AttributeTargets.Property)]
public class ScalePrecisionValidationAttribute : ValidationAttribute
{
    private int _scale;
    private int _precision;

    public ScalePrecisionValidationAttribute(int scale, int precision)
    {
        _scale = scale;
        _precision = precision;
    }

    protected override ValidationResult IsValid(object value, ValidationContext validationContext)
    {
        if (value != null)
        {
            if (!Regex.IsMatch(value.ToString(), $@"^(0|-?\d{{0,{_scale-_precision}}}(\.\d{{0,{_precision}}})?)$"))
            {
                return new ValidationResult($"Allowed scale: {_scale}, precision: {_precision}");
            }
        }

        return ValidationResult.Success;
    }
}

use as

[ScalePrecisionValidationAttribute(8, 3)]
public decimal Weight { get; set; }

you might want to add/modify additional guards depending on the use-case. p.s. I have used the Regex pattern from one of the other answers

Answer 9

 [Range(1,(double) decimal.MaxValue, ErrorMessage="value should be between{1} and {2}."]

Answer 10

Im using almost excplusively (b/c it's simple and works)

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

Then if I need to convert back to double I add a conversion

(double)model.Split

Answer 11

Adding to Ahmad Kelany's answer.

From the Microsoft documentation Entity Properties

Entity Framework does not do any validation of precision or scale before passing data to the provider. It is up to the provider or data store to validate as appropriate.