[DotNet] Were there ideas of having strongly typed properties?

[Danielku15]

On .net it is quite a hassle to use the Terraform CDK properly because of the union types used in TypeScript for many properties. In the .net generation a lot of properties result in a simple object? which removes any type safety and is prone for users to set things correctly.

So I was wondering if there were ideas and/or attempts to get a better type safety by using a fake-union type which gives a certain level of compile time safety.

I prepared a small example on how such a runtime safety could look like. It uses the implicit and explicit casting operators to make the usage more convenient:

// Such a type is the heart of the type safety. we would create one of them for each 
// number of union types we want to support. e..g Union<T1, T2>, Union<T1, T2, T3, T4> 
public class Union<T1, T2, T3>
{
    public enum Value
    {
        T1,
        T2,
        T3
    }

    public Value FilledValue { get; }
    public T1 V1 { get; }
    public T2 V2 { get; }
    public T3 V3 { get; }

    public Union(T1 v1)
    {
        V1 = v1;
        FilledValue = Value.T1;
    }

    public Union(T2 v2)
    {
        V2 = v2;
        FilledValue = Value.T2;
    }

    public Union(T3 v3)
    {
        V3 = v3;
        FilledValue = Value.T3;
    }

    public static implicit operator Union<T1, T2, T3>(T1 value)
    {
        return new Union<T1, T2, T3>(value);
    }

    public static implicit operator Union<T1, T2, T3>(T2 value)
    {
        return new Union<T1, T2, T3>(value);
    }

    public static implicit operator Union<T1, T2, T3>(T3 value)
    {
        return new Union<T1, T2, T3>(value);
    }

    public static explicit operator T1(Union<T1, T2, T3> value)
    {
        if (value.FilledValue == Value.T1)
        {
            return value.V1;
        }

        throw new InvalidCastException("Union did not contain " + typeof(T1).Name);
    }

    public static explicit operator T2(Union<T1, T2, T3> value)
    {
        if (value.FilledValue == Value.T2)
        {
            return value.V2;
        }

        throw new InvalidCastException("Union did not contain " + typeof(T2).Name);
    }

    public static explicit operator T3(Union<T1, T2, T3> value)
    {
        if (value.FilledValue == Value.T3)
        {
            return value.V3;
        }

        throw new InvalidCastException("Union did not contain " + typeof(T3).Name);
    }
}

// the generated C# classes will use the union types like this
public class Resource
{
    public Union<string?, string[]?, bool> UnionProp { get; set; }
}


// this is the usage
public class Usage
{
    public Usage()
    {
        // setter (successful)
        var r1 = new Resource
        {
            UnionProp = true
        };

        var r2 = new Resource
        {
            UnionProp = "test"
        };

        var r3 = new Resource
        {
            UnionProp = new[] { "test" }
        };
        
        // setter which fails on compile time
        r1.UnionProp = 4711; 

        // getter (successful)
        var boolValue = (bool)r1.UnionProp;
        var stringValue = (string?)r2.UnionProp;
        var stringArrayValue = (string[]?)r3.UnionProp;

        // getter which will fails
        var wrong1 = (string?)r1.UnionProp; // will throw an InvalidCastException (like before with object) 
        var wrong2 = (bool)r1.UnionProp; // will throw an InvalidCastException (like before with object) 
        var wrong3 = (int)r1.UnionProp; // compile time error because it cannot be an int
    }
}

Of course the backend/serialization parts would have to be adjusted accordingly but the benefit for developers would be huge.