Code-behind e XAML in WPF

  • Articolo

Code-behind è un termine usato per descrivere il codice unito a oggetti definiti dal markup, quando viene compilata una pagina XAML. Questo argomento descrive i requisiti per il code-behind e un meccanismo di codice inline alternativo per il codice in XAML.

Questo argomento include le sezioni seguenti:

Prerequisiti

In questo argomento si presuppone che il codice XAML sia stato letto in WPF e che si abbia una conoscenza di base della programmazione CLR e orientata agli oggetti.

Code-behind e linguaggio XAML

Il linguaggio XAML include funzionalità a livello di linguaggio che consentono di associare file di codice ai file di markup, dal lato del file di markup. In particolare, il linguaggio XAML definisce le funzionalità del linguaggio x:Class Directive, x:Subclass Directive e x:ClassModifier Directive. Esattamente come deve essere prodotto il codice e come integrare markup e codice, non fa parte di ciò che viene specificato dal linguaggio XAML. Viene lasciato a framework come WPF per determinare come integrare il codice, come usare XAML nei modelli di applicazione e programmazione e le azioni di compilazione o altro supporto necessario.

Requisiti di code-behind, gestore eventi e classi parziali in WPF

  • La classe parziale deve derivare dal tipo che restituisce l'elemento radice.

  • Si noti che nel comportamento predefinito delle azioni di compilazione del markup è possibile lasciare vuota la derivazione nella definizione della classe parziale sul lato code-behind. Il risultato compilato presuppone che il tipo di supporto della radice della pagina sia la base per la classe parziale, anche se non specificato. Tuttavia, fare affidamento su questo comportamento non è una procedura consigliata.

  • I gestori eventi scritti nel code-behind devono essere metodi di istanza e non possono essere metodi statici. Questi metodi devono essere definiti dalla classe parziale all'interno dello spazio dei nomi CLR identificato da x:Class. Non puoi qualificare il nome di un gestore eventi per indicare a un processore XAML di cercare un gestore eventi per il cablaggio di eventi in un ambito di classe diverso.

  • Il gestore deve corrispondere al delegato per l'evento appropriato nel sistema di tipi di supporto.

  • Per il linguaggio Microsoft Visual Basic in particolare, puoi usare la parola chiave specifica Handles del linguaggio per associare gestori a istanze ed eventi nella dichiarazione del gestore, invece di associare gestori con attributi in XAML. Tuttavia, questa tecnica presenta alcune limitazioni perché la Handles parola chiave non può supportare tutte le funzionalità specifiche del sistema eventi WPF, ad esempio alcuni scenari di eventi indirizzati o eventi associati. Per informazioni dettagliate, vedere Gestione degli eventi di Visual Basic e WPF.

x:Code

x:Code è un elemento di direttiva definito in XAML. Un x:Code elemento direttiva può contenere codice di programmazione inline. Il codice definito inline può interagire con il codice XAML nella stessa pagina. L'esempio seguente illustra il codice C# inline. Si noti che il codice si trova all'interno dell'elemento x:Code e che il codice deve essere racchiuso tra <CDATA[...]]> per eseguire l'escape del contenuto per XML, in modo che un processore XAML (interpretando lo schema XAML o lo schema WPF) non tenti di interpretare il contenuto letteralmente come 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>

Limitazioni del codice inline

È consigliabile evitare o limitare l'uso di codice inline. In termini di architettura e filosofia di codifica, mantenere una separazione tra markup e code-behind mantiene molto più distinti i ruoli di progettazione e sviluppatore. A livello più tecnico, il codice scritto per il codice inline può risultare difficile da scrivere, perché si scrive sempre nella classe parziale generata da XAML e può usare solo i mapping degli spazi dei nomi XML predefiniti. Poiché non è possibile aggiungere using istruzioni, è necessario qualificare completamente molte delle chiamate API effettuate. I mapping WPF predefiniti includono la maggior parte, ma non tutti gli spazi dei nomi CLR presenti negli assembly WPF; sarà necessario qualificare completamente le chiamate ai tipi e ai membri contenuti negli altri spazi dei nomi CLR. Non è inoltre possibile definire elementi oltre la classe parziale nel codice inline e tutte le entità di codice utente a cui si fa riferimento devono esistere come membro o variabile all'interno della classe parziale generata. Non sono disponibili anche altre funzionalità di programmazione specifiche del linguaggio, ad esempio macro o #ifdef variabili di compilazione o variabili di compilazione globali. Per altre informazioni, vedi Tipo XAML intrinseco x:Code.

Vedi anche