[API Proposal]: union

[HughPH]

Background and motivation

I apologise if this has already appeared, I don't see an API Proposal for it explicitly (with union in the title)

When dealing with interop with C/C++, and sometimes when porting, there are times when it would be handy to have a union.

API Proposal

union {
    [type1] [nameA];
    [type2] [nameB];
    [type3] [nameC];
}

API Usage

[StructLayout(LayoutKind.Sequential)]
struct MyStruct {
    public int* thingiesHandle; // unrelated

    public int thingiesCount; // unrelated

    internal union {
        int whyAreTheseInTheSameMemory;
        float nobodyKnows;
        Vector2OfShort itsAMystery;
        fixed byte isThisAStretchTooFar[4];
    }
}

Alternative Designs

Behind the scenes it would create an explicitly laid out struct the size of its largest member that would behave like a tuple with access to the fields like Unsafe.As or *(T*)ptr. So in that sense perhaps there are alternatives like Tuple<T1,T2>(val1,val2) vs (val1,val2) or Nullable<T> vs T? maybe something like Union<T1,T2,T3> though that wouldn't work at all with fixed buffers.

The other need would be to be able to inject names, which would probably blow a hole in that:

unsafe struct Union<T1, T2> where T1: unmanaged where T2: unmanaged
{
    private void* _ptr;
    
    public T1 AsT1 => *(T1*)_ptr;
    public T2 AsT2 => *(T2*)_ptr;
}

I'd just want to refer to the aliases by which the same memory goes, rather than myStruct.MyUnion.AsT1 (for example)

Risks

The only fly in the ointment that I can think of is lack of clarity in the IL. You'd be creating a field in the owning struct that has a size, and then just load it as whatever type is being requested just like an unsafe cast. BUT dotnet already produces things with weird names for anonymous types, lambdas, and so forth, and very few people try to understand the code by reading the IL. The performance impact is zero.

[huoyaoyuan]

union {
[type1] [nameA];
[type2] [nameB];
[type3] [nameC];
}

This is not an API, but a C# language feature. There are discussions for discriminated union at dotnet/csharplang#399, dotnet/csharplang#8313 and dotnet/csharplang#8926, but not interop-oriented union.
It's very unlikely to get a C# language feature for interop.

The suggested solution for the future is #100896 with CustomLayoutKind.Union.

[HughPH]

Thanks!

[Clockwork-Muse]

... Note that a discriminated union isn't quite the same as C/C++s alias union.

Strictly speaking discriminated unions in most languages don't allow for referencing the fields indiscriminately, and only as a type-checked reference. And usually allows for multiple fields per "entry".

In contrast a C/C±± union overlays the fields, allowing some tricks (some of which are officially undefined).