C# 如何对通用接口使用依赖项注入？

如何对通用接口使用依赖项注入？我希望在DrawPresenter中创建IDrawView接口，它控制视图

我不知道该用什么，Ninject还是别的什么。我正在使用WinForms

选择哪个更好？

class Program
{
    static void Main(string[] args)
    {
        IDrawPresenter prisenter = new DrawPresenter(new DrawWindow());
        prisenter.Show();
        Console.ReadLine();
    }
}

public interface IView
{
    void Show();
}

public interface IDrawView : IView
{
    object GetGridDraw { get; }
}
public interface IPrisenter<TView> where TView : IView
{
    void Show();
}
public interface IDrawPresenter : IPrisenter<IDrawView>
{
    object SelectedDraws { get; }
}

public class DrawWindow : IDrawView
{
    public object GetGridDraw => 1;

    public void Show()
    {
        Console.WriteLine("Show Window");
    }
}

public abstract class BasePresenter<TView> : IPrisenter<TView>
where TView : IView
{
    protected BasePresenter(TView view)
    {
        View = view;
    }
    protected TView View { get; private set; }
    public void Show()
    {
        View.Show();
    }
}

public class DrawPresenter : BasePresenter<IDrawView>, IDrawPresenter
{
    public DrawPresenter(IDrawView view): base(view)
    {
    }
    public object SelectedDraws => View.GetGridDraw;
}

IDrawPresenter prisenter = new DrawPresenter();   
    public DrawPresenter()
    {
    }

演示者管理表单需要做什么。

public class NinjectProgram
{
    //Gets the inject kernal for the program.
    public static IKernel Kernel { get; protected set; }
}

public class DependencyModule : NinjectModule
{
    public override void Load()
    {
        Bind<IDrawView>().To<DrawWindow>();
    }
}

    static void Main(string[] args)
    {
        StandardKernel Kernel = new StandardKernel();
        Kernel.Load(new DependencyModule());

        IDrawPresenter prisenter = new DrawPresenter();
        prisenter.Show();
        Console.ReadLine();
    }

