Basically I am wondering how costly the call "Type.GetType()" is.
More specifically, I am wondering whether the subsequent identical calls
will incur the same amount of resource or not.

For example, let's say I have a MyClass type defined in MyAssembly.dll and I
call Type.GetType() method like below:

Type myType = Type.GetType("MyNamespace.MyClass, MyAssembly");

I assume then the the assembly will be loaded from the disk and the runtime
will use reflection to look up the type information, etc.  In my scenario,
this would be done in a static constructor/method, or in a one time setup
method.

Then some time later, let's say I need to create a class instance from the
same type but all I have is the same string argument that I passed into the
GetType method before - please don't argue why for the sake of argument for
now - and I use the same statement to create the Type instance and create an
instance at the same time like so:

Type myType = Type.GetType("MyNamespace.MyClass, MyAssembly");
MyClass myClass = (MyClass)Activator.CreateInstance(myType);

Would the second call to Type.GetType() incur the same amount of resource or
would it be relatively small since the assembly would have been loaded
already from the disk and cached?
Would calling, Activator.CreateInstance("MyAssembly",
"MyNamespace.MyClass"), make any difference?

Finally, MyAssembly.dll once loaded before, would it ever get unloaded from
the runtime other than by the appdomain recycle?

Thanks so much in advance.
Jiho