c# - 为什么在ninject中使用.ToSelf()背后的主要逻辑是什么

我正在Ninject上工作，因为我从“ Warrior Module”类中的以下代码中提出了一个问题
        我们已经与可理解的类绑定了接口，但是为什么我们对SWORD类使用.ToSelf（）
        我做了谷歌，但我不能得到确切的逻辑。.如果我删除该行怎么办

Bind<Sword>().ToSelf();

以下代码

//interface
        interface IWeapon
        {
            void Hit(string target);
        }
        //sword class
        class Sword : IWeapon
        {
            public void Hit(string target)
            {
                Console.WriteLine("Killed {0} using Sword", target);
            }
        }

         class Soldier
        {
            private IWeapon _weapon;
            [Inject]
            public Soldier(IWeapon weapon)
            {
                _weapon = weapon;
            }
            public void Attack(string target)
            {
                _weapon.Hit(target);
            }
        }

         class WarriorModule : NinjectModule
        {
            public override void Load()
            {
                Bind<IWeapon>().To<Sword>();

                Bind<Sword>().ToSelf();//why we use .Toself() with self
            }
        }

        static void Main(string[] args)
        {
            IKernel kernel = new StandardKernel(new WarriorModule());

            Soldier warrior = kernel.Get<Soldier>();

            warrior.Attack("the men");

            Console.ReadKey();
        }

最佳答案

Ninject允许解析"self-bindable"类型，即使它们没有显式绑定。

然后默认为

Bind<Foo>().ToSelf()
    .InTransientScope();

注意：


ToSelf()绑定等效于Bind<Foo>().To<Foo>()。
如果不指定范围，则默认为InTransientScope()。因此，当您编写Bind<Foo>().ToSelf();时，它也等效于Bind<Foo>().ToSelf().InTransientScope();


结论

总之，仅当您希望与默认类型不同时，才需要为可自绑定类型编写一个绑定，例如：

Bind<Foo>().ToSelf()
    .InRequestScope();

要么

Bind<Foo>().ToSelf()
    .OnActivation(x => x.Initialize());

要么

Bind<Foo>().To<SpecialCaseFoo>();

我还认为在某个时候存在（或仍然有）停用“自绑定”自动绑定行为的选项，在这种情况下，Bind<Foo>().ToSelf()也是有意义的。