public abstract class BasePresenter<TView> : IPrisenter<TView>
where TView : IView
{
    protected BasePresenter()
    {
        View = NinjectProgram.Kernel.Get<TView>();
    }
    protected TView View { get; private set; }
    public void Show()
    {
        View.Show();
    }
}

        static void Main(string[] args)
        {
            CompositionRoot.Wire(new DependencyModule());

            IDrawPresenter prisenter = new DrawPresenter();//kernel.Get<IDrawPresenter>();
            prisenter.Show();
            Console.ReadLine();
        }

    public class CompositionRoot
    {
        private static IKernel _ninjectKernel;

        public static void Wire(INinjectModule module)
        {
            _ninjectKernel = new StandardKernel(module);
        }

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

    public class DependencyModule : NinjectModule
    {
        public override void Load()
        {
            Bind<IDrawView>().To<DrawWindow>();
        }
    }

    public abstract class BasePresenter<TView> : IPrisenter<TView>
    where TView : IView
    {
        protected BasePresenter()
        {
            View = CompositionRoot.Resolve<TView>();//NinjectProgram.Kernel.Get<TView>();
        }
        protected TView View { get; private set; }
}

这是我想要的。但这不起作用…

public class NinjectProgram
{
    //Gets the inject kernal for the program.
    public static IKernel Kernel { get; protected set; }
}

public class DependencyModule : NinjectModule
{
    public override void Load()
    {
        Bind<IDrawView>().To<DrawWindow>();
    }
}

    static void Main(string[] args)
    {
        StandardKernel Kernel = new StandardKernel();
        Kernel.Load(new DependencyModule());

        IDrawPresenter prisenter = new DrawPresenter();
        prisenter.Show();
        Console.ReadLine();
    }

public abstract class BasePresenter<TView> : IPrisenter<TView>
where TView : IView
{
    protected BasePresenter()
    {
        View = NinjectProgram.Kernel.Get<TView>();
    }
    protected TView View { get; private set; }
    public void Show()
    {
        View.Show();
    }
}

        static void Main(string[] args)
        {
            CompositionRoot.Wire(new DependencyModule());

            IDrawPresenter prisenter = new DrawPresenter();//kernel.Get<IDrawPresenter>();
            prisenter.Show();
            Console.ReadLine();
        }

    public class CompositionRoot
    {
        private static IKernel _ninjectKernel;

        public static void Wire(INinjectModule module)
        {
            _ninjectKernel = new StandardKernel(module);
        }

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

    public class DependencyModule : NinjectModule
    {
        public override void Load()
        {
            Bind<IDrawView>().To<DrawWindow>();
        }
    }

    public abstract class BasePresenter<TView> : IPrisenter<TView>
    where TView : IView
    {
        protected BasePresenter()
        {
            View = CompositionRoot.Resolve<TView>();//NinjectProgram.Kernel.Get<TView>();
        }
        protected TView View { get; private set; }
}

公共类程序
{
//获取程序的注入内核。
公共静态IKernel内核{get；protected set；}
}
公共类DependencyModule:NinjectModule
{
公共覆盖无效负载（）
{
绑定（）到（）；
}
}
静态void Main（字符串[]参数）
{
StandardKernel内核=新的StandardKernel（）；
Load（新的DependencyModule（））；
IDrawPresenter pricenter=新的DrawPresenter（）；
pricenter.Show（）；
Console.ReadLine（）；
}
公共抽象类BasePresenter:IPRICenter
TView:IView在哪里
{
受保护的BasePresenter（）
{
View=NinjectProgram.Kernel.Get（）；
}
受保护的TView视图{get；private set；}
公开展览（
{
View.Show（）；
}
}

还将演示者包括在容器中并解决它

public class DependencyModule : NinjectModule {
    public override void Load() {
        Bind<IDrawView>().To<DrawWindow>();
        Bind<IDrawPresenter>().To<DrawPresenter>();
    }
}

公共类依赖模块：ninject模块{
公共覆盖无效负载（）{
绑定（）到（）；
绑定（）到（）；
}
}

其所有依赖项（如果已注册）也将被解析并注入演示者

static void Main(string[] args) {
    var kernel = new StandardKernel();
    kernel.Load(new DependencyModule());

    IDrawPresenter presenter= kernel.Get<IDrawPresenter>();
    presenter.Show();
    Console.ReadLine();
}

static void Main（字符串[]args）{
var kernel=新的标准内核（）；
Load（新的DependencyModule（））；
IDrawPresenter=kernel.Get（）；
Show（）；
Console.ReadLine（）；
}

以上是基于

public abstract class BasePresenter<TView> : IPrisenter<TView> where TView : IView {
    protected BasePresenter(TView view) {
        View = view;
    }
    protected TView View { get; private set; }
    public void Show() {
        View.Show();
    }
}

public class DrawPresenter : BasePresenter<IDrawView>, IDrawPresenter {
    public DrawPresenter(IDrawView view): base(view) {
    }
    public object SelectedDraws => View.GetGridDraw;
}

公共抽象类BasePresenter:IPrisenter其中TView:IView{
受保护的BasePresenter（TView视图）{
视图=视图；
}
受保护的TView视图{get；private set；}
公开展览（{
View.Show（）；
}
}
公共类DrawPresenter:BasePresenter、IDrawPresenter{
公共DrawPresenter（IDrawView视图）：基础（视图）{
}
公共对象SelectedDraws=>View.GetGridDraw；
}

谢谢大家，这就是我想做的。也许这会对将来的人有所帮助。

public class NinjectProgram
{
    //Gets the inject kernal for the program.
    public static IKernel Kernel { get; protected set; }
}

public class DependencyModule : NinjectModule
{
    public override void Load()
    {
        Bind<IDrawView>().To<DrawWindow>();
    }
}

    static void Main(string[] args)
    {
        StandardKernel Kernel = new StandardKernel();
        Kernel.Load(new DependencyModule());

        IDrawPresenter prisenter = new DrawPresenter();
        prisenter.Show();
        Console.ReadLine();
    }

public abstract class BasePresenter<TView> : IPrisenter<TView>
where TView : IView
{
    protected BasePresenter()
    {
        View = NinjectProgram.Kernel.Get<TView>();
    }
    protected TView View { get; private set; }
    public void Show()
    {
        View.Show();
    }
}

        static void Main(string[] args)
        {
            CompositionRoot.Wire(new DependencyModule());

            IDrawPresenter prisenter = new DrawPresenter();//kernel.Get<IDrawPresenter>();
            prisenter.Show();
            Console.ReadLine();
        }

    public class CompositionRoot
    {
        private static IKernel _ninjectKernel;

        public static void Wire(INinjectModule module)
        {
            _ninjectKernel = new StandardKernel(module);
        }

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

    public class DependencyModule : NinjectModule
    {
        public override void Load()
        {
            Bind<IDrawView>().To<DrawWindow>();
        }
    }

    public abstract class BasePresenter<TView> : IPrisenter<TView>
    where TView : IView
    {
        protected BasePresenter()
        {
            View = CompositionRoot.Resolve<TView>();//NinjectProgram.Kernel.Get<TView>();
        }
        protected TView View { get; private set; }
}

static void Main（字符串[]args）
{
CompositionRoot.Wire（新的DependencyModule（））；
IDrawPresenter pricenter=new-DrawPresenter（）；//kernel.Get（）；
pricenter.Show（）；
Console.ReadLine（）；
}
公共类复合根
{
私有静态IKernel Ninject内核；
公共静电空心线（INinjectModule）
{
_Ninject内核=新的标准内核（模块）；
}
公共静态T解析（）
{
返回_ninjectKernel.Get（）；
}
}
公共类DependencyModule:NinjectModule
{
公共覆盖无效负载（）
{
绑定（）到（）；
}
}
公共抽象类BasePresenter:IPRICenter
TView:IView在哪里
{
受保护的BasePresenter（）
{
View=CompositionRoot.Resolve（）；//NinjectProgram.Kernel.Get（）；
}
受保护的TView视图{get；private set；}
}

依赖项注入是一种模式。它不需要任何DI容器。DI容器只会让开发人员的生活更轻松。不管怎样，我不清楚你的问题是关于什么的。你的问题是什么？您是想向您推荐DI容器吗？这类问题与StackOverflow无关。我使用接口，无法从接口创建对象。但我使用泛化，理论上，如果我使用依赖项注入，我可以在Presenter.DI中创建一个对象。我无法创建您无法手动创建的对象。那么，如果没有DI，您的

DrawPresenter（）

会是什么样子呢？