NinjectでIKernelをプロパティとして注入

Question

私は抽象として共通ライブラリの依存関係リゾルバインタフェースを使用します。これにより、コンテナの切り替えに柔軟に対応できます。以下のインターフェースと静的IoCクラスを考えると、グローバルなasaxからIKernelを渡していない工場でIoCを初期化する必要があります。

Ninjectカーネルを作成するには、NinjectHttpApplicationベースをどのように使用しているのですか。

ここに問題があります。 CtsDependencyFactoryのIKernelプロパティは常にnullです。

Ninjectはこのように自分自身を挿入しませんか？別の方法を使用してIKernelを工場に渡す必要がありますか？私はのような静的なクラスをNinjectのStructureMapに見つけることができませんでした。

何か助けていただければ幸いです。あなたは正しくNInject（またはそのことについては、DIコンテナ）を使用していない

public interface IResolveDependency 
{ 
    T Resolve<T>(); 
    T Resolve<T>(params object[] parameters); 
    T Resolve<T>(string name); 
    T Resolve<T>(string name, params object[] parameters); 
    object Resolve(Type type); 
    IEnumerable<T> ResolveAll<T>(); 
    void Clear(); 
} 

public interface IResolveDependencyFactory 
{ 
    IResolveDependency CreateInstance(); 
} 

public class CtsDependencyResolver : IResolveDependency 
{ 
    private readonly IKernel m_kernel; 

    public CtsDependencyResolver(IKernel kernel) 
    { 
     m_kernel = kernel; 
    } 

    #region Implementation of IResolveDependency 

    // removed for brevity 

    #endregion 
} 

public class CtsDependencyFactory : IResolveDependencyFactory 
{ 
    [Inject] 
    public IKernel Kernel { get; set; } 

    #region Implementation of IResolveDependencyFactory 

    public IResolveDependency CreateInstance() 
    { 
     return new CtsDependencyResolver(Kernel); 
    } 

    #endregion 
} 

public static class IoC 
{ 
public static IResolveDependency DependencyResolver { get; private set; } 

public static void InitilizeWith(IResolveDependencyFactory factory) 
{ 
    DependencyResolver = factory.CreateInstance(); 
} 

public static void Register<T>(T instance) 
{ 
    if (DependencyResolver is IRegisterDependency) 
     ((IRegisterDependency)DependencyResolver).Register(instance); 
    else 
     throw new InvalidOperationException("cannot register service"); 
} 

public static T Resolve<T>(string name) 
{ 
    return DependencyResolver.Resolve<T>(name); 
} 

public static T Resolve<T>(string name, params object[] parameters) 
{ 
    return DependencyResolver.Resolve<T>(name, parameters); 
} 

public static T Resolve<T>() 
{ 
    return DependencyResolver.Resolve<T>(); 
} 

public static T Resolve<T>(params object[] parameters) 
{ 
    return DependencyResolver.Resolve<T>(parameters); 
} 

public static object Resolve(Type type) 
{ 
    return DependencyResolver.Resolve(type); 
} 

public static IEnumerable<T> ResolveAll<T>() 
{ 
    return DependencyResolver.ResolveAll<T>(); 
} 

public static void Clear() 
{ 
    DependencyResolver.Clear(); 
} 
} 

public class MvcApplication : NinjectHttpApplication 
{ 
    private IKernel m_kernel; 

    // removed stuff 

    protected override void OnApplicationStarted() 
    { 
     AreaRegistration.RegisterAllAreas(); 

     RegisterGlobalFilters(GlobalFilters.Filters); 
     RegisterRoutes(RouteTable.Routes); 

     IoC.InitilizeWith(new CtsDependencyFactory()); 
    } 

    protected override IKernel CreateKernel() 
    { 
     var modules = new INinjectModule[] 
          { 
           new FormHandlerModule() 
          }; 

     m_kernel = new StandardKernel(modules); 

     return m_kernel; 
    } 
} 

おかげ

Answer 1

。あなたがしているのは、あなたが必要とする依存関係を解決するという問題を解決しているように見えるサービスロケータを使用することですが、単純に隠しているだけです。 RRRに従うと、クラスが必要とする依存関係を解決する負担をコンテナが処理できるようになります。

Why is using a service locator an anti-pattern?

最後に、手動で効果的依存関係をあざけるのすべてのチャンスを削除している依存関係を解決することによって。それがあなたのために問題であるかどうか、誰が知っていますか。これは、コンストラクタインジェクションを使用して解決されます。

スワッピングコンテナに関する問題については、問題ごとに複数のコンテナを使用していない限り（大きな問題はない）、プロジェクトのルートコンポーネントを解決してコンテナを引き継ぐだけですみます。いったんすべてが言われて、あなたのコードはコンテナが存在することを知らないはずです。

Mark SeemannがDependency Injection in .NETを読むことをお勧めします。