177

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.

Improve this question
0

3 Answers 3

Reset to default
179

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

8 Comments

Why decimals are not considered primitive types in the CLR?
@koumides i believe the answer is the type is too large to express in a single CPU register as it is 128bit
OK so why are strings allowed as attribute properties? I suppose it comes under the 'array of primitives' category but it is heap allocated (reference type)...
Because strings are reference types which are handled completely different.
@Soren this is not true, Enum are supported. I currently have 2 custom attributes one with 2 enums and the others with an array of enum.
|
86

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.
Improve this answer

4 Comments

Correct, but note that you're quoting an old version of the spec. In C# versions 3.0, 4.0, and 5.0, it is stated that it can also have type sbyte, ushort, uint, ulong. And that seems to work all right. But still decimal is not allowed :-(
@JeppeStigNielsen I've updated the spec link and quote
Nullable primitives are also NOT supported.
I used this syntax to pass a an array of string to constructro: params string[] When calling the constructor you should separate string by comma
5

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;
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.