Generic Strategy Selector

//http://www.codedomain.de

using System;
using System.Collections.Generic;

namespace StrategySelector {
   public enum InstanceType {
      Singelton,
      Instance
   }

   public class StrategySelector<T> {
      private readonly Dictionary<Enum, InstanceType> _instanceControl = new Dictionary<Enum, InstanceType>();
      private readonly Dictionary<Enum, T> _singeltonControl = new Dictionary<Enum, T>();
      private readonly Dictionary<Enum, Type> _typeControl = new Dictionary<Enum, Type>();

      public bool RegisterStrategy(Enum value, Type strategy, InstanceType instanceType) {
         if (_instanceControl.ContainsKey(value)) {
            return false;
         }
         _instanceControl[value] = instanceType;
         _typeControl[value] = strategy;
         return true;
      }

      public T SelectStrategy(Enum value) {
         if (!_instanceControl.ContainsKey(value)) {
            throw new Exception("Strategy not available");
         }
         if (_instanceControl[value] == InstanceType.Instance) {
            return (T) Activator.CreateInstance(_typeControl[value]);
         }
         if (_singeltonControl.ContainsKey(value)) {
            return _singeltonControl[value];
         }
         lock (_instanceControl) {
            if (!_singeltonControl.ContainsKey(value)) {
               _singeltonControl[value] = (T) Activator.CreateInstance(_typeControl[value]);
            }
         }
         return _singeltonControl[value];
      }
   }
}

// here the an usage example

using System;
using StrategySelector;

namespace ConsoleStrategy {
   internal interface IStrategy {
      void DoSomething();
   }

   internal class MyStrategy1 : IStrategy {
      public void DoSomething() {
         Console.WriteLine("Strategy1");
      }
   }

   internal class MyStrategy2 : IStrategy {
      public void DoSomething() {
         Console.WriteLine("Strategy2");
      }
   }

   internal class Program {

      public enum Strategies {
         Strategy1,
         Strategy2
      };

      private static void Main(string[] args) {
         var strategySelector = new StrategySelector<IStrategy>();
         strategySelector.RegisterStrategy(Strategies.Strategy1, typeof (MyStrategy1), InstanceType.Instance);
         strategySelector.RegisterStrategy(Strategies.Strategy2, typeof (MyStrategy2), InstanceType.Singelton);
         strategySelector.SelectStrategy(Strategies.Strategy1).DoSomething();
         strategySelector.SelectStrategy(Strategies.Strategy2).DoSomething();
         strategySelector.SelectStrategy(Strategies.Strategy1).DoSomething();
         strategySelector.SelectStrategy(Strategies.Strategy2).DoSomething();
         System.Console.ReadLine();
      }
   }
}