Información general sobre XAML (WPF)

XAML es un lenguaje declarativo de marcado Tal y como se aplica en el modelo de programación .NET Framework, XAML simplifica la creación de la interfaz de usuario para una aplicación .NET Framework. Se pueden crear elementos visibles de la interfaz de usuario en el marcado XAML declarativo y, a continuación, separar la definición de la interfaz de usuario de la lógica en tiempo de ejecución mediante archivos de código subyacente, que se unen al marcado mediante definiciones de clases parciales. XAML representa directamente la creación de instancias de objetos en un conjunto concreto de tipos de respaldo definidos en ensamblados. Esto no es lo que sucede con la mayoría de lenguajes de marcado, que normalmente se interpretan sin esa relación directa con un sistema de tipos de respaldo. El código XAML habilita un flujo de trabajo en el que las partes independientes pueden funcionar en la interfaz de usuario y la lógica de una aplicación, a través de herramientas potencialmente diferentes.

Cuando se representan como texto, los archivos XAML son archivos XML que generalmente tienen la extensión .xaml. Los archivos se pueden codificar con cualquier codificación XML, pero lo habitual es la codificación UTF-8.

En el ejemplo siguiente se muestra cómo podría crear un botón como parte de una interfaz de usuario. Este ejemplo se ha pensado simplemente para que tenga una idea de cómo representa el código XAML las metáforas de programación de la interfaz de usuario común (no es un ejemplo completo).

<StackPanel>
  <Button Content="Click Me"/>
</StackPanel>

En las secciones siguientes se explican las formas básicas de la sintaxis XAML y se proporciona un breve ejemplo de marcado. Estas secciones no están pensadas para proporcionar información completa sobre cada sintaxis, por ejemplo, cómo se representan en el sistema de tipos de respaldo. Para obtener más información acerca de los detalles específicos de la sintaxis de XAML para cada una de las formas de sintaxis presentadas en este tema, vea Detalles de la sintaxis XAML.

Gran parte del material de las secciones siguientes será básico para usted si tiene familiaridad con el lenguaje XML. Esta es una consecuencia de uno de los principios de diseño básicos de XAML. XAML El lenguaje XAML define conceptos propios, pero estos conceptos funcionan dentro del lenguaje XML y del formato de marcado.

Elementos de objeto XAML

<StackPanel>
  <Button Content="Click Me"/>
</StackPanel>

Sintaxis de atributos (propiedades)

<Button Background="Blue" Foreground="Red" Content="This is a button"/>

Sintaxis de elementos de propiedad

<Button>
  <Button.Background>
    <SolidColorBrush Color="Blue"/>
  </Button.Background>
  <Button.Foreground>
    <SolidColorBrush Color="Red"/>
  </Button.Foreground>
  <Button.Content>
    This is a button
  </Button.Content>
</Button>

Sintaxis de colecciones

<LinearGradientBrush>
  <LinearGradientBrush.GradientStops>
    <!-- no explicit new GradientStopCollection, parser knows how to find or create -->
    <GradientStop Offset="0.0" Color="Red" />
    <GradientStop Offset="1.0" Color="Blue" />
  </LinearGradientBrush.GradientStops>
</LinearGradientBrush>

Propiedades del contenido XAML

<Border>
  <TextBox Width="300"/>
</Border>
<!--explicit equivalent-->
<Border>
  <Border.Child>
    <TextBox Width="300"/>
  </Border.Child>
</Border>

<Button>I am a 
  <Button.Background>Blue</Button.Background>
  blue button</Button>

Contenido de texto

Propiedades de contenido y sintaxis de colección combinadas

<StackPanel>
  <Button>First Button</Button>
  <Button>Second Button</Button>
</StackPanel>

<StackPanel>
  <StackPanel.Children>
    <!--<UIElementCollection>-->
    <Button>First Button</Button>
    <Button>Second Button</Button>
    <!--</UIElementCollection>-->
  </StackPanel.Children>
</StackPanel>

Sintaxis de atributos (eventos)

