Can Object.GetType also be used for late binding?

a) Can Object.GetType also be used for late binding ( Book I’m reading says it can’t be used for late-binding )?

For example, assuming we use late binding ( by dynamically loading an assembly A, calling A.GetType(“T”) and then calling Activator.CreateInstance) to create an instance (I) of type (T) not known at compile time and if we then pass I as an argument to method M, would o.GetType be able to extract metadata from T and create Type object using this extracted metadata?

void M ( object o )
{
  Type someType = o.GetType() ;
}

b) If yes --> how is o.GetType able to extract the metadata about o, since program’s assembly doesn’t contain any metadata on type T ( here I’m assuming tha开发者_开发百科t Object.GetType consults assembly’s metadata when trying to gt information about particular type )?

thanx

a) Yes, you can do late binding by using the methods like Type.Invoke and Type.GetMember. But the code gets a bit elaborate that way. C# 4.0 adds the dynamic keyword to simplify things.

b) Yes it can. It gets its info from the dynamically loaded assembly which contained the type in the first place. After it is loaded it is part of the (runtime) application (AppDomain) and it's metadata can be accessed.

Yes. Since GetType() gets the type information at run time, rather than compile time, all the metadata is already there when calling it, because when the type is loaded, it's assembly is already loaded too, so when you assume the program doesn't contain the information about the type remember that you have already loaded the dynamic assembly and now you can query about the new assembly's types. Hope it helps.

Each instantiated object has an pointer to its Type info. If you know the type name and the assembly it comes from, you can create it like you said. .NET will search the metadata of the assembly to find the type and everything it needs.

What do you mean by "late binding" exactly ?

Answer to comment: A. Yes, each reference to an object has 8 bytes (on x86) of overhead: a pointer to a sync lock and a pointer to the type information. Each assembly has all the metadata necessary to describe all types therein. So, the instance o knows itself and its originating assembly (the Type class has an Assembly property). B. 'Late binding' has quite a few definitions. I've seen it used often when one uses Type.InvokeMember to call a method when the method name is known at run-time only; or in the context of COM, when IDispatch is used (like the old VB did when one did not declare a variable type).