What is System.Void?

Question

I know that methods declared with void does not return anything.

But it seems that in C# void is more then just a keyword, but a

Answer 1

void/System.Void is different from int/System.Int32, it's a special struct in C#, used for reflection only. See this example:

class Program
{
   public static void Main(string[] args)
   {
      Type voidType = typeof(Program).GetMethod("Main").ReturnType;
   }
}

There must some type used to describe the return type of Main method here, that's why we have the System.Void.

Answer 2

We have used the following code

public Type GetType(object o)
{
    var type = o == null ? typeof(void) : o.GetType();
}

So that we can use the null object pattern. It's pretty good. This allows us to do stuff like

GetType(o).GetProperties().Select( .....

instead of putting guard clauses everywhere

Answer 3

Beyond not returning a value, very little definition is given of void (although void* gets some attention) in the language spec. This isn't really a language concern - although the CLI may define it further.

Ultimately though: because it has no meaning to do new void()

Answer 4

From the documentation:

The Void structure is used in the System.Reflection namespace, but is rarely useful in a typical application. The Void structure has no members other than the ones all types inherit from the Object class.

There's no reason really to use it in code.

Also:

var nothing = new void();

This doesn't compile for me. What do you mean when saying it "works"?

Update:

A method void Foo() does not return anything. System.Void is there so that if you ask (through Reflection) "what is the type of the return value that method?", you can get the answer typeof(System.Void). There is no technical reason it could not return null instead, but that would introduce a special case in the Reflection API, and special cases are to be avoided if possible.

Finally, it is not legal for a program to contain the expression typeof(System.Void). However, that is a compiler-enforced restriction, not a CLR one. Indeed, if you try the allowed typeof(void) and look at its value in the debugger, you will see it is the same value it would be if typeof(System.Void) were legal.