Zawsze piszę opakowanie adaptera dla dowolnego kontenera IoC, który wygląda następująco:
public static class Ioc
{
public static IIocContainer Container { get; set; }
}
public interface IIocContainer
{
object Get(Type type);
T Get<T>();
T Get<T>(string name, string value);
void Inject(object item);
T TryGet<T>();
}
Konkretnie dla Ninject konkretna klasa adaptera wygląda następująco:
public class NinjectIocContainer : IIocContainer
{
public readonly IKernel Kernel;
public NinjectIocContainer(params INinjectModule[] modules)
{
Kernel = new StandardKernel(modules);
new AutoWirePropertyHeuristic(Kernel);
}
private NinjectIocContainer()
{
Kernel = new StandardKernel();
Kernel.Load(AppDomain.CurrentDomain.GetAssemblies());
new AutoWirePropertyHeuristic(Kernel);
}
public object Get(Type type)
{
try
{
return Kernel.Get(type);
}
catch (ActivationException exception)
{
throw new TypeNotResolvedException(exception);
}
}
public T TryGet<T>()
{
return Kernel.TryGet<T>();
}
public T Get<T>()
{
try
{
return Kernel.Get<T>();
}
catch (ActivationException exception)
{
throw new TypeNotResolvedException(exception);
}
}
public T Get<T>(string name, string value)
{
var result = Kernel.TryGet<T>(metadata => metadata.Has(name) &&
(string.Equals(metadata.Get<string>(name), value,
StringComparison.InvariantCultureIgnoreCase)));
if (Equals(result, default(T))) throw new TypeNotResolvedException(null);
return result;
}
public void Inject(object item)
{
Kernel.Inject(item);
}
}
Głównym powodem tego jest wyodrębnienie frameworka IoC, dzięki czemu mogę go zastąpić w dowolnym momencie - biorąc pod uwagę, że różnica między frameworkami jest zasadniczo w konfiguracji, a nie w użyciu.
Ale jako bonus, rzeczy stają się o wiele łatwiejsze w korzystaniu z frameworka IoC wewnątrz innych frameworków, które nie obsługują go od razu. Na przykład w przypadku WinForms są to dwa kroki:
W metodzie Main po prostu utwórz instancję kontenera, zanim zrobisz cokolwiek innego.
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>
[STAThread]
static void Main()
{
try
{
Ioc.Container = new NinjectIocContainer( /* include modules here */ );
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MyStartupForm());
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
A potem mają podstawową Formę, z której wywodzą się inne formy, która sama wywołuje Inject.
public IocForm : Form
{
public IocForm() : base()
{
Ioc.Container.Inject(this);
}
}
To mówi heurystyce automatycznego okablowania, aby spróbowała rekurencyjnie wstrzyknąć wszystkie właściwości w formie zgodnej z regułami ustawionymi w modułach.