Xtykutl

I currently working on an application that will act differently based on userInput. So I think about the Strategy Pattern. Below is my implementation:

I have some business logic:

interface IBusinessLogic

{

   void DoBusinessLogic();

}



class TypeABusinessLogic : IBusinessLogic

{

   public void DoBusinessLogic()

   {

      Console.WriteLine("Do Business Logic for Type A");

   }

 } 



class TypeBBusinessLogic : IBusinessLogic

{

   public void DoBusinessLogic()

   {

      Console.WriteLine("Do Business Logic for Type B");

   }

}  

And, also some application logic:

interface IApplicationLogic

{

   void DoApplicationLogic();

}



class TypeAApplicationLogic : IApplicationLogic

{

   public void DoApplicationLogic()

   {

      Console.WriteLine("Do Application Logic for Type A");

   }

 } 



class TypeBApplicationLogic : IApplicationLogic

{

   public void DoApplicationLogic()

   {

      Console.WriteLine("Do Application Logic for Type B");

   }

}    

Now, my strategies need to do both business logic and application logic

interface IStrategy

{

   void DoWork();

}



abstract class StrategyBase : IStrategy

{

   private IBusinessLogic _businessLogic;

   private IApplicationLogic _applicationLogic;



   protected StrategyBase(IBusinessLogic businessLogic, IApplicationLogic applicationLogic)

   {

      _businessLogic = businessLogic;

      _applicationLogic = applicationLogic;

   }



   public void DoWork()

   {

      _businessLogic.DoBusinessLogic();

      _applicationLogic.DoApplicationLogic();

   }

}



class TypeAStrategy : IStrategy

{

   public TypeAStrategy(TypeABussinessLogic businessLogic, TypeAApplicationLogic applicationLogic) : base(businessLogic, applicationLogic)

   {}

}



class TypeBStrategy : IStrategy

{

   public TypeBStrategy(TypeBBussinessLogic businessLogic, TypeBApplicationLogic applicationLogic) : base(businessLogic, applicationLogic)

   {}

}

Now is my Context class

class Context

{

   private Func<string, IStrategy> _strategyFactory;

   public Context(Func<string, IStrategy> strategyFactory)

   {

      _strategyFactory = strategyFactory;

   } 

   public void Run()

   {

      string userInput = GetUserInput(); //"TypeA" or "TypeB"

      IStrategy strategy = _strategyFactory(userInput);

      strategy.DoWork();

   }

}

Here is my DI builder code:

var builder = new ContainerBuilder();

builder.RegisterType<TypeAStrategy>().As<IStrategy>().Keyed<IStrategy>("TypeA");

var builder = new ContainerBuilder();

builder.RegisterType<TypeBStrategy>().As<IStrategy>().Keyed<IStrategy>("TypeB");

builder.Register<Func<string, IStrategy>>( c => 

{

   var componentContext = c.Resolve<IComponentContext>();

   return (key) =>

   {

       IStrategy stategy = componentContext.ResolveKeyed<IStrategy >(key);

       return stategy;

   };

});

The problem I can see here is my strategies (TypeAStrategy, TypeBStrategy) depend directly on concrete class (TypeABusinessLogic,TypeAApplicationLogic,TypeBBusinessLogic, TypeBApplicationLogic), which is not good. I can't mock these dependencies in unit test.

If I let my strategies depend on interfaces, I dont know how to implement DI container to resolve dependencies (Notes: I currently using Autofac, but I can use any other DI containers )

Please advise.

So I thought of a few ways to approach this, but I think the cleanest way is to just introduce some token interfaces. A token interface is one which doesn't add any properties or functionality. For instance:

interface IBusinessLogic

{

    void DoBusinessLogic();

}

interface ITypeABusinessLogic : IBusinessLogic { }

interface ITypeBBusinessLogic : IBusinessLogic { }



interface IApplicationLogic

{

    void DoApplicationLogic();

}

interface ITypeAApplicationLogic : IApplicationLogic { }

interface ITypeBApplicationLogic : IApplicationLogic { }

Next we adjust the classes to implement the relevant token interface:

class TypeABusinessLogic : ITypeABusinessLogic

{

    public virtual void DoBusinessLogic()

    {

        Console.WriteLine("Do Business Logic for Type A");

    }

}



class TypeBBusinessLogic : ITypeBBusinessLogic

{

    public virtual void DoBusinessLogic()

    {

        Console.WriteLine("Do Business Logic for Type B");

    }

}



class TypeAApplicationLogic : ITypeAApplicationLogic

{

    public void DoApplicationLogic()

    {

        Console.WriteLine("Do Application Logic for Type A");

    }

}



class TypeBApplicationLogic : ITypeBApplicationLogic

{

    public void DoApplicationLogic()

    {

        Console.WriteLine("Do Application Logic for Type B");

    }

}

We can similarly create mock classes by implementing the relevant token interface:

class MockTypeABusinessLogic : ITypeABusinessLogic

{

    public void DoBusinessLogic()

    {

        Console.WriteLine("[Mock] Do Business Logic for Type A");

    }

}



class MockTypeBBusinessLogic : ITypeBBusinessLogic

{

    public void DoBusinessLogic()

    {

        Console.WriteLine("[Mock] Do Business Logic for Type B");

    }

}



class MockTypeAApplicationLogic : ITypeAApplicationLogic

{

    public void DoApplicationLogic()

    {

        Console.WriteLine("[Mock] Do Application Logic for Type A");

    }

}



class MockTypeBApplicationLogic : ITypeBApplicationLogic

{

    public void DoApplicationLogic()

    {

        Console.WriteLine("[Mock] Do Application Logic for Type B");

    }

}

