Accès le code-behind de la variable dans le code XAML

Comment puis-je accéder à la variable publique qui, dans de l'Échantillon.xaml.cs fichier comme asp.net <%=VariableName%>?

Cette question peut également être utile depuis elle est un peu plus récent ...

InformationsquelleAutor Murat | 2009-03-20

c#silverlight wpf xaml

63

Il ya quelques façons de le faire.
- Ajouter votre variable comme une ressource à partir du code-behind:
```
myWindow.Resources.Add("myResourceKey", myVariable);
```
  Puis vous pouvez y accéder à partir de XAML:
```
<TextBlock Text="{StaticResource myResourceKey}"/>
```
  Si vous devez l'ajouter après le XAML est analysée, vous pouvez utiliser un DynamicResource dessus au lieu de StaticResource.
- Faire de la variable une propriété de quelque chose dans votre XAML. Habituellement, cela fonctionne par le biais de DataContext:
```
myWindow.DataContext = myVariable;
```
  ou
```
myWindow.MyProperty = myVariable;
```
  Après cela, quelque chose dans votre XAML peut y accéder par un Binding:
```
<TextBlock Text="{Binding Path=PropertyOfMyVariable}"/>
```
  ou
```
<TextBlock Text="{Binding ElementName=myWindow, Path=MyProperty}"/>
```
InformationsquelleAutor Robert Macnee
24

Pour la liaison, si DataContext n'est pas en cours d'utilisation, vous pouvez simplement ajouter ceci dans le constructeur du code de derrière:
```
this.DataContext = this;
```
À l'aide de cette, chaque propriété dans le code devient accessible à de liaison:
```
<TextBlock Text="{Binding PropertyName}"/>
```
Une autre façon est de simplement donner un nom à l'élément racine du XAML:
```
x:Name="root"
```
Depuis le XAML est compilé comme une classe partielle du code-behind, nous pouvons avoir accès à la propriété par nom:
```
<TextBlock Text="{Binding ElementName="root" Path=PropertyName}"/>
```
Remarque: l'accès est uniquement disponible pour les propriétés; pas de champs. set; et get; ou {Binding Mode = OneWay} sont nécessaires. Si OneWay de liaison est utilisé, les données sous-jacentes devraient mettre en œuvre INotifyPropertyChanged.
- Merci! Cette réponse m'a aidé. Je ne pouvais pas utiliser le DataContext de la méthode parce que je suis de la création d'un contrôle de l'utilisateur, et si j'ai mis le contexte de données au sein de mon contrôle, puis de ma volonté de ne pas être en mesure d'obtenir le datacontext de ses parents quand je l'utilise dans les applications. Se liant directement à la racine m'a donné le même résultat que je cherchais et les feuilles de mon contrôle, les données de contexte intacte.
- Le "{Binding PropertyName}" ne fonctionne que sur une propriété publique.
- Merci pour la "racine" des conseils. Il fonctionne en dépit de propriétés de code-behind ne sont pas répertoriés dans visual concepteur de liaison qui est un peu déroutant.
InformationsquelleAutor yossharel

Pour quick-and-dirty Windows WPF, je préfère de liaison le DataContext de la Fenêtre pour la fenêtre elle-même; cela peut être fait dans le code 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";
    }
}

Dans l'exemple ci-dessus, note la liaison utilisé dans le DataContext bien sur la Fenêtre, ce qui dit "Mis à votre contexte de données vous-même". Les deux blocs de texte sont liés à MyProperty1 et MyProperty2, le gestionnaire d'événement pour le bouton définir ces valeurs, qui seront automatiquement propagées à la Text la propriété des deux TextBlocks que les propriétés sont des Propriétés de Dépendance.

InformationsquelleAutor Phil Price

3

Il est également intéressant de noter qu'un "Liant" ne peut être réglé que sur une DependencyProperty de DependencyObject. Si vous souhaitez définir un non DependencyProperty (eg. une propriété classique) sur un objet dans le code XAML, alors vous devrez utiliser Robert de la première méthode de l'utilisation des ressources dans le code derrière.

InformationsquelleAutor Sheridan

Vous devez vous connecter pour publier un commentaire.