[Proposal]: Nullable value types in attribute usage

[matkoch]

Nullable value types in attribute usage

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

Remove the restrictions of setting nullable value types in attribute usages.

Motivation

Currently, the following code yields a CS0655:

public class FooAttribute : Attribute
{
    public bool? Boolean { get; set; }
}

[Foo(Boolean = true)] // CS0655
public class Bar { }

This is often an annoyance because I have to fully implement the property with a "backing field":

public class FooAttribute : Attribute
{
    public bool? Boolean2; // not even a real backing field, since I might need to access from outside of class
    public bool Boolean
    {
        set => Boolean2 = value;
        get => Boolean2.Value ?? false; // defining a getter is mandatory
    }
}

Detailed design

N/A

Drawbacks

The status quo is a drawback.

Alternatives

N/A

Unresolved questions

Design meetings

[Joe4evr]

Part of the problem here is that nullable value types cannot be emitted as a const value which is a requirement for setting attribute properties.

[matkoch]

Okay. Maybe I'm oversimplifying, but true, false, null, are all constants. So what's stopping from allowing this?

[HaloFour]

The attribute metadata is embedded in the assembly as a binary blob that the is interpreted by the runtime at runtime when you look up the custom attributes on a type/member. The runtime has to be able to understand the types and layout of the data in that binary blob. This is why even pseudo-constants supported by C#, like decimal, are not supported in attributes, the compiler can't influence how the value would be interpreted.

Would be nice if that list of supported types could be expanded. I don't believe it's changed since 1.0.

[matkoch]

[YairHalberstadt]

The runtime only allows specific values in attributes. None of them are the null value of Nullable<T>. So this would require runtime changes.

[matkoch]

Sorry, I accidentally posted as an answer... will post as reply again..

[svick]

I don't understand, why do you have to define the attribute with a backing field? Can't you make it a bool auto-property?

public class FooAttribute : Attribute
{
    public bool Boolean { get; set; }
}

Even like this, you should still be able to differentiate between [Foo], [Foo(Boolean = true)] and [Foo(Boolean = false)].

[svick]

@YairHalberstadt Using GetCustomAttributesData. E.g.:

using System;
using System.Linq;

foreach (var type in new[] { typeof(Nothing), typeof(True), typeof(False) })
{
    var attributeData = type.GetCustomAttributesData().Single();
    Console.WriteLine($"{attributeData}: {(attributeData.NamedArguments.Any() ? attributeData.NamedArguments.Single() : "nothing")}");
}

public class FooAttribute : Attribute
{
    public bool Boolean { get; set; }
}

[Foo]
class Nothing { }

[Foo(Boolean = true)]
class True { }

[Foo(Boolean = false)]
class False { }

This prints:

[FooAttribute()]: nothing
[FooAttribute(Boolean = True)]: Boolean = True
[FooAttribute(Boolean = False)]: Boolean = False

[matkoch]

Good idea, but for one, this doesn't work if you have inheritance chains where an intermediate type sets the property in its constructor. It's a workaround, and it will work in some cases.

[jnm2]

IIRC it's safer to use GetCustomAttributesData than to allow arbitrary code to execute by getting an actual attribute instance. Metadata-only/reflection-only contexts enforce this.

[matkoch]

But that's unrelated to the proposal?

[jnm2]

My answer was to "this doesn't work if you have inheritance chains." An inherited class where an intermediate type sets a property in the constructor is in the same bucket and works equally well with GetCustomAttributesData. Whether or not inheritance is involved, the code that uses reflection to understand the attribute needs to recognize what defaults are set by the constructor that is called if it uses GetCustomAttributesData.

[Joe4evr]

Another alternative would be to provide a secondary constructor:

public class FooAttribute : Attribute
{
    public bool? Boolean { get; }

    public FooAttribute() { }
    public FooAttribute(bool flag) => Boolean = flag;
}

Though, I admit, this is only feasible when you only have 1 (or maaaaaybe 2) of these properties.