Dependency Injection - Choose DLL and class implementation at runtime through configuration file

I've an API DLL (API.dll, for example) which, in addition to many other thinks, makes available an abstract class (AbstractClass).

Now making use of that AbstractClass I've implemented it on two different dlls:

• First.API.Implementation.dll with ConcreteImplementation1
• Second.API.Implementation.dll with ConcreteImplementation2

Both ConcreteImplementation1 and ConcreteImplementation2 are implementation of the same abstract class.

What I want is an application where I can choose which of those two dlls to use and, through that, choose which implementation 开发者_如何学Pythonto use without the user having to change anything within the code and, if possible, without stopping the application.

Some configuration file where I can bring the application to use whatever implementation I want. Something like:

<appconfiguration>
    <implementation_to_use>
        <dll>First.API.Implementation.dll</dll>
        <class>ConcreteImplementation1</class>
    </implementation_to_use>
</appconfiguration>

I know near to nothing about dependency injection, apart from its concept, but I guess thats the perfect fit for this task.

I've researched several DI/IoC libraries but I'm not familiar with all the concepts and names. I can use whatever library I want. For what I can say these are the most used: StructureMap, Ninject and Sprint.NET

Moreover, apart from all the dlls and implementation I need to indicate a file to be used by that application. Can I indicate its path in that same file?

I just need some tips and directions to implement such a thing. Some examples using one of those libraries, would be awesome.

Thanks.

To get you started using StructureMap, create a console application, include in it:

structuremap.config:

<?xml version="1.0" encoding="utf-8" ?>
<StructureMap MementoStyle="Attribute">
  <DefaultInstance
    PluginType="DemoIoC.AbstractBase,DemoIoC"
    PluggedType="DemoIoC.ConcreteImplementation1,DemoIoC"
    Scope="Singleton" />
</StructureMap>

The PluginType and PluggedType attributes are "FullyQualifiedClassName,AssemblyName" By default it will look for assemblies in the executable folder, I'm not sure how you would specify another location for the assemblies

There are plenty of options for Scope, e.g. Singleton, Transient, etc

Program.cs:

namespace DemoIoC
{
    using System;
    using StructureMap;

    public static class Program
    {
        public static void Main(string[] args)
        {
            // here you initialize structuremap from the config file.
            // You could probably use a FileSystemWatcher to reinitialize 
            // whenever the structuremap.config file changes
            ObjectFactory.Initialize(x =>
            {
                x.UseDefaultStructureMapConfigFile = true;
            });

            var concrete = ObjectFactory.GetInstance<AbstractBase>();

            concrete.Method1();

            Console.ReadKey(true);
        }
    }
}

AbstractBase.cs:

namespace DemoIoC
{
    public abstract class AbstractBase
    {
        public abstract void Method1();
    }
}

ConcreteImplementation1.cs:

namespace DemoIoC
{
    using System;

    public class ConcreteImplementation1 : AbstractBase
    {
        public override void Method1()
        {
            Console.WriteLine("Called ConcreteImplementation1");
        }
    }
}