“绑定”在 DI 模式的上下文中是什么意思？

Question

What does the binding mean in the context of the DI pattern?

I am going through the IoC tutorial over here . And I come across the following excerpt:

Dependency Injection (DI) is a design pattern used to implement IoC. It allows the creation of dependent objects outside of a class and provides those objects to a class through different ways. Using DI, we move the creation and binding of the dependent objects outside of the class that depends on them.

I can not understand what binding is referred to here?

I guess that the binding referred to here is about setting the client class field. But in such a case we are not moving such a binding with the DI. Because, there are three ways to use the DI: constructor, property (setter) and method. And all of those ways do not move the binding (the assignment of the client class field) outside of the class, all of them happen in the scope of the client class. So, I am confused here.

UPDATE After a few answers were provided to the question I come to a conclusion that there are two possible definitions of what a binding is.

1 Binding means mapping an interface which is used inside the dependent classes to an actual object type.

2 Binding means passing an actual type as an argument for an interface parameter into the dependent classes.

What is the correct definition 1 or 2 ? Or does the definition of the binding depend on the context where the binding is mentioned?

Answer 1

What binding means?

It means that our dependency classes will automatically be resolved by the IoC container.

For example:

We have IRepository interface and the Repository class .

If we bind those two together. Every time we request the IRepository , our container automatically provides us with the Repository class.

This makes it very easy to alter the implementation of the Repository class. Since we are not immediately dependent on it . We never say new Repository class. We only provide the interface and everything else is taken care of by the container. You could for example say the IRepository is bound to the DatabaseRepository class. With only changing your container bindings and nothing else.

This all happens due to the binding in the IoC container. This provides a lot of flexibility inside your application.

Also what we can do with the binding command in our container can provide lifetimes for our objects usually those three(Singleton, PerInstance, Scoped).

Answer 2

The class can be made unaware of the actual classes that get injected into it.

It can rely on interface, instead of classes, where the logic of which class to instantiate in order to "fulfill" each interface can be delegated to code external to the classes themselves (or configuration).

So we can say that the action of injecting a class where an interface is expected is like "binding".

Answer 3

You can write code without Dependency injection like that:

class NoDiRadio
{
    public EnergizerBattery Battery { get; set; }

    public NoDiRadio()
    {
        Battery = new EnergizerBattery(); // creation and binding inside of NoDiRadio
    }
}

class EnergizerBattery
{
    public void Start()
    {
    }        
}

However, you can write more loosely coupled code and more testable code like this:

class DiRadio
{
    public IBattery Battery { get; set; }

    public DiRadio(IBattery battery)
    {
        Battery = battery;
    }
}

interface IBattery
{
    void Start();
}

class EnergizerBattery : IBattery
{
    public void Start()
    {
    }        
}

and then we move the creation and binding of the dependent objects outside of the class that depends on them .

IBattery battery = new DuracellBattery(); // creation and **binding** to IBattery here
var diRadio = new DiRadio(battery);

UPDATE:

Binding in IoC-container means, when we see IBattery , then our IoC container will resolve an instance of DuracellBattery and inject it. This is an example of Ninject Bind method:

Bind<IBattery>().To<DuracellBattery>()