<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="ExampleNamespace.ExamplePage">
  <Button Click="Button_Click" >Click Me!</Button>
</Page>

En general, XAML distingue entre mayúsculas y minúsculas. Para fines de resolver los tipos de respaldo, el XAML de WPF distingue entre mayúsculas y minúsculas por las mismas reglas que el CLR. Los elementos de objeto, los elementos de propiedad y los nombres de atributo se deben especificar utilizando la grafía que distinga mayúsculas de minúsculas cuando se comparan por nombre con el tipo subyacente en el ensamblado, o con un miembro de un tipo. Las palabras clave y primitivas del lenguaje XAML también distinguen entre mayúsculas y minúsculas. Los valores no siempre distinguen entre mayúsculas y minúsculas. La distinción entre mayúsculas y minúsculas para los valores dependerá del comportamiento del convertidor de tipos asociado a la propiedad que toma el valor o del tipo de valor de propiedad. Por ejemplo, las propiedades que toma el tipo Boolean pueden tomar true o True como valores equivalentes, pero solo porque la conversión de tipos de cadena del analizador de código XAML de WPF nativo para la cadena a Boolean ya los permite como equivalentes.

Los procesadores y serializadores XAML de WPF omiten o quitan todos los espacios en blanco no significativos y normalizan cualquier espacio en blanco significativo. Esto es coherente con las recomendaciones de comportamiento de espacio en blanco predeterminado de la especificación de XAML. Este comportamiento generalmente sólo tiene importancia si se especifican cadenas dentro de las propiedades de XAML. Es decir, XAML convierte los caracteres de espacio, avance de línea y tabulación en espacios y, a continuación, conserva un espacio si lo encuentra en cualquier extremo de una cadena contigua. La explicación completa del control de espacios en blanco de XAML no se aborda en este tema. Para obtener información detallada, vea Procesamiento de espacios en blanco en XAML.

Las extensiones de marcado son un concepto del lenguaje XAML. Cuando se usan para proporcionar el valor de una sintaxis de atributos, las llaves ({ y }) indican el uso de una extensión de marcado. Este uso hace que el procesamiento XAML se aparte del tratamiento general de valores de atributo como una cadena literal o un valor directamente convertible en cadena.

Las extensiones de marcado más comunes utilizadas en la programación de aplicaciones de WPF son Binding, utilizada para las expresiones de enlace de datos, y las referencias de recursos StaticResource y DynamicResource. Al usar las extensiones de marcado, se puede utilizar la sintaxis de atributos para proporcionar valores para las propiedades aunque esa propiedad no admita una sintaxis de atributos en general. Las extensiones de marcado utilizan a menudo tipos de expresión intermedia para habilitar características tales como diferir los valores o hacer referencia a otros objetos que solo están presentes en tiempo de ejecución.

Por ejemplo, en el marcado siguiente se establece el valor de la propiedad Style mediante la sintaxis de atributos. La propiedad Style toma una instancia de la clase Style, cuya instancia no se podría crear mediante una cadena de sintaxis de atributo de forma predeterminada. Pero en este caso, el atributo hace referencia a una extensión de marcado determinada, StaticResource. Cuando se procesa dicha extensión de marcado, devuelve una referencia a un estilo del que ya se han creado instancias como un recurso con clave en un diccionario de recursos.

<Page.Resources>
  <SolidColorBrush x:Key="MyBrush" Color="Gold"/>
  <Style TargetType="Border" x:Key="PageBackground">
    <Setter Property="Background" Value="Blue"/>
  </Style>


...


</Page.Resources>
<StackPanel>
  <Border Style="{StaticResource PageBackground}">


...


  </Border>
</StackPanel>

Para obtener una lista de referencias de todas las extensiones de marcado para XAML implementadas específicamente en WPF, vea Extensiones XAML de WPF. Para obtener una lista de referencias de las extensiones de marcado definidas por System.Xaml y que están más disponibles para las implementaciones XAML de .NET Framework, vea Características de lenguaje (x:) de espacios de nombres XAML. Para obtener más información sobre los conceptos de la extensión de marcado, vea Extensiones de marcado y XAML de WPF.

