Let us use static classes as type parameters

[rick-palmsens]

As an example, many of the Microsoft.Extensions library services take a type that is uses as a sort of tag or category rather than a type that should be instantiated (see IStringLocalizer<>, ILogger<>, etc).

Now in our code base we also have a few static classes that contain identifiers like so:

public static class TechniqueId
{
    public const string ACVoltammetry = nameof(ACVoltammetry);
    public const string Chronoamperometry = nameof(Chronoamperometry);
    public const string Chronocoulometry = nameof(Chronocoulometry);
    public const string Chronopotentiometry = nameof(Chronopotentiometry);
    public const string CyclicVoltammetry = nameof(CyclicVoltammetry);
    public const string DifferentialPulseVoltammetry = nameof(DifferentialPulseVoltammetry);
    public const string ElectrochemicalImpedanceSpectroscopy = nameof(ElectrochemicalImpedanceSpectroscopy);
    public const string ElectrochemicalImpedanceSpectroscopicIteration = nameof(ElectrochemicalImpedanceSpectroscopicIteration);
    public const string FastAmperometry = nameof(FastAmperometry);
    public const string FastCyclicVoltammetry = nameof(FastCyclicVoltammetry);
    public const string GalvanostaticImpedanceSpectroscopy = nameof(GalvanostaticImpedanceSpectroscopy);
    public const string GalvanostaticImpedanceSpectroscopicIteration = nameof(GalvanostaticImpedanceSpectroscopicIteration);
    public const string LinearSweepPotentiometry = nameof(LinearSweepPotentiometry);
    public const string LinearSweepVoltammetry = nameof(LinearSweepVoltammetry);
    public const string MethodScriptSandbox = nameof(MethodScriptSandbox);
    public const string MixedMode = nameof(MixedMode);
    public const string MultiplePulseAmperometry = nameof(MultiplePulseAmperometry);
    public const string MultiStepAmperometry = nameof(MultiStepAmperometry);
    public const string MultiStepPotentiometry = nameof(MultiStepPotentiometry);
    public const string NormalPulseVoltammetry = nameof(NormalPulseVoltammetry);
    public const string OpenCircuitPotentiometry = nameof(OpenCircuitPotentiometry);
    public const string PulsedAmperometricDetection = nameof(PulsedAmperometricDetection);
    public const string SquareWaveVoltammetry = nameof(SquareWaveVoltammetry);
    public const string StrippingChronopotentiometry = nameof(StrippingChronopotentiometry);
}

It is impossible for us to now provide translations for these identifiers by creating an instance of IStringLocalizer<TechniqueId>, since static classes can't be used as type parameters.

We hacked around this by making the class uninstantiatable, but it obviously isn't a great solution:

public sealed class TechniqueId
{
    private TechniqueId() {}
}

We would prefer if C# was less restricting in this case and allowed us to pass a static class type to IStringLocalizer<>.

[huoyaoyuan]

Now that with static interface methods, static class with static-only interface is a thing now.

The generic type must declare it supports static class so that it can't create any instance of T. This is similar to ref struct as generic parameter. The generic type loses some functionality and it should be aware of this.

[rick-palmsens]

It already can't create an instance of T without defining where T : new(), so I don't believe explicitly declaring support for static classes is necessary. where is for adding functionality to T, not removing it. T without where is just as valid for a static class as it is for a non static class since it defined no functionality for T, and therefore has no expectations about T.

[khm1600]

For a static T, the generic type shouldn't be able to declare anything (fields, returns, parameters, etc.) as T or an array of T, cast an object to T, use is T, use default(T), use T as a generic constraint or pattern match against T, all of which is possible for an unconstrained T.

[TahirAhmadov]

What is the use case for this? What is a generic type which can receive TechniqueId as a generic argument?

[rick-palmsens]

As stated in the example, IStringLocalizer<TechniqueId>.

[TahirAhmadov]

I saw that, but my question is, how would this work? With a class like List<T>, generics allow you to add and retrieve items of that type without casting. What would IStringLocalizer<T> do with this type which benefits from generics? Perhaps you are looking for something like class StringLocalizer { public StringLocalizer(Type constantsContainer) { ... } ... }?

[PathogenDavid]

(I originally wrote this assuming that IStringLocalizer's implementation worked this way. It could, but it turns out it doesn't, but I still think this pattern serves as an example of why you might want generics that accept static types.)

Types like these can be an efficient way to attach extra static metadata to other types thanks to how the runtime handles generic types internally.

For an example in the BCL, look at the implementation of Array.Empty<T>(). Internally it uses System.Array.EmptyArray<T> to indirectly associate a 0-sized array of T with T its self. At runtime, calls to Array.Empty<T>() can compile down to a simple pointer dereference.

---

To give another example (and one that would actually work with static classes), imagine you're designing a system that frequently needs access to the Base64 of the names of types encoded as UTF8. Encoding strings as UTF8 and then encoding that as base64 is relatively slow, so ideally we only do it once and then never again.

One way to do this would be to store a Dictionary<Type, string> to associate pre-encoded strings to types. However if we only ever deal with these types in a generic context, we can use static fields within a generic type container to more efficiently associate this information with the type its self: (SharpLab)

public static class MyMetadata<T>
{
    public static readonly string FullName = typeof(T).FullName;
    private static readonly byte[] _FullNameUtf8Bytes = Encoding.UTF8.GetBytes(FullName);
    public static ReadOnlySpan<byte> FullNameUtf8Bytes => _FullNameUtf8Bytes;
    public static readonly string NameAsBase64 = Convert.ToBase64String(_FullNameUtf8Bytes);
}

---

This feature would also be useful if static classes were allowed to implement interfaces which only contain static abstract members. (This and this feature have been brought up in #4436, not sure if it was ever discussed in LDM.)

[333fred]

Extremely similar to #4840.

[jnm2]

Using static classes as generic type arguments is included under option 2 in Stephen Toub's proposal at #5783.