Code-behind e XAML no WPF

  • Artigo

Code-behind é um termo usado para descrever o código que é unido a objetos definidos por marcação, quando uma página XAML é compilada com marcação. Este tópico descreve os requisitos para code-behind, bem como um mecanismo de código embutido alternativo para código em XAML.

Este tópico contém as seguintes seções:

Pré-requisitos

Este tópico pressupõe que você tenha lido o XAML no WPF e tenha algum conhecimento básico do CLR e da programação orientada a objeto.

Code-Behind e a linguagem XAML

A linguagem XAML inclui recursos de nível de linguagem que tornam possível associar arquivos de código com arquivos de marcação, do lado do arquivo de marcação. Especificamente, a linguagem XAML define os recursos de linguagem Diretiva x:Class, Diretiva x:Subclass e Diretiva x:ClassModifier. O modo exato como o código deve ser produzido e como a marcação e o código devem ser integrados não faz parte do que a linguagem XAML especifica. É deixado para as estruturas, como o WPF, determinarem como integrar o código, como usar a linguagem XAML nos modelos de aplicativo e programação e as ações de build ou outros tipos de suporte que são exigidos.

Code-behind, manipulador de eventos e requisitos de classe parcial no WPF

  • A classe parcial deve derivar do tipo que sustenta o elemento raiz.

  • Observe que, sob o comportamento padrão das ações de build de compilação de marcação, você pode deixar a derivação em branco na definição de classe parcial no lado da lógica. O resultado compilado assumirá o tipo de suporte da raiz da página para ser a base para a classe parcial, mesmo se não for especificado. No entanto, contar com esse comportamento não é uma prática recomendada.

  • Os manipuladores de eventos que você escreve no code-behind devem ser métodos de instância e não podem ser métodos estáticos. Esses métodos devem ser definidos pela classe parcial dentro do namespace CLR identificado por x:Class. Não é possível qualificar o nome de um manipulador de eventos para instruir um processador XAML a procurar um manipulador de eventos para a fiação de eventos em um escopo de classe diferente.

  • O manipulador deve corresponder ao delegado para o evento apropriado no sistema de tipo de suporte.

  • Para a linguagem Microsoft Visual Basic especificamente, você pode usar a palavra-chave específica Handles do idioma para associar manipuladores a instâncias e eventos na declaração do manipulador, em vez de anexar manipuladores com atributos em XAML. No entanto, essa técnica tem algumas limitações porque a palavra-chave não pode oferecer suporte a Handles todos os recursos específicos do sistema de eventos WPF, como determinados cenários de eventos roteados ou eventos anexados. Para obter detalhes, consulte Visual Basic e manipulação de eventos WPF.

x:Code

x:Code é um elemento de diretiva definido em XAML. Um elemento de diretiva x:Code pode conter um código de programação embutido. O código definido embutido pode interagir com o XAML na mesma página. O exemplo a seguir ilustra o código C# embutido. Observe que o código está dentro do elemento e que o código deve ser cercado por <CDATA[...]]> para escapar do x:Code conteúdo para XML, de modo que um processador XAML (interpretando o esquema XAML ou o esquema WPF) não tente interpretar o conteúdo literalmente como XML.

<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="MyNamespace.MyCanvasCodeInline"
>
  <Button Name="button1" Click="Clicked">Click Me!</Button>
  <x:Code><![CDATA[
    void Clicked(object sender, RoutedEventArgs e)
    {
        button1.Content = "Hello World";
    }
  ]]></x:Code>
</Page>

Limitações de código embutido

Considere evitar ou limitar o uso de código embutido. Em termos de arquitetura e filosofia de código, manter uma separação entre a marcação e o code-behind mantém as funções de designer e de desenvolvedor muito mais distintas. Em um nível mais técnico, o código que você escreve para código embutido pode ser difícil de escrever, porque você está sempre gravando na classe parcial gerada por XAML e só pode usar os mapeamentos de namespace XML padrão. Como não é possível adicionar using instruções, você deve qualificar totalmente muitas das chamadas de API que você faz. Os mapeamentos WPF padrão incluem a maioria, mas não todos os namespaces CLR que estão presentes nos assemblies WPF; você terá que qualificar totalmente as chamadas para tipos e membros contidos nos outros namespaces CLR. Você também não poderá definir nada além da classe parcial no código embutido e todas as entidades de código de usuário que você referencia devem existir como um membro ou uma variável na classe parcial gerada. Outros recursos específicos da linguagem de programação, como as macros ou #ifdef contra as variáveis globais ou de build, também não estão disponíveis. Para obter mais informações, consulte x:Code Intrinsic XAML Type (Tipo intrínseco x:Code (XAML)).

Confira também