Deducing if a generic is an array type at compile time

Question

As documented upstream, one cannot use 'array' as base constraints:

[...]Some types are disallowed as a base class constraint: Object, Array, and ValueType.[...]

However there seems to be minimal type inference for array as seen at:

• C# generic constraint: Array of Structs
• Why can't System.Array be a type constraint?

My goal is to extend the original SO post, to handle also array types:

• https://stackoverflow.com/a/68949729/136285

So my naive attempt is as follow:

public class JsonDictionary
{
    public static readonly Key<int> Int = new Key<int> { Name = "INT" };
    public static readonly Key<int[]> Int3 = new Key<int[]> { Name = "INT3" };
    
    IDictionary<string, object> _data;
    public JsonDictionary()
    {
        _data = new Dictionary<string, object>();
    }
    public void Set<T>(Key<T> key, T obj)
    {
        if (obj is int[] objArray) // FIXME: runtime check
        {
            if (objArray.Length != 3)
                throw new FormatException("Illegal INT3");
        }
        _data[key.Name] = obj;
    }
    public T Get<T>(Key<T> key)
    {
        return (T)_data[key.Name];
    }
    public class Key<T>
    {
        public string Name { get; init; }
    }
}

Usage is simply:

var d = new JsonDictionary();
d.Set(JsonDictionary.Int, 42);
var i = d.Get(JsonDictionary.Int);
d.Set(JsonDictionary.Int3, new int[] { 1, 2, 3 });
var i3 = d.Get(JsonDictionary.Int3);
Assert.Throws<FormatException>(() => d.Set(JsonDictionary.Int3, new int[] { 1, 2 }));

Notice how I used a runtime check (obj is int[] objArray) because I could not use some kind of constraint for 'array'.

Is there a way to rewrite the above so that I can have two different Set functions, one for T and one for T[]. Otherwise I would need to handle all possible types with an ugly if/else:

        if (obj is int[] objArray)
        {
            if (objArray.Length != 3)
                throw new FormatException("Illegal INT3");
        }
        else if (obj is ushort[] objArray)
        {
            if (objArray.Length != 3)
                throw new FormatException("Illegal USHORT3");
        }
        else if (obj is double[] objArray)
        {
            if (objArray.Length != 3)
                throw new FormatException("Illegal DOUBLE3");
        }
        [...]

Answer 1

You can check if it's an Array:

if (obj is Array arr && arr.Length != 3)
{
    throw new FormatException("Illegal array. Expected length 3.");
}

Answer 2

It seems like you shouldn't use generics here at all. There's absolutely nothing common between an int[] and a double[], as there is no constraint for numbers - nor for arrays.

You could in some way workaround your problem with a constraint for IEnumerable, but that would also fit int[], but also a List<MyClass>.

So even if there was a constraint for arrays, there's no constraint for the array-type.

So after all you should have different method for different types:

Set(int i) => ...
Set(int[] arr) => ...
Set(double d) => ...
Set(double[]) => ...