title: TypeLoadException on Assembly.GetType Explicit Interface implementation
body: <p>So here is my issue.  I have a complex archetecture of interfaces and abstract classes that I am trying to load up via Assembly.LoadFrom("x.dll").  When certain types that have an interface implementation where the implementation is explicit in a base class are trying to be loaded, I am getting a TypeLoadException saying:</p>
  
  <p>Method 'MyMethod' in type 'MyPart2DerivedType' from assembly 'MyPart2Assembly, version...' does not have an implementation.  I am trying to understand why this is as I have gone through several articles and have even attempted to delete the obj files and dlls manually.  Here are the references to what I have done so far:</p>
  
  <p><a href="https://stackoverflow.com/questions/8527966/solution-to-typeloadexception">Solution to TypeLoadException</a></p>
  
  <p><a href="https://stackoverflow.com/questions/948785/typeloadexception-says-no-implementation-but-it-is-implemented">TypeLoadException says &#39;no implementation&#39;, but it is implemented</a></p>
  
  <p><a href="http://social.msdn.microsoft.com/Forums/vstudio/en-US/1949a541-9726-40d4-b139-06afca8309cd/typeloadexception" rel="nofollow noreferrer">Visual Studio Forumns: TypeLoadException</a></p>
  
  <p><a href="http://social.msdn.microsoft.com/Forums/vstudio/en-US/cde62e35-be9a-400b-867b-fe16a51fb13b/private-accessors-and-explicit-interface-implementation" rel="nofollow noreferrer">Private accessors and explicit interface implementation</a></p>
  
  <p>So here is my example code:</p>
  
  <pre><code>//This is in project 1
  public interface IFooPart1
  {
      void DoStuff();
  }
  
  //This is in project 2
  public interface IFooPart2
  {
      void DoOtherStuff();
  }
  
  //This is in project 3
  public interface IFooPart3: IFooPart1, IFooPart2
  {
      void DoEvenMoreStuff();
  }
  
  //This is in project 4
  public abstract class MyBaseType: IFooPart1, IFooPart2
  {
      void IFooPart1.DoStuff()
      {
          DoStuffInternal();
      }
  
      void IFooPart2.DoOtherStuff()
      {
          DoOtherStuffInternal();
      }
  }
  
  //This is in project 5
  public class MyDerivedType: MyBaseType, IFooPart3
  {
      public void DoEvenMoreStuff()
      {
          //Logic here...
      }
  }
  
  //Only has references to projects 1, 2, &amp; 3 (only interfaces)
  public class Program
  {
      void Main(params string[] args)
      {
          //Get the path to the actual dll
          string assemblyDll = args[0];
  
          //Gets the class name to load (full name, eg: MyNameSpace.MyDerivedType)
          string classNameToLoad = args[1];
  
          //This part works...
          var fooAssembly = Assembly.LoadFrom(assemblyDll);
  
          //Here we throw a TypeLoadException stating
          // Method 'DoStuff' in type 'MyDerivedType' from assembly 'Project 5...' does
          //  not have an implementation.
          Type myDerivedTypeExpected = Assembly.GetType(classNameToLoad);
      }
  }
  </code></pre>
  
  <p>Note: If I move the explicit implementation to MyDerivedType instead of MyBaseType it works... but I don't get why I would have to do that.  Seems like I should be able to.  This code is only an example, the actual code has a factory that returns the loaded class but only via the interface type. (eg: var myDerivedType = GetInstance();)</p>