Why "decimal" is not a valid attribute parameter type?

It is really unbelievable but real. This code will not work:

[AttributeUsage(AttributeTargets.Property|AttributeTargets.Field)]
public class Range : Attribute
{
    public decimal Max { get; set; }
    public decimal Min { get; set; }
}

public class Item
{
    [Range(Min=0m,Max=1000m)]  //compile error:'Min' is not a valid named attribute argument because it is not a valid attribute parameter type 
    public decimal Total { get; set; }  
}

While this works:

[AttributeUsage(AttributeTargets.Property|AttributeTargets.Field)]
public class Range : Attribute
{
    public double Max { get; set; }
    public double Min { get; set; }
}

public class Item
{
    [Range(Min=0d,Max=1000d)]
    public decimal Total { get; set; }  
}

Who can tell me why double is OK while decimal is not.

> This is a CLR restriction. Only > primitive constants or arrays of > primitives can be used as attribute > parameters. The reason why is that an > attribute must be encoded entirely in > metadata. This is different than a > method body which is coded in IL. > Using MetaData only severely restricts > the scope of values that can be used. > In the current version of the CLR, > metadata values are limited to > primitives, null, types and arrays of > primitives (may have missed a minor > one). >

Taken from this answer by JaredPar. > Decimals while a basic type are not a > primitive type and hence cannot be > represented in metadata which prevents > it from being an attribute parameter.

From the specs:

> The types of positional and named parameters for an attribute class > are limited to the attribute parameter types, which are: > > - One of the following types: bool, byte, char, double, float, int, long, sbyte, short, string, uint, ulong, ushort. > - The type object. > - The type System.Type. > - An enum type, provided it has public accessibility and the types in which it is nested (if any) also have public accessibility (Attribute specification). > - Single-dimensional arrays of the above types.

The answer to this problem is to use strings, which are allowed as attributes despite not being an atomic type. Don't use doubles as rounding will make the results less accurate.

public String MinimumValue
{
    get
    {
        return minimumValueDecimal.ToString();
    }

    set
    {
        minimumValueDecimal = Decimal.Parse(value);
    }
}

private decimal minimumValueDecimal;