How can I define a const nuint value with every bit as 1, which is -1 in C#?

[LEI-Hongfaan]

const nuint v1 = 42; // OK
const nuint v2 = ~(nuint)0; // CS0133
const nuint v3 = unchecked((nuint)(-1)); // CS0133

[ufcpp]

https://github.com/dotnet/csharplang/blob/main/proposals/csharp-9.0/native-integers.md

If the operation results in a constant value in 32-bits, constant folding is performed at compile-time. Otherwise the operation is executed at runtime and not considered a constant.

[BlinD-HuNTeR]

I made a quick investigation and apparently it's not possible. Because native ints have variable size, you can only define constants in the 32-bit range. Then, according to Built-in numeric conversions (C# reference), signed types get sign-extended while unsigned types get zero-extended.

In other words, you can define a const nint to be -1 (0xFFFFFFFF) and it will be sign-extended at runtime, but if you define a const nuint to 0xFFFFFFFF, it will be zero-extended to 0x00000000FFFFFFFF at runtime, which is not what you want.

[jnm2]

Adding on:

The numeric value of the constant must be the same on both x64 and x86, but unsigned 32-bit 0xFFFFFFFF and unsigned 64-bit 0xFFFFFFFF_FFFFFFFF do not have the same numeric value.

This is functionally similar to asking "how do I make a const that has the value 1234 when running as 32-bit and the value 5678 when running as 64-bit?" That's not something a single AnyCPU .dll can do in the .NET runtime.

You can, however use static readonly fields, or have even larger divergent code paths and let the jit elide branches based on IntPtr.Size checks (IIRC). It's not possible to make a single const hold a numeric value that varies per runtime bitness, but that shouldn't stop you from achieving the behavior you need in an app.