Encadernação tardia

Da Wikipédia, a enciclopédia livre
Ir para a navegação Saltar para pesquisar

Late binding ou dynamic linkage [1] - embora não seja um processo idêntico ao de vincular dinamicamente bibliotecas de código importadas - é um mecanismo de programação de computador no qual o método que está sendo chamado em um objeto, ou a função que está sendo chamada com argumentos, é consultado pelo nome em tempo de execução . Em outras palavras, um nome é associado a uma operação ou objeto específico em tempo de execução, e não durante a compilação. O nome vinculação dinâmica é usado algumas vezes, [2] mas é mais comumente usado para se referir ao escopo dinâmico .

Com early binding , ou static binding , em uma linguagem orientada a objetos , a fase de compilação corrige todos os tipos de variáveis ​​e expressões. Isso geralmente é armazenado no programa compilado como um deslocamento em uma tabela de método virtual ("tabela v"). [3] Em contraste, com a vinculação tardia, o compilador não lê informações suficientes para verificar se o método existe ou vincula seu slot na tabela v. Em vez disso, o método é pesquisado pelo nome em tempo de execução.

A principal vantagem de usar a associação tardia na programação COM ( Component Object Model ) é que ela não exige que o compilador faça referência às bibliotecas que contêm o objeto em tempo de compilação . Isso torna o processo de compilação mais resistente a conflitos de versão, nos quais a v-table da classe pode ser modificada acidentalmente. (Isso não é uma preocupação em plataformas compiladas por compilação just-in-time , como .NET ou Java, porque a v-table é criada em tempo de execução pela máquina virtual em relação às bibliotecas enquanto elas estão sendo carregadas no aplicativo em execução. [ 4] )

História

O termo "tarde binding" remonta pelo menos à década de 1960, onde pode ser encontrado nas Comunicações da ACM . O termo foi amplamente usado para descrever convenções de chamada em linguagens como Lisp, embora geralmente com conotações negativas sobre desempenho. [5]

Na década de 1980 , o Smalltalk popularizou a programação orientada a objetos (OOP) e com ela a ligação tardia. Alan Kay disse uma vez: "OOP para mim significa apenas mensagens, retenção local, proteção e ocultação do processo de estado e vinculação tardia extrema de todas as coisas. Isso pode ser feito em Smalltalk e em LISP. Possivelmente existem outros sistemas em que isso é possível, mas eu não estou ciente deles." [6]

No início e meados da década de 1990, a Microsoft promoveu fortemente seu padrão COM como uma interface binária entre diferentes linguagens de programação OOP. A programação COM promoveu igualmente a vinculação inicial e tardia, com muitas linguagens suportando ambas no nível da sintaxe.

Em 2000, Alex Martelli cunhou o termo " Dick Typing " para se referir a um conceito semelhante, mas com uma ênfase diferente. Enquanto a ligação tardia geralmente se concentra nos detalhes da implementação, a tipagem de pato se concentra na capacidade de ignorar tipos e se concentrar nos métodos que um objeto possui atualmente.

Implementações de vinculação tardia

Ligação tardia em linguagens orientadas a objetos tipadas dinamicamente

Na maioria das linguagens tipadas dinamicamente , a lista de métodos em um objeto pode ser alterada em tempo de execução. Isso requer ligação tardia.

Ligação tardia em Lisp

Em Lisp , as chamadas de função global de ligação tardia são pesquisadas com eficiência em tempo de execução por meio de uma célula de função de um símbolo . Essas associações de função são mutáveis.

Exemplo usando uma sessão interativa do Clozure Common Lisp :

?  ( defun  foo  () 
    ( bar  pi ))    ; uma função BAR ainda indefinida é chamada 
;Avisos do compilador: 
; Em FOO: função indefinida BAR 
FOO

?  ( defun  bar  ( x )    ; agora definimos 
    ( *  x  2 )) 
BAR

?  ( foo )     ; chamando foo e usa a definição recente de BAR 
6.283185307179586D0

