Generics open and closed constructed types

Question

Recently I noticed that generic constructed types can be open and closed. But I do not understand what they actually mean. Can you give a simple example?

Answer 1

In practice the terminology doesn't really matter much - I can't remember the last time I had to worry about it except when trying to write about it.

• An unbound type has no type arguments specified
• A constructed type has at least one type argument specified
• A type parameter is an open type
• An array type where the element type is open is an open type
• An open constructed type has at least one type argument which is an open type
• A closed type is any type which isn't open

(There are further rules for nested types. Consult the C# 3.0 spec section 4.4 for gory details.)

As an example of an open constructed type, consider:

public class NameDictionary<T> : Dictionary<string, T>

The base class of typeof(NameDictionary<>) is:

• Constructed because it specifies type arguments
• Open because the second type argument (T) is an open type

The MSDN docs for Type.IsGenericType have quite a useful little table.

Just to reiterate, this is almost entirely unimportant in day to day use.

I'm generally in favour of knowing the correct terminology - particularly for things like "pass by reference" etc - but in this case it really, really doesn't come up very often. I would like to actively discourage you from worrying about it :)

Answer 2

From MSDN:

A generic type or method is closed if instantiable types have been substituted for all its type parameters, including all the type parameters of all enclosing types. You can only create an instance of a generic type if it is closed.

So this works as List<int> is closed:

var list = Activator.CreateInstance(typeof(List<int>));

But this throws an exception at run-time because List<> is open:

var list = Activator.CreateInstance(typeof(List<>));
                                               ↑

Answer 3

I have mostly used open generics (basically uninstantiated generics) in dependency injection mappings. For example, something like

Bind<IRepository<>>()
   .To<BasicRepository<>>()

Then, when my object constructor contains:

public SomethingController(IRepository<Something>) { ... }

My dependency injection mechanism will instantiate a BasicRepository< Something > automagically. (This works with Ninject and StructureMap, and probably the Castle Windsor library; I'm not sure about other frameworks).