En la sección , se ha dicho que el valor de atributo debe poder establecerlo una cadena. El control nativo básico de cómo se convierten las cadenas en otros tipos de objeto o los valores primitivos se basa en el propio tipo String, así como en algún procesamiento nativo para ciertos tipos como DateTime o Uri. Pero muchos tipos o miembros de WPF de esos tipos extienden el comportamiento básico del procesamiento de atributos de cadena, de tal forma que se pueden especificar instancias de tipos de objeto más complejos como cadenas y atributos.

La estructura Thickness es un ejemplo de un tipo que incluye una conversión de tipos habilitada para los usos del código XAML. Thickness indica las medidas dentro de un rectángulo anidado y se usa como el valor de propiedades tales como Margin. Al colocar un convertidor de tipos en Thickness, todas las propiedades que usan la propiedad Thickness son más fáciles de especificar en código XAML porque se pueden especificar como atributos. En el ejemplo siguiente se usa una conversión de tipos y una sintaxis de atributos para proporcionar un valor a la propiedad Margin:

<Button Margin="10,20,10,30" Content="Click me"/>

El ejemplo de sintaxis de atributo anterior es equivalente al ejemplo de sintaxis siguiente más detallado, donde la propiedad Margin se establece mediante la sintaxis de elementos de propiedad que contiene un elemento de objeto Thickness. Las cuatro propiedades clave de Thickness se establecen como atributos en la nueva instancia:

<Button Content="Click me">
  <Button.Margin>
    <Thickness Left="10" Top="20" Right="10" Bottom="30"/>
  </Button.Margin>
</Button>

Nota
También hay un número limitado de objetos en los que la conversión de tipos es la única manera pública de establecer una propiedad en ese tipo sin necesidad de una subclase, debido a que el propio objeto de tipo no tiene un constructor predeterminado. Un ejemplo de ello sería Cursor.

Para obtener más información la compatibilidad de la conversión de tipos y su uso para la sintaxis de atributos, vea Clases TypeConverter y XAML.

Para que un archivo XAML pueda ser tanto un archivo XAML con un formato correcto como un archivo XML válido, solo debe tener un elemento raíz. Normalmente, en los escenarios WPF, se debe elegir un elemento raíz que tenga un significado notable en el modelo de aplicaciones WPF (por ejemplo, Window o Page para una página, ResourceDictionary para un diccionario externo o Application para la definición de la aplicación). En el ejemplo siguiente se muestra el elemento raíz de un archivo XAML típico para una página WPF, con el elemento raíz de Page.

<Page
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"


...


</Page>

El elemento raíz también contiene los atributos xmlns y xmlns:x. Estos atributos indican a un procesador XAML los espacios de nombres XAML que contienen las definiciones los tipos de respaldo a los que el marcado hará referencia. El atributo xmlns indica específicamente el espacio de nombres XAML predeterminado. Dentro este espacio de nombres XAML, los elementos de objeto en el marcado se pueden especificar sin un prefijo. Para la mayoría de los escenarios de aplicaciones WPF y para casi todos los ejemplos ofrecidos en las secciones de WPF del SDK, el espacio de nombres XAML predeterminado está asignado al espacio de nombres http://schemas.microsoft.com/winfx/2006/xaml/presentation de WPF. El atributo xmlns:x indica un espacio de nombres XAML adicional, que asigna el espacio de nombres del XAML http://schemas.microsoft.com/winfx/2006/xaml.

Este uso de xmlns con el fin de definir un ámbito para el uso y asignación de un ámbito de nombres es coherente con la especificación XML 1.0. Los ámbitos de nombres de código XAML solo se diferencian de los ámbitos de nombres de XML en que un ámbito de nombres de código XAML también implica al forma en que los tipos respaldan los elementos del ámbito de nombres cuando se trata de la resolución de tipos y del análisis del código XAML.

