Qu'est-ce que la fixation précoce et tardive ?

Question

Quelle est la différence entre une fixation précoce et une fixation tardive ?

Answer 1

La réponse courte est que la liaison précoce (ou statique) fait référence à la liaison au moment de la compilation et que la liaison tardive (ou dynamique) fait référence à la liaison au moment de l'exécution (par exemple lorsque vous utilisez la réflexion).

Answer 2

Dans les langages compilés, la différence est flagrante.

Java :

//early binding:
public create_a_foo(*args) {
 return new Foo(args)
}
my_foo = create_a_foo();

//late binding:
public create_something(Class klass, *args) {
  klass.new_instance(args)
}
my_foo = create_something(Foo);

Dans le premier exemple, le compilateur peut faire toutes sortes de choses intéressantes au moment de la compilation. Dans le second, il faut juste espérer que celui qui utilise la méthode le fasse de manière responsable. (Bien entendu, les JVM les plus récentes prennent en charge la fonction Class<? extends Foo> klass structure, ce qui peut réduire considérablement ce risque).

Un autre avantage est que les IDE peuvent établir un lien direct avec la définition de la classe, puisqu'elle est déclarée directement dans la méthode. L'appel à la création de quelque chose (Foo) pourrait être _très loin de la définition de la méthode, et si vous regardez la définition de la méthode, il pourrait être agréable de voir l'implémentation.

Le principal avantage de la liaison tardive est qu'elle facilite des choses comme l'inversion de contrôle, ainsi que certaines autres utilisations du polymorphisme et du duck-typing (si votre langage supporte ces choses).

Answer 3

Tiré directement de http://word.mvps.org/fAQs/InterDev/EarlyvsLateBinding.htm

Il existe deux façons d'utiliser l'automatisation (ou OLE Automation) pour contrôler une autre application de manière programmée.

La liaison tardive utilise CreateObject pour créer une instance de l'objet d'application que vous pouvez ensuite contrôler. objet d'application, que vous pouvez ensuite contrôler. Par exemple, pour créer une nouvelle instance d'Excel en utilisant la liaison tardive :

 Dim oXL As Object
 Set oXL = CreateObject("Excel.Application")

D'autre part, pour manipuler une instance existante d'Excel (si Excel est déjà ouvert), vous devez utiliser GetObject (que vous utilisiez que vous utilisiez la liaison précoce ou tardive) :

 Dim oXL As Object
 Set oXL = GetObject(, "Excel.Application")

Pour utiliser la liaison anticipée, vous devez tout d'abord définir une référence dans votre projet à l'application que vous souhaitez manipuler. Dans l'éditeur VB de n'importe quelle application Office, ou dans VB lui-même, vous pouvez le faire en sélectionnant Outils + Références, puis en sélectionnant l'application souhaitée dans la liste (par ex. (par exemple, "Microsoft Excel 8.0 Object Library").

Pour créer une nouvelle instance d'Excel en utilisant la liaison anticipée :

 Dim oXL As Excel.Application
 Set oXL = New Excel.Application

Dans les deux cas, d'ailleurs, vous pouvez d'abord essayer d'obtenir une instance existante d'Excel. existante d'Excel, et si cela renvoie une erreur, vous pouvez créer une nouvelle instance de instance dans votre gestionnaire d'erreur.

Answer 4

Dans les langues interprétées, la différence est un peu plus subtile.

Ruby :

# early binding:
def create_a_foo(*args)
  Foo.new(*args)
end
my_foo = create_a_foo

# late binding:
def create_something(klass, *args)
  klass.new(*args)
end
my_foo = create_something(Foo)

Comme Ruby n'est (généralement) pas compilé, il n'y a pas de compilateur pour effectuer les tâches préliminaires. La croissance de JRuby signifie que de plus en plus de Ruby est compilé de nos jours, ce qui le fait agir plus comme Java, ci-dessus.

Le problème des IDE est toujours d'actualité : une plate-forme comme Eclipse peut rechercher les définitions de classe si vous les codez en dur, mais ne le peut pas si vous les laissez à l'appelant.

L'inversion de contrôle n'est pas très populaire en Ruby, probablement en raison de son extrême souplesse d'exécution, mais Rails fait un excellent usage des liaisons tardives pour réduire la quantité de configuration nécessaire au démarrage de votre application.

Answer 5

De Injection de dépendances dans .NET par Mark Seemann :

[...] late binding refers to the ability to replace parts of an application without
recompiling the code. An application that enables third-party add-ins (such as
Visual Studio) is one example.

Another example is standard software that supports different runtime environments.
You may have an application that can run on more than one database engine:
for example, one that supports both Oracle and SQL Server. To support this feature,
the rest of the application can talk to the database through an interface. The code
base can provide different implementations of this interface to provide access to Oracle
and SQL Server, respectively. A configuration option can be used to control which
implementation should be used for a given installation.