Loading type through Reflection

I assume you did try it out and now you want a confirmation of your observation?

As long as you don't need any information from your loaded type (like calling a method or a property, etc.), you don't need any references anywhere.

But since in most cases you do need some information of that type, such a scenario is usually done via interfaces: that loaded type implements an interface and you cast the created object to that interfaces instead of an object. Then you only need to know the interface type (i.e. have the defining assembly references in the project).

E.g.

// interface assembly I
public interface IMyPlugin
{
   string Name { get; }
   ...
}

// implementation A assembly: reference to assembly I
public class MyPluginA: IMyPlugin
{
   public string Name { get { return m_Name; } }
   ...
}

// main assembly: references only assembly I
...
Dictionary<string, IMyPlugin> m_Plugins = new Dictionary<string, IMyPlugin>();
...
foreach(Type type in LoadMyPluginConfig(...))
{
    IMyPlugin plugin = (IMyPlugin)Activator.CreateInstance(type);
    m_Plugins.Add(plugin.Name, plugin);
}
...

You may want to have a look at MEF (Managed Extensibility Framework)[^] to have this kind of activation done for you.

Cheers
Andi

Now that I did try it out myself, I think I found the reason for your problem:
you get fooled by Visual Studio.

Visual Studio usually deploys (silently) all the project references to the build output folder of the given C# project. I.e. when you add in the main program project a reference to the LibA and LibB, then they get deployed beside the main program in the bin\Debug or bin\Release folder.

If you do not reference these two libs, you get only the main program assembly deployed to its bin\Debug or bin\Release folder.

What you observe is that the type from LibA can not be constructed since the types could not be found by .NET assembly resolution machinery.

Do the following:
1) set the output folder of all projects to ..\bin (instead of bin\Debug or bin\Release)
2) recompile the solution.

Now, all assemblies are in the same bin folder and .NET can resolve the needed types.

Cheers
Andi

PS: Example code:

Main Project, no references to neither LibA nor LibB.

namespace ConsoleApplication9
{
    class Program
    {
        static void Main(string[] args)
        {
            Type type = Type.GetType("LibA.ClassA, LibA, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
            object obj = Activator.CreateInstance(type);
            Console.WriteLine(obj.ToString());
        }
    }
}

LibA with reference to LibB:

namespace LibA
{
    public class ClassA
    {
        public ClassB Other { get; set; }
        public ClassA()
        {
            Other = new ClassB();
        }
    }
}

LibB:

namespace LibB
{
    public class ClassB
    {
        public void Write(string message)
        {
            Console.WriteLine("Message: {0}", message);
        }
    }
}

Now, the important part is: build all projects such that the resulting assemblies are located in *one* directory.
This can be done by one of the following:

1. the steps as described above
2. copy the assemblies manually to one directory (crude)
3. if you have a specific deployment structure in the product, implement an assembly resolution handler

I suggest to go the 1st approach since it is the simplest one. Otherwise, a resolution handler would help.