Observe que los atributos xmlns solo son estrictamente necesarios en el elemento raíz de cada archivo XAML. Las definiciones de xmlns se aplicarán a todos los elementos descendientes del elemento raíz (una vez más, este comportamiento es coherente con la especificación XML 1.0 para xmlns). También se permiten atributos xmlns en otros elementos bajo el raíz, y se aplican a cualquier elemento descendiente del elemento de definición. Sin embargo, una definición o redefinición frecuente de los espacios de nombres XAML puede dar lugar a un estilo de marcado XAML que resulte difícil de leer.

La implementación de WPF de su procesador XAML incluye una infraestructura que reconoce los ensamblados básicos de WPF. Se sabe que los ensamblados básicos de WPF contienen los tipos que admiten las asignaciones de WPF al espacio de nombres XAML predeterminado. Esto se habilita a través de la configuración que forma parte de su archivo de compilación de proyecto y los sistemas de compilación y proyectos de WPF. Por consiguiente, solo es necesario declarar el espacio de nombres XAML predeterminado como xmlns predeterminado para hacer referencia a los elementos de código XAML que proceden de los ensamblados de WPF.

El prefijo x:

Para sus propios ensamblados personalizados o para los ensamblados fuera del núcleo WPF de PresentationCore, PresentationFramework y WindowsBase, puede especificar el ensamblado como parte de una asignación xmlns personalizada. A continuación, puede hacer referencia a los tipos de ese ensamblado en su código XAML, siempre que su tipo esté implementado correctamente para admitir los usos de código XAML que intenta.

El siguiente es un ejemplo muy básico de cómo funcionan los prefijos personalizados en el marcado XAML. El prefijo custom se define en la etiqueta de elemento raíz y se asigna a un ensamblado concreto que se empaqueta y está disponible con la aplicación. Este ensamblado contiene un tipo NumericUpDown, que se implementa para admitir el uso XAML general, además de usar una herencia de clases que permite su inserción en este punto concreto en un modelo de contenido de código XAML de WPF. Se declara una instancia de este control NumericUpDown como un elemento de objeto, utilizando el prefijo para que un analizador de código XAML sepa qué espacio de nombres XAML contiene el tipo y, por consiguiente, dónde está el ensamblado de respaldo que contiene la definición de tipo.

<Page
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:custom="clr-namespace:NumericUpDownCustomControl;assembly=CustomLibrary"
    >
  <StackPanel Name="LayoutRoot">
    <custom:NumericUpDown Name="numericCtrl1" Width="100" Height="60"/>
...
  </StackPanel>
</Page>

Para obtener más información acerca de los tipos personalizados en el código XAML, vea Clases XAML y personalizadas para WPF.

Para obtener más información sobre la relación existente entre los espacios de nombres XML y los espacios de nombres del código de respaldo en los ensamblados, vea Espacios de nombres y asignación de espacios de nombres XAML para WPF.

La mayoría de las aplicaciones de WPF constan de marcado XAML y código subyacente. En un proyecto, el código XAML se escribe como un archivo .xaml y se utiliza un lenguaje de CLR, como Microsoft Visual Basic o C#, para escribir un archivo de código subyacente. Cuando se compila un archivo XAML como parte de los modelos de aplicaciones y programación de WPF, la ubicación del archivo de código subyacente WPF para cada página XAML se identifica especificando un espacio de nombres y una clase como atributo x:Class del elemento raíz de la página XAML.

En los ejemplos presentados hasta ahora se incluían varios botones, pero ninguno de ellos tenía todavía ningún comportamiento lógico asociado. El mecanismo primario en el nivel de la aplicación para agregar un comportamiento a un elemento de objeto consiste en utilizar un evento existente de la clase de elemento y escribir un controlador específico para dicho evento que se invocará cuando se provoque éste en tiempo de ejecución. El nombre del evento y el nombre del controlador que se van a utilizar se especifican en el marcado, mientras que el código que implementa el controlador se define en el código subyacente.

<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  x:Class="ExampleNamespace.ExamplePage">
  <Button Click="Button_Click" >Click Me!</Button>
</Page>

