c# - wpf xaml tutorial

Código de acceso variable en XAML

Question

¿Cómo puedo acceder a la variable pública que en el archivo Sample.xaml.cs como asp.net <%=VariableName%> ?

Answer 1

Hay algunas maneras de hacer esto.

• Agregue su variable como un recurso de codebehind:

  myWindow.Resources.Add("myResourceKey", myVariable);

  Entonces puedes acceder desde XAML:

  <TextBlock Text="{StaticResource myResourceKey}"/>

  Si tiene que agregarlo después de analizar el XAML, puede usar DynamicResource arriba en lugar de StaticResource .

• Haga que la variable sea una propiedad de algo en su XAML. Por lo general, esto funciona a través del DataContext :

  myWindow.DataContext = myVariable;

  o

  myWindow.MyProperty = myVariable;

  Después de esto, cualquier cosa en su XAML puede acceder a través de un Binding :

  <TextBlock Text="{Binding Path=PropertyOfMyVariable}"/>

  o

  <TextBlock Text="{Binding ElementName=myWindow, Path=MyProperty}"/>

Answer 2

Para Windows rápido y sucio en WPF, prefiero vincular el DataContext de la Ventana a la ventana misma; esto se puede hacer todo en XAML.

Window1.xaml

<Window x:Class="WpfApplication1.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    DataContext="{Binding RelativeSource={RelativeSource self}}"
    Title="Window1" Height="300" Width="300">
    <StackPanel>
        <TextBlock Text="{Binding Path=MyProperty1}" />
        <TextBlock Text="{Binding Path=MyProperty2}" />
        <Button Content="Set Property Values" Click="Button_Click" />
    </StackPanel>
</Window>

Window1.xaml.cs

public partial class Window1 : Window
{
    public static readonly DependencyProperty MyProperty2Property =
        DependencyProperty.Register("MyProperty2", typeof(string), typeof(Window1), new UIPropertyMetadata(string.Empty));

    public static readonly DependencyProperty MyProperty1Property =
        DependencyProperty.Register("MyProperty1", typeof(string), typeof(Window1), new UIPropertyMetadata(string.Empty));

    public Window1()
    {
        InitializeComponent();
    }

    public string MyProperty1
    {
        get { return (string)GetValue(MyProperty1Property); }
        set { SetValue(MyProperty1Property, value); }
    }

    public string MyProperty2
    {
        get { return (string)GetValue(MyProperty2Property); }
        set { SetValue(MyProperty2Property, value); }
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        // Set MyProperty1 and 2
        this.MyProperty1 = "Hello";
        this.MyProperty2 = "World";
    }
}

En el ejemplo anterior, tenga en cuenta el enlace utilizado en la propiedad DataContext en la ventana, esto dice "Establezca su contexto de datos para usted". Los dos bloques de texto están vinculados a MyProperty1 y MyProperty2 , el controlador de eventos para el botón establecerá estos valores, que se propagarán automáticamente a la propiedad Text de los dos TextBlocks ya que las propiedades son Dependency Properties.

Answer 3

Para el enlace, si DataContext no está en uso, simplemente puede agregar esto al constructor del código detrás:

this.DataContext = this;

Al usar esto, cada propiedad en el código se vuelve accesible para el enlace:

<TextBlock Text="{Binding PropertyName}"/>

Otra forma es simplemente dar un nombre al elemento raíz de XAML:

x:Name="root"

Como el XAML se compila como una clase parcial del código subyacente, podemos acceder a cada propiedad por su nombre:

<TextBlock Text="{Binding ElementName="root" Path=PropertyName}"/>

Nota: el acceso solo está disponible para las propiedades; no a los campos. set; y get; o {Binding Mode = OneWay} son necesarios. Si se utiliza el enlace OneWay, los datos subyacentes deben implementar INotifyPropertyChanged .

Answer 4

También vale la pena señalar que un ''Encuadernación'' solo se puede establecer en una DependencyProperty de un DependencyObject. Si desea establecer una Propiedad no Dependency (por ejemplo, una propiedad normal) en un objeto en XAML, tendrá que utilizar el primer método de Robert de usar recursos en el código subyacente.