using System;

using Ninject;

public class Program

{

    public static void Main()

    {

        IKernel kernel = new StandardKernel();

        kernel.Bind<IServiceA>().To<ServiceA>().Named("legacy");

        kernel.Bind<IServiceA>().To<RoutingService>().Named("routing");

        kernel.Bind<IServiceB>().To<WhateverServiceB>();

        var legacyServiceA = kernel.Get<IServiceA>("legacy");

        legacyServiceA.DoWork();

        var routingServiceA = kernel.Get<IServiceA>("routing");

        routingServiceA.DoWork();

        // Not really sure how 'MethodA' is supposed to be accessed if

        // RoutingService is a replacement, so let's do a type cast

        (routingServiceA as RoutingService).MethodA("Zooo legacy-ish!");

        (routingServiceA as RoutingService).MethodA("Do something new and fancy");

    }

}

​

public interface IServiceA

{

    void DoWork();

}

​

public class ServiceA : IServiceA

{

    public ServiceA() { }

    public void DoWork() { Console.WriteLine("I am your legacy!"); }

}

​

public interface IServiceB

{

    void DoWork();

}

​

public class WhateverServiceB : IServiceB

{

    public WhateverServiceB() { }

    public void DoWork() { Console.WriteLine("Whatever..."); }

}

​

public interface IRoutingService

{

    void MethodA(string code);

}

​

public class RoutingService : IRoutingService, IServiceA

{

    private readonly IServiceA _serviceA;

    private readonly IServiceB _serviceB;

​

    public RoutingService([Named("legacy")] IServiceA serviceA, IServiceB serviceB)

    {

        this._serviceA = serviceA;

        this._serviceB = serviceB;

    }

    public void MethodA(string code)

    {

        if (code.StartsWith('Z'))

        {

            this._serviceA.DoWork();

        }

        else

        {

            this._serviceB.DoWork();

        }

    }

    public void DoWork() { Console.WriteLine("I don't know what I'm supposed to do :/"); }

}