Allowing runtime evaluated expressions in user defined Attributes

[adejongh93]

Background

Working with Attributes InlineData on Xunit we faced the issue of not being able to pass runtime evaluated expressions, for example, Guid.NewGuid().ToString() when creating dynamic identifiers.

using System;
using Xunit;

namespace CSharp_Language_Proposals.AttributeProposal
{
    public class UnitTests
    {
        [Theory]
        [InlineData(Guid.NewGuid().ToString())] // CS0182 An attribute argument must be a constant expression, typeof 
                                                // expression or array creation expression of an attribute parameter type.
        public void SomeTest(string id)
        {
            // some Assertions
        }
    }
}

This issue is extended to user defined Attributes.

Proposal

Modify the compiler so the attributes would accept new types and runtime evaluated expressions.

using System;
using Xunit;

namespace CSharp_Language_Proposals.AttributeProposal
{
    public class UnitTests
    {
        [Theory]
        [InlineData(Guid.NewGuid().ToString())] // Compiler builds correctly.
        public void SomeTest(string id)
        {
            // some Assertions
        }
    }
}

[bernd5]

See: #4771

Why not using "Tools/Create Guid" in e.g. Visual Studio?

[jnm2]

@bernd5 I think "runtime-evaluated" means the same binary gets a different GUID on each test run?

[Joe4evr]

See #343.

[acaly]

If you need "runtime evaluated", you can probably workaround this by providing a dummy class type as argument and internally store runtime generated GUIDs in a Dictionary<Type, Guid>. Something like this:

class InlineDataAttribute
{
    private static Dictionary<Type, Guid> _guids = new();
    private readonly Type _type;
    public InlineDataAttribute(Type type)
    {
        _type = type;
    }
    public Guid Guid
    {
        get
        {
            if (!_guids.TryGetValue(_type, out var ret))
            {
                ret = Guid.NewGuid();
                _guids[_type] = ret;
            }
            return ret;
        }
    }
}

public class UnitTests
{
    private class GuidType {}
    [Theory]
    [InlineData(typeof(GuidType))]
    public void SomeTest(string id)
    {
        // some Assertions
    }
}

Note that this does not handle multithread racing. If you don't want to add new type for each method, you may instead combine a type + a nameof(SomeTest).