?  ( defun  bar  ( x )    ; agora redefinimos BAR 
    ( *  x  1000 )) 
BAR

?  ( foo )     ; FOO agora chama a nova função, não há necessidade de recompilar/vincular/carregar FOO 
3141.592653589793D0

?  ( tipo de  'barra )    ; BAR é um símbolo 
SÍMBOLO

?  ( símbolo-função  'barra )   ; o símbolo BAR tem uma ligação de função 
# <Barra de função compilada  # x302000D1B21F  >

Ligação tardia em C++

Em C++, a ligação tardia (também chamada de "ligação dinâmica") refere-se ao que normalmente acontece quando a virtualpalavra-chave é usada na declaração de um método. C++ cria então a chamada tabela virtual, que é uma tabela de consulta para tais funções que sempre serão consultadas quando forem chamadas. [7] Normalmente, o termo "vinculação tardia" é usado em favor de " expedição dinâmica ".

Ligação tardia em idiomas COM

Na programação COM, uma chamada de método de ligação tardia é executada usando a interface IDispatch . Algumas linguagens baseadas em COM, como o Visual Basic 6, têm suporte sintático para chamar essa interface. [8] Isso é feito definindo o tipo da variável como Object. Outros, como C++, exigem que você chame explicitamente GetIDsOfNames para pesquisar um método e Invoke para chamá-lo.

Ligação tardia em .NET

No .NET, a vinculação tardia refere-se à substituição de um virtualmétodo como C++ ou à implementação de uma interface. O compilador cria tabelas virtuais para cada chamada de método virtual ou de interface que é usada em tempo de execução para determinar a implementação a ser executada.

Assim como COM e Java, o Common Language Runtime fornece APIs de reflexão que podem fazer chamadas de ligação tardias. O uso dessas chamadas varia de acordo com o idioma.

Com o C# 4, a linguagem também adicionou o pseudotipo "dinâmico". Isso seria usado no lugar do tipo Object para indicar que a vinculação tardia é desejada. O mecanismo de ligação tardia específico necessário é determinado em tempo de execução usando o Dynamic Language Runtime como ponto de partida.

O Visual Basic os utiliza sempre que a variável for do tipo Object e a diretiva do compilador "Option Strict Off" estiver em vigor. Esta é a configuração padrão para um novo projeto VB. Antes da versão 9, somente objetos .NET e COM podiam ser vinculados tardiamente. Com o VB 10, isso foi estendido para objetos baseados em DLR.

Ligação tardia em Java

Existem três definições para ligação tardia em Java.

Os primeiros documentos sobre Java discutiam como as classes não eram vinculadas em tempo de compilação. Enquanto os tipos são verificados estaticamente em tempo de compilação, diferentes implementações para classes podem ser trocadas antes do tempo de execução simplesmente substituindo o arquivo de classe. Contanto que a nova definição de classe tivesse os mesmos nomes de classe e método, o código ainda funcionaria. Nesse sentido, é semelhante à definição tradicional de ligação tardia.

Atualmente, é popular usar o termo ligação tardia na programação Java como sinônimo de despacho dinâmico . Especificamente, isso se refere ao mecanismo de despacho único do Java usado com métodos virtuais.

Finalmente, Java pode usar ligação tardia usando suas APIs de reflexão e introspecção de tipos da mesma forma que é feito na programação COM e .NET. De um modo geral, aqueles que programam apenas em Java não chamam essa ligação tardia. Da mesma forma, o uso de técnicas de "digitação de pato" é desaprovado na programação Java, com interfaces abstratas usadas em seu lugar.

A Oracle, a atual proprietária do Java, é conhecida por usar o termo ligação tardia no sentido de "tipagem de pato" ao discutir Java e outras linguagens na mesma documentação. [9]

Ligação antecipada vs. tardia em PL/SQL e Ada

Ao usar a ligação antecipada entre Ada e um procedimento armazenado no banco de dados, um carimbo de data/hora é verificado para verificar se o procedimento armazenado não foi alterado desde que o código foi compilado. Isso permite execuções mais rápidas e evita que o aplicativo seja executado na versão errada de um procedimento armazenado. [10]

Ao usar a ligação tardia, a verificação de carimbo de data/hora não é executada e o procedimento armazenado é executado por meio de um bloco PL/SQL anônimo. Embora isso possa ser mais lento, elimina a necessidade de recompilar todos os aplicativos cliente quando um procedimento armazenado é alterado.

Essa distinção parece ser exclusiva de PL/SQL e Ada. Outras linguagens que podem chamar procedimentos PL/SQL, assim como outros mecanismos de banco de dados, usam somente ligação tardia.

Críticas

A vinculação tardia tem um desempenho inferior ao de uma chamada de método de vinculação antecipada. Na maioria das implementações, o endereço de método correto deve ser pesquisado pelo nome a cada chamada, exigindo uma pesquisa de dicionário relativamente cara e, possivelmente, uma lógica de resolução de sobrecarga, mas geralmente é insignificante em computadores modernos.

Para alguns compiladores, a associação tardia pode impedir o uso da verificação de tipo estático. Ao fazer uma chamada de ligação tardia, o compilador deve assumir que o método existe. Isso significa que um simples erro de ortografia pode causar um erro em tempo de execução. A exceção exata varia de acordo com o idioma, mas geralmente é chamada de algo como "Método não encontrado" ou "Método ausente". Os compiladores modernos evitam isso garantindo que cada chamada possível tenha uma implementação durante a compilação.

A vinculação tardia pode impedir as formas de análise estática necessárias para um ambiente de desenvolvimento integrado (IDE). Por exemplo, o recurso "ir para definição" de um IDE pode não funcionar em uma chamada de ligação tardia, se o IDE não tiver como saber a qual classe a chamada pode se referir. Um IDE moderno resolve isso facilmente, especialmente para linguagens orientadas a objetos, uma vez que um método de ligação tardia sempre especifica uma interface ou classe base, que é onde "ir para definição" leva, e "encontrar todas as referências" pode ser usado para encontrar todas as implementações ou substituições.

Um problema semelhante é que a possível falta de informações de digitação pode impedir a criação de gráficos de dependência. No entanto, outros métodos de programação, como interfaces abstratas, podem resultar nos mesmos problemas. Um IDE moderno pode criar esses gráficos de dependência com a mesma facilidade com que lida com "encontrar todas as referências".

Veja também

Referências

  1. ^ Schreiner, Axel-Tobias (1994). Programação orientada a objetos com ANSI-C (PDF) . Munique: Hanser. pág. 15. ISBN 3-446-17426-5.
  2. ^ Booch, Grady. Análise e Design orientados a objetos. Addison-Wesley, 1994. p71
  3. ^ "Usando ligação antecipada e ligação tardia na automação" . Microsoft . 06-09-2003. Arquivado a partir do original em 27/06/2014 . Recuperado em 27/06/2014 .
  4. ^ "A Estrutura da Máquina Virtual Java: Vinculação Dinâmica" . Sun Microsystems . 1999. seg. 3.6.3 . Recuperado 2013-09-21 .
  5. ^ Técnicas de engenharia de software, JN Buxton, Brian Randell , Comitê Científico da OTAN, Comitê Científico da OTAN, 1970
  6. ^ "Dr. Alan Kay sobre o significado de "Programação Orientada a Objetos"" . Purl.org . Recuperado em 16/08/2013 .
  7. ^ "12.5 — A mesa virtual « Aprenda C" . Learncpp. com. 08-02-2008 . Recuperado 2013-08-16 .
  8. ^ "Usando ligação antecipada e ligação tardia na automação" . Support.microsoft.com . Recuperado 2011-01-15 .
  9. ^ "Chamando no WebLogic Server a partir de um aplicativo cliente COM" . Download.oracle.com . Recuperado 2013-08-16 .
  10. ^ "Early and Late Binding, Oracle SQL *Module for Ada Programmer's Guide" . Download.oracle.com . Recuperado 2011-01-15 .