I also modified the IStrategy interface to make injection with Unity a little easier, giving each strategy a Name property (you don't need to do this):

interface IStrategy

{

    string Name { get;  }

    void DoWork();

}



abstract class StrategyBase : IStrategy

{

    private IBusinessLogic _businessLogic;

    private IApplicationLogic _applicationLogic;



    public string Name { get; private set; }



    protected StrategyBase(String name, IBusinessLogic businessLogic, IApplicationLogic applicationLogic)

    {

        this.Name = name;

        _businessLogic = businessLogic;

        _applicationLogic = applicationLogic;

    }



    public void DoWork()

    {

        _businessLogic.DoBusinessLogic();

        _applicationLogic.DoApplicationLogic();

    }

}    



class TypeAStrategy : StrategyBase

{

    public TypeAStrategy(String name, ITypeABusinessLogic businessLogic, ITypeAApplicationLogic applicationLogic) : base(name, businessLogic, applicationLogic)

    { }

}



class TypeBStrategy : StrategyBase

{

    public TypeBStrategy(String name, ITypeBBusinessLogic businessLogic, ITypeBApplicationLogic applicationLogic) : base(name, businessLogic, applicationLogic)

    { }

}

Using Unity I wrote the following program to test the registrations:

class Context

{

    private Dictionary<string, IStrategy> _strategyFactory = new Dictionary<string, IStrategy>();

    public Context(IStrategy strategies)

    {

        foreach (var s in strategies)

        {

            _strategyFactory.Add(s.Name, s);

        }

    }

    public void Run()

    {

        string userInput = "TypeA";

        IStrategy strategy = _strategyFactory[userInput];

        strategy.DoWork();



        userInput = "TypeB";

        strategy = _strategyFactory[userInput];

        strategy.DoWork();

    }

}



class Program

{

    static void Main(string args)

    {

        Console.WriteLine("Mock DI Example: ");

        UnityContainer ioc = new UnityContainer();



        ioc.RegisterType<ITypeABusinessLogic, MockTypeABusinessLogic>();

        ioc.RegisterType<ITypeAApplicationLogic, MockTypeAApplicationLogic>();

        ioc.RegisterType<ITypeBBusinessLogic, MockTypeBBusinessLogic>();

        ioc.RegisterType<ITypeBApplicationLogic, MockTypeBApplicationLogic>();

        ioc.RegisterType<IStrategy, TypeAStrategy>("TypeA", new InjectionConstructor("TypeA", typeof(ITypeABusinessLogic), typeof(ITypeAApplicationLogic)));

        ioc.RegisterType<IStrategy, TypeBStrategy>("TypeB", new InjectionConstructor("TypeB", typeof(ITypeBBusinessLogic), typeof(ITypeBApplicationLogic)));



        Context c = ioc.Resolve<Context>();

        c.Run();



        Console.WriteLine("nUnmocked DI Example: ");



        ioc = new UnityContainer();



        ioc.RegisterType<ITypeABusinessLogic, TypeABusinessLogic>();

        ioc.RegisterType<ITypeAApplicationLogic, TypeAApplicationLogic>();

        ioc.RegisterType<ITypeBBusinessLogic, TypeBBusinessLogic>();

        ioc.RegisterType<ITypeBApplicationLogic, TypeBApplicationLogic>();

        ioc.RegisterType<IStrategy, TypeAStrategy>("TypeA", new InjectionConstructor("TypeA", typeof(ITypeABusinessLogic), typeof(ITypeAApplicationLogic)));

        ioc.RegisterType<IStrategy, TypeBStrategy>("TypeB", new InjectionConstructor("TypeB", typeof(ITypeBBusinessLogic), typeof(ITypeBApplicationLogic)));



        c = ioc.Resolve<Context>();

        c.Run();



        Console.WriteLine("nPress enter to exit...");

        Console.ReadLine();

    }

And here was my output:

Mock DI Example:

[Mock] Do Business Logic for Type A

[Mock] Do Application Logic for Type A

[Mock] Do Business Logic for Type B

[Mock] Do Application Logic for Type B

Unmocked DI Example:

Do Business Logic for Type A

Do Application Logic for Type A

Do Business Logic for Type B

Do Application Logic for Type B

Press enter to exit...

This isn't the only way to solve the problem, but I think this most directly matches how you have structured your code in the OP. Hope this helps :)

EDIT: Here is one alternative to the above which I think you should consider. It will cut down on your object and interface hierarchy quite a bit. NOTE: you'll need to make the StrategyBase class not abstract, and expose the constructor as public.

        Console.WriteLine("nAlternative DI Example: ");



        ioc = new UnityContainer();



        ioc.RegisterType<IBusinessLogic, TypeABusinessLogic>("TypeA");

        ioc.RegisterType<IApplicationLogic, TypeAApplicationLogic>("TypeA");

        ioc.RegisterType<IStrategy, StrategyBase>("TypeA", new InjectionConstructor("TypeA", new ResolvedParameter<IBusinessLogic>("TypeA"), new ResolvedParameter<IApplicationLogic>("TypeA") ));

        ioc.RegisterType<IBusinessLogic, TypeBBusinessLogic>("TypeB");

        ioc.RegisterType<IApplicationLogic, TypeBApplicationLogic>("TypeB");

        ioc.RegisterType<IStrategy, StrategyBase>("TypeB", new InjectionConstructor("TypeB", new ResolvedParameter<IBusinessLogic>("TypeB"), new ResolvedParameter<IApplicationLogic>("TypeB")));

        c = ioc.Resolve<Context>();

        c.Run();

Since your classes and the token interfaces don't actually provide you any functionality, they only serve as a means of differentiating the specific implementations. But DI containers already have a simple means of doing this: strings. In Unity you can use the same string for different types, like above. You can use this to delineate which specific implementations go together. This is my recommendation :)