Definition of Type in .NET

This question gives me curiosity... When you want to define a type you must say GetType(Type) ex.: GetType(string), but ain't String a type itself?

Why do you need to use GetType in those situations? And, if the reason is because i开发者_StackOverflowt is expecting a Type 'Type'... why isn't the conversion implicit... I mean, all the data is there...

What you're doing is getting a reference to the meta-data of the type ... it might be a little more obvious if you look at the C# version of the API, which is typeof(string) ... which returns a Type object with information about the string type.

You would generally do this when using reflection or other meta-programming techniques

string is type, int is type and Type is type and they are not the same. but about why there is no implicit conversion it's not recommended by MSDN:

By eliminating unnecessary casts, implicit conversions can improve source code readability. However, because implicit conversions can occur without the programmer's specifying them, care must be taken to prevent unpleasant surprises. In general, implicit conversion operators should never throw exceptions and never lose information so that they can be used safely without the programmer's awareness. If a conversion operator cannot meet those criteria, it should be marked explicit.

Take attention to :

never lose information so that they can be used safely without the programmer's awareness

When you want to define a type you must say GetType(Type) ex.: GetType(string)...

That's not true. Every time you do any of the following

class MyClass
{
///...
}

class MyChildClass : MyClass
{
}

struct MyStruct
{
///...
}

you're defining a new type.

if the reason is because it is expecting a Type 'Type'... why isn't the conversion implicit... I mean, all the data is there...

One reason for this is polymorphism. For instance, if we were allowed to do the following:

MyChildClass x;

....GetType(x)

GetType(x) could return MyChildClass, MyClass, or Object, since x is really an instance of all of those types.

It's also worth noting that Type is itself a class (ie, it inherits from Object), so you can inherit from it. Although I'm not sure why you'd want to do this other than overriding the default reflection behavior (for instance, to hide the internals from prying eyes).

GetType(string) will return the same information. Look at it like you would a constant. The only other way to get the Type object that represents a string would be to instantiate the string object and call o.GetType(). Also, this is not possible for interfaces and abstract types.

If you want to know the runtime type of a variable, call the .GetType() method off of it, as the runtime type may not be the same as the declared type of the variable.