Using the same class from different versions of an assembly

Question

I have a question regarding how the .NET runtime handles types loaded from different versions of the same assembly. I know, this is generally not a recommended practice. Also I am aware that strictly speaking they are not the same type if they come from different versions. I have successfully reproduced and (I think) understood this example: http://blogs.msdn.com/b/thottams/archive/2007/04/11/two-versions-of-an-assembly-in-an-appdomain.aspx.

However, I have created another example, which I don't understand. Here's what it's like:

• Assembly "Framework", with one simple class "FrameworkClass". I have compiled this class twice, with different version numbers, and stored them in separate folders. These DLLs are signed & strong named.

  public class FrameworkClass
  {
      public FrameworkClass()
      {
          Id = Guid.NewGuid().ToString();
      }
  
      public string Id { get; private set; }
  }
  

• Assemblies "Lib1" which references Framework 1.0.0.0, and "Lib2" which references Framework 2.0.0.0. Both implement methods "MakeFrameworkClass" to instantiate and return FrameworkClass, and "ProcessFrameworkClass" to receive a FrameworkClass and somehow process it. So Lib1 can create and process FrameworkClass 1.0.0.0, and Lib2 can create and process FrameworkClass 2.0.0.0.

  public class LibX
  {
      public FrameworkClass MakeFrameworkClass()
      {
          return new FrameworkClass();
      }
  
      public string ProcessFrameworkClass(FrameworkClass x)
      {
          return x.Id;
      }
  }
  

• Assembly "Main", which is a command line app that ties it all together by calling the methods from Lib1 and Lib2 and writing results to the console. In the app.config I have used codeBase elements, so that both Framework versions are loaded and used as required by the Lib assembles.

Now here's what happens:

1. If I call the Lib1 MakeFrameworkClass and pass the result to the Lib1 ProcessFrameworkClass, it obviously works. The same is true when using only Lib2.
2. If I instantiate the FrameworkClass 1.0.0.0 using Activator.CreateInstance and cast it to FrameworkClass 2.0.0.0 (as shown in the example in the link above), it obviously fails. That makes sense, since the FrameworkClass 1.0.0.0 and FrameworkClass 2.0.0.0 are actually different types, that are not assignable to each other. So far so good...

3. BUT: If I call MakeFrameworkClass from Lib1 and pass the result to ProcessFrameworkClass of Lib2, it works! Also, the other way round, if I call MakeFrameworkClass from Lib2 and pass the result to ProcessFrameworkClass of Lib1, it works!

   FrameworkClass x;
   x = lib2.MakeFrameworkClass();
   Console.WriteLine(lib1.ProcessFrameworkClass(x) + " " + x.GetType().AssemblyQualifiedName);
   x = lib1.MakeFrameworkClass();
   Console.WriteLine(lib2.ProcessFrameworkClass(x) + " " + x.GetType().AssemblyQualifiedName);
   

I don't understand how #3 can work. I have verified by outputting the AssemblyQualifiedName that the instance I get from the MakeFrameworkClass call is the correct version depending on what Lib is being used. And of course if I use the other Lib for the ProcessFrameworkClass call, it has to expect a FrameworkClass of the other version. These should be different types. Why do i not get an exception as in the linked example?