Private Sub Button_Click(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
    Dim b As Button = e.Source
    b.Foreground = Brushes.Red
End Sub

namespace ExampleNamespace
{
  public partial class ExamplePage
  {
    void Button_Click(object sender, RoutedEventArgs e)
    {
      Button b = e.Source as Button;
      b.Foreground = Brushes.Red;
    }
  }
}

Tenga en cuenta que el archivo de código subyacente utiliza el espacio de nombres CLR ExampleNamespace y declara ExamplePage como una clase parcial dentro de dicho espacio de nombres. Esto es similar al valor de atributo x:Class de ExampleNamespace.ExamplePage que se ha proporcionado en la raíz del marcado. El compilador de marcado WPF creará automáticamente una clase parcial para cualquier archivo XAML compilado, al derivar una clase del tipo de elemento raíz. Al proporcionar código subyacente que también define la misma clase parcial, el código resultante se combina dentro del mismo espacio de nombres y la clase de la aplicación compilada.

Para obtener más información sobre los requisitos para la programación de código subyacente en WPF, vea la sección "Requisitos del código subyacente, los controladores de eventos y las clases parciales" de Código subyacente y XAML en WPF.

Si no desea crear un archivo de código subyacente independiente, también puede insertar el código dentro de un archivo XAML. Sin embargo, el código insertado es una técnica menos versátil que tiene importantes limitaciones. Para obtener información detallada, vea Código subyacente y XAML en WPF.

Eventos enrutados

De forma predeterminada, la instancia de objeto que se crea en un gráfico de objetos al procesar un elemento de objeto XAML no posee un identificador único o una referencia de objeto inherente que se pueda utilizar en el código. Por el contrario, si se llama a un constructor en el código, casi siempre se utiliza el resultado del constructor para establecer una variable en la instancia creada con objeto de que se pueda hacer referencia a dicha instancia posteriormente en el código. Para proporcionar acceso normalizado a los objetos creados mediante una definición de marcado, XAML define el atributo x:Name. Es posible establecer el valor del atributo x:Name en cualquier elemento de objeto. En el código subyacente, el identificador elegido es equivalente a una variable de instancia que hace referencia a la instancia creada. Los elementos con nombre funcionan en todos los sentidos como si fueran instancias de objeto (el nombre hace referencia a la instancia) y el código subyacente puede hacer referencia a dichos elementos para controlar las interacciones en tiempo de ejecución dentro de la aplicación. Esta conexión entre las instancias y el compilador se logra por el compilador de marcado XAML de WPF y más específicamente implica características y modelos como InitializeComponent que no se tratarán en este tema.

Los elementos de código XAML del nivel de marco de WPF heredan una propiedad Name, que es equivalente al atributo x:Name definido por XAML. Otros tipos de clases también proporcionan equivalentes en el nivel de propiedad para x:Name, que en general también suele definirse como una propiedad Name. En general, si no puede localizar una propiedad Name en la tabla de miembros del elemento/tipo elegido, utilice en su lugar x:Name. Los valores x:Name proporcionarán un identificador a un elemento XAML que se puede utilizar en tiempo de ejecución por subsistemas concretos o por métodos de utilidad como FindName.

En el ejemplo siguiente se establece Name en un elemento StackPanel. A continuación, un controlador en un elemento Button dentro de StackPanel hace referencia al objeto StackPanel mediante su referencia de instancia buttonContainer tal y como lo establece Name.

<StackPanel Name="buttonContainer">


...


  <Button Click="RemoveThis">Click to remove this button</Button>
</StackPanel>

 Private Sub RemoveThis(ByVal sender As System.Object, ByVal e As System.Windows.RoutedEventArgs)
     Dim fe As FrameworkElement = e.Source
     If (buttonContainer.Children.Contains(fe)) Then
         buttonContainer.Children.Remove(fe)
     End If
End Sub

void RemoveThis(object sender, RoutedEventArgs e)
{
    FrameworkElement fe = e.Source as FrameworkElement;
    if (buttonContainer.Children.Contains(fe))
    {
        buttonContainer.Children.Remove(fe);
    }
}

Al igual que una variable, el nombre XAML de una instancia está regido por un concepto de ámbito con objeto de aplicar los nombres de forma que sean únicos dentro de un ámbito predecible. El marcado primario que define una página indica un ámbito de nombres de código XAML único, siendo el límite de dicho ámbito el elemento raíz de la página. Sin embargo, otros orígenes de marcado pueden interactuar con una página en tiempo de ejecución, por ejemplo, los estilos o las plantillas incluidas en los estilos, y dichos orígenes tienen a menudo su propio ámbito de nombres de código XAML que no tiene por qué estar conectado necesariamente con el de la página. Para obtener más información sobre x:Name y los ámbitos de nombres de código XAML, vea Name, x:Name (Directiva) o Ámbitos de nombres XAML de WPF.

XAML incluye una característica de lenguaje que permite especificar ciertas propiedades o eventos en cualquier elemento, independientemente de si la propiedad o el evento existe en las definiciones del tipo para el elemento en el que se establece. La versión de esta característica para las propiedades se denomina propiedad asociada y la versión para los eventos se denomina evento asociado. Conceptualmente, las propiedades y los eventos adjuntos se pueden considerar como miembros globales que se pueden establecer en cualquier elemento / instancia de objeto XAML. Sin embargo, ese elemento / clase o infraestructura mayor debe admitir un almacén de propiedades de respaldo para los valores adjuntos.

Las propiedades adjuntas de código XAML se usan normalmente mediante la sintaxis de atributos. En la sintaxis de atributos, una propiedad adjunta se especifica con el formato tipoDePropietario.nombreDePropiedad.

A primera vista, esto se parece al uso de un elemento de propiedad, pero en este caso el tipoDePropietario que se especifica es siempre un tipo distinto del elemento de objeto en el que se establece la propiedad adjunta. tipoDePropietario es el tipo que proporciona los métodos de descriptor de acceso que un procesador XAML requiere para poder obtener o establecer el valor de propiedad adjunto.

El escenario más común para las propiedades asociadas es permitir a los elementos secundarios enviar un valor de propiedad a su elemento primario.

En el ejemplo siguiente se muestra la propiedad asociada DockPanel.Dock. La clase DockPanel define los descriptores de acceso para DockPanel.Dock y, por lo tanto, es la propietaria de la propiedad asociada. La clase DockPanel también incluye la lógica que recorre en iteración sus elementos secundarios y busca en cada uno de ellos un valor establecido de DockPanel.Dock. Si se encuentra dicho valor, éste se utiliza durante el diseño para colocar los elementos secundarios. El uso de la propiedad asociada DockPanel.Dock y esta función de posición constituyen de hecho el escenario de motivación para la clase DockPanel.

<DockPanel>
  <Button DockPanel.Dock="Left" Width="100" Height="20">I am on the left</Button>
  <Button DockPanel.Dock="Right" Width="100" Height="20">I am on the right</Button>
</DockPanel>

En WPF, la mayoría de las propiedades adjuntas se implementan también como propiedades de dependencia. Para obtener información detallada, vea Información general sobre propiedades asociadas.

Los eventos adjuntos usan un formato de sintaxis de atributos similar: tipoDePropietario.nombreDeEvento. Al igual que en los eventos no adjuntos, el valor del atributo para un evento adjunto en código XAML especifica el nombre del método controlador que se invoca cuando se controla el evento en el elemento. Los usos de eventos adjuntos en código XAML de WPF son menos comunes. Para obtener más información, vea Información general sobre eventos adjuntos.

Debajo del código XAML de WPF y su espacio de nombres XAML existe una colección de tipos que corresponden a los objetos de CLR, así como elementos de marcado para XAML. Sin embargo, no todas las clases se pueden asignar a elementos. Las clases abstractas, como ButtonBase, y ciertas clases base no abstractas se usan para la herencia en el modelo de objetos de CLR. Las clases base, incluidas las abstractas, son importantes para el desarrollo de código XAML porque cada uno de los elementos de código XAML concretos hereda miembros de alguna clase base en su jerarquía. A menudo, estos miembros incluyen propiedades que se pueden establecer como atributos en el elemento o eventos que se pueden controlar. FrameworkElement es la clase base concreta de la interfaz de usuario de WPF en el nivel de marco WPF. Al diseñar la interfaz de usuario, se utilizarán varias clases de forma, de panel, de decorador o de control, que se derivan de FrameworkElement. Una clase base relacionada, FrameworkContentElement, admite elementos orientados a documentos que funcionan bien para una presentación de diseño de flujo, utilizando API que reflejan deliberadamente las API de FrameworkElement. La combinación de atributos en el nivel de elemento y un modelo de objetos de CLR proporciona un conjunto de propiedades comunes que se pueden establecer en la mayoría de los elementos de código XAML concretos, independientemente del tipo de elemento XAML específico y su tipo subyacente.

XAML es un lenguaje de marcado que representa directamente la creación de instancias y la ejecución de objetos. Por consiguiente, los elementos creados en código XAML tienen la misma capacidad de interactuar con los recursos del sistema (por ejemplo, el acceso a la red y la E/S del sistema de archivos) que el código generado equivalente.

WPF admite el marco de trabajo de seguridad Seguridad de acceso del código (CAS) de .NET Framework 4. Esto significa que el contenido de WPF que se ejecuta en la zona de Internet tiene permisos de ejecución reducidos. " El "código XAML dinámico" (páginas de código XAML no compilado interpretadas en el momento de la carga por un visor de código XAML) y las Aplicación del explorador XAML (XBAP) se ejecutan normalmente en esta zona de Internet y usan el mismo conjunto de permisos. No obstante, el código XAML cargado en una aplicación de plena confianza tiene el mismo acceso a los recursos del sistema que la aplicación host. Para obtener más información, vea Seguridad de confianza parcial de WPF.

XAML se puede usar para definir la totalidad de la interfaz de usuario, pero a veces también es conveniente definir solo una parte de dicha interfaz en código XAML. Esta funcionalidad se podría usar para habilitar una personalización parcial, para el almacenamiento local de información, para proporcionar un objeto comercial mediante código XAML o para diversos escenarios posibles. La clave para estos escenarios es la clase XamlReader y su método Load. La entrada es un archivo XAML y la salida es un objeto que representa la totalidad del árbol de objetos en tiempo de ejecución que se ha creado a partir de ese marcado. A continuación, se puede insertar el objeto como una propiedad de otro objeto que ya existe en la aplicación. Siempre que la propiedad sea una propiedad adecuada en el modelo de contenido que tiene funcionalidades de presentación y que notifica al motor de ejecución que se ha agregado el nuevo contenido a la aplicación, es posible modificar con gran facilidad el contenido de una aplicación en ejecución si se carga código XAML. Tenga en cuenta que esta función normalmente sólo está disponible en las aplicaciones de plena confianza, debido a las implicaciones de seguridad obvias de la carga de archivos en aplicaciones que se están ejecutando.

En este tema se proporciona una introducción básica a la terminología y los conceptos de la sintaxis XAML que se aplica en WPF. Para obtener más información acerca de los términos utilizados aquí, vea Detalles de la sintaxis XAML.

Si aún no lo ha hecho, intente realizar los ejercicios del tutorial Tutorial: Introducción a WPF. La aplicación centrada en el marcado descrita en el tutorial le ayudará a reforzar muchos de los conceptos descritos en este tema.

WPF utiliza un modelo de aplicación determinado que está basado en la clase Application. Para obtener información detallada, vea Información general sobre la administración de aplicaciones.

Compilar una aplicación de WPF (WPF) le ofrece información más detallada sobre cómo compilar aplicaciones que incluyen código XAML desde la línea de comandos y con Microsoft Visual Studio.

Información general sobre las propiedades de dependencia le ofrece más información sobre la versatilidad de las propiedades en WPF, e introduce el concepto de propiedades de dependencia.

Conceptos

Otros recursos