Builds on type of the ConstTypeArgs.Core library to provide const type arguments that allow you to use type parameters to pass uint values to generics at compile-time. This provides an analog to type specialization in C++, and can be used for scenarios such as: * Static configuration, * Eliminating unnecessary instance constructors, * "Passing" values to type initializers, * And more. Built-in const type arguments cover 0 to 15, powers of 2 up to 65536, and more. Here's a simple demonstration showing how to define and use const type arguments and domain-specific type arguments: using ConstTypeArgs.Uints; // Const type arguments: public readonly struct _8 : K_Uint<_8> { public static uint Value => 8; } public readonly struct _32 : K_Uint<_32> { public static uint Value => 32; } public abstract class DefaultSize : Uint<_32> { } // Usage: public class Foo<TSize> where TSize : K_Uint { public static readonly int[] FooArray = new int[TSize.Value]; static Foo() { Console.WriteLine($"Array size is {FooArray.Length}"); } } // Elsewhere var foo = new Foo<_8>(); // Outputs "Array size is 8" foo = new Foo<DefaultSize>(); // Outputs "Array size is 32"
Get Started
$ dotnet add package ConstTypeArgs.UintsReadme
Uint Const Type Arguments
Const type arguments (also called const type args) are types used to pass constant & static values to generics through type parameters. These values are available at compile-time and can be used in static contexts, such as static constructors, static fields, and static methods. This can provide enhanced type safety, compile-time polymorphism, performance improvements, and more.
You can use types in the ConstTypeArgs.Uints namespace for passing uint values as const type arguments.
Usage scenarios include:
- Static configuration,
- Eliminating unnecessary instance constructors,
- "Passing" values to type initializers,
- and more.
The following is a simple example to demonstrate how this works:
using ConstTypeArgs.Uints;
public class Foo<TVal>
where TVal : K_Uint
{
static Foo()
{
if (TVal.Value > 0)
Console.WriteLine("Value is positive! ");
if (TVal.Value > (uint)int.MaxValue)
Console.Write($"{TVal.Value} > integer max value!");
}
}
// Elsewhere, assuming that _2147483648 is equal to 2,147,483,648
var foo = new Foo<_2147483648>();
// Output: "Value is positive! 2147483648 > integer max value!");
Here's how you could define a uint const type argument:
public readonly struct Pos_2 : K_Uint<Pos_2>
{ public static uint Value => 2; }