Defining a Type to be a Superset of Types

Question

Suppose I have a basic inheritance structure:

public class Letter {...}
public class A : Letter {...}
public class B : Letter {...}
public class C : Letter {...}

public class Number {...} 
public class One : Number {...}

I want to define an array of Types such that only Types which inherit from Letter are valid. So a sample array might look like:

(type)[] myArray = new (type)[] {typeof(A), typeof(B), typeof(C)};

But the assignment

myArray[0] = typeof(One);

would fail. Is it possible to define such a structure?

First thing that comes to mind is generics with constraints. — Tim, Jan 11 '16 at 23:01
@Tim: mind it is not the *objects* that are stored, it are the `System.Type`s... — Willem Van Onsem, Jan 11 '16 at 23:02
For sure it's possible, since you are allowed to write classes with indexers and put whatever logic you want inside. But it cannot be a plain array. — Jon, Jan 11 '16 at 23:04
@Jon: I think the OP asks for a type-checkable solution (at compile time) for the problem. Evidently one can define a data structure that does checking at the frontdoor. — Willem Van Onsem, Jan 11 '16 at 23:05
@WillemVanOnsem how can it ever be statically verifiable when `Type` instances can be produced at runtime? — Jon, Jan 11 '16 at 23:06
@Jon: that's my point exactly: it isn't. But you can check the type at runtime, or you could use code contracts and hope that it can be verified. — Willem Van Onsem, Jan 11 '16 at 23:06
@Tim: You can do this with Java (although the check can be spoofed anyway), but in C# `System.Type` is not generic. — Willem Van Onsem, Jan 11 '16 at 23:10
See posting : http://stackoverflow.com/questions/8388964/how-can-i-inherit-the-string-class — jdweng, Jan 11 '16 at 23:18

score 3 · Answer 1 · answered Jan 11 '16 at 23:18

All types are instances of System.Type, being the same statically. Therefore, doing this using a conventional array is not possible. One option is to create a data structure that only allows addition through type parameters:

internal sealed class LetterTypeSet : IReadOnlyCollection<Type>
{
    readonly ISet<Type> types = new HashSet<Type>();
    public IEnumerator<Type> GetEnumerator() => this.types.GetEnumerator();
    IEnumerator IEnumerable.GetEnumerator() => this.GetEnumerator();
    public int Count => this.types.Count;

    public bool Add<T>()
        where T : Letter
    {
        return this.types.Add(typeof (T));
    }
}

This would allow:

var letters = new LetterTypeSet();
letters.Add<A>(); //ok
letters.Add<B>(); //ok
letters.Add<One>(); //CS0311 "The type 'One' cannot be used ..."

Note: I'm using a ISet<T> as the underlying data structure, you may or may not want to use a List<T> instead depending on the requirements.

Willem Van Onsem · Accepted Answer · 2016-01-11T23:28:23.467

I don't think it is possible that you can use the type system to enforce this: typeof returns an instance of System.Type. This is a generic class and there is no aspect of the typesystem that can enforce that only subtypes of a certain type can be stored. So using the typesystem for this is probably not the way to go.

There are some alternatives however:

You could use contract contracts and hope that your can verify this at compile time. For instance:
```
Type[] myArray = new (type)[] {typeof(A), typeof(B), typeof(C)};

//...

Contract.Ensures(Contract. ForAll (myArray,t => typeof(Letter).IsAassignableFrom(t));
```
Note however that it is an undecidable problem, and that the contract verifier can only give a conservative answer.

You could define a data-structure (probably a subset of an ICollection<Type> that enforces this at the front door. For instance:

public class SubTypeList<T> : IList<Type> {

    private readonly List<Type> innerList = new List<Type>();

    public void Add (Type type) {
        if(typeof(T).IsAssignableFrom(type)) {
            innerList.Add(type);
        } else {
            throw new ArgumentException("The given System.Type must be an inherit from T!");
        }
    }

    //Implement other methods
    //...

}

score 0 · Answer 3 · answered Jan 11 '16 at 23:14

You can always define an array of Letter, and only Letter objects and types derived from it can be assigned to the elements. However, when you get an element of the array, the compiler will think it is a Letter. That may be what you want. If not, you can discover what it really is at run-time:

if (myArray[i] is A)
{
    A objA = myArray[i] as A;
    ...

The is and as operators are used in these downcasts to verify that the downcast is valid.

Or, better, you can define behavioral properties and methods of your Letter base class that allow the caller to obtain the behaviors of the derived classes without having to know what the exact class of the object is.

myArray[i].DrawSelf(Point ptStart)

and make the various derived classes responsible for knowing how to draw themselves starting at a given location.

I think you do not understand the problem correctly. `myArray` will contain `System.Type` **instances**, **not** instances of `Letter`. — Willem Van Onsem, Jan 11 '16 at 23:15
Wrap your array in accessors that verify the `Type` instance meets the test `typeof(Letter).IsAssignableFrom(t)`. — S. Rojak, Jan 11 '16 at 23:21

Defining a Type to be a Superset of Types

3 Answers3