La liaison de l'étiquette à une variable

Je commence tout juste avec WPF et j'essaye de configurer la liaison entre une variable locale et une étiquette. Fondamentalement, je veux mettre à jour les étiquettes lors de la variable locale changements. J'étais à la recherche d'une solution, mais ils ont tous simplement utiliser la zone de texte comme une source non seulement variable de classe et je ne suis même pas sûr que ça fonctionne de cette façon. Voici donc mon code.

public partial class MainWindow : Window
{
    int idCounter;

    public MainWindow()
    {
        InitializeComponent();


        Binding b = new Binding();
        b.Source = idCounter;
        b.Mode = BindingMode.OneWay;
        b.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;

        myLabel.SetBinding(Label.ContentProperty,b);
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        idCounter++;
    }
}

Bouton fonctionne, idCounter change de valeur, mais il ne met pas à jour l'étiquette, donc je suppose que la liaison est mauvaise. Quelqu'un peut me dire quel est le problème? Grâce

InformationsquelleAutor Safiron | 2014-05-17

binding c#controls event-handling wpf

6

Votre code ne fonctionnera que si vous modifiez votre classe à ce...
```
  public partial class Window1 : Window, INotifyPropertyChanged
    {
        private int _idCounter;
        public int IdCounter
        {
            get { return _idCounter; }
            set
            {
                if (value != _idCounter)
                {
                    _idCounter = value;
                    OnPropertyChanged("IdCounter");
                }
            }
        }
        public Window1()
        {
            InitializeComponent();
            myLabel.SetBinding(ContentProperty, new Binding("IdCounter"));
            DataContext = this;
        }
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            e.Handled = true;
            IdCounter++;
        }
        #region INotifyPropertyChanged Implementation
        public event PropertyChangedEventHandler PropertyChanged;
        protected virtual void OnPropertyChanged(string name)
        {
            var handler = System.Threading.Interlocked.CompareExchange(ref PropertyChanged, null, null);
            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(name));
            }
        }
        #endregion
    }
```
Certaines des questions que vous aviez sont...

La fenêtre elle-même doit implémenter INotifyPropertyChanged, de sorte que le moteur de liaison pouvez placer une oreille sur celui-ci.

la IdCounter doit être publique, et ont un getter publique sur elle de sorte que la liaison moteur peut " get " il.

Vous devez définir le DataContext à ce que la classe a déclaré IdCounter (le MainWindow dans ce cas). Une partie du problème est que le moteur de liaison n'avait pas de DataContext.

La BindingMode réglage était une diversion depuis une Étiquette lie que par défaut.

La UpdateSourceTrigger était une diversion puisque le contenu de l'étiquette n'est pas un mécanisme pour mettre à jour la source de la propriété. Une étiquette de contenu n'est pas comme une zone de texte où l'utilisateur peut taper quelque chose que le code a besoin de les connaître. Lorsque vous êtes à la liaison à quelque chose que l'utilisateur ne peut pas changer, oublier UpdateSourceTrigger, c'est la Cible propriété qui compte.

Le gestionnaire doit marquer l'événement. C'est une bonne pratique et n'affecte pas la liaison.

La liaison constructeur doit uniquement le chemin d'accès.

Ce code vous donnera le résultat escompté; c'est à dire, que l'étiquette des mises à jour lorsque le bouton est cliqué. Vérifié, compilé et exécuté sur vs2013, .net 4.5.

Les autres répondants ont dit que vous devez utiliser un Modèle de Vue. Je suis d'accord avec ce 100%, et dans l'ensemble c'est une bonne chose à considérer.
- Techniquement vos objets ne sont pas inherit de INotifyPropertyChange, ils implement il. Belle réponse bien.
- merci pour le très habile de la tête vers le haut. Je vais modifier. TA
InformationsquelleAutor Gayot Fow

Vous souhaitez utiliser une propriété pour ce faire, ainsi que la mise en œuvre de INotifyPropertyChanged de sorte que le label's le contenu est mis à jour lors de la modification de la propriété.

Voici un exemple en utilisant un simple ViewModel

xaml:

<Window x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:converters="clr-namespace:WpfApplication1"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel>
        <Label Width="200" Height="50" Content="{Binding MyLabel}"/>
        <Button Height="30" Width="100" Content="Increment" Click="Button_Click" />
    </StackPanel>
</Window>

xaml.cs:

namespace WpfApplication1
{
    ///<summary>
    ///Interaction logic for MainWindow.xaml
    ///</summary>
    public partial class MainWindow : Window
    {
        MainViewModel vm = new MainViewModel();
        public MainWindow()
        {
            InitializeComponent();
            this.DataContext = vm;
        }

        private void Button_Click(object sender, RoutedEventArgs e)
        {
            vm.MyLabel += 1;
        }
    }
}

MainViewModel.cs:

namespace WpfApplication1
{
    public class MainViewModel : INotifyPropertyChanged
    {
        #region Members
        private int _myLabel;
        #endregion Members

        #region Properties
        public int MyLabel
        {
            get
            {
                return _myLabel;
            }
            set
            {
                _myLabel = value;
                NotifyPropertyChanged("MyLabel");
            }
        }

        #endregion Properties

        public MainViewModel()
        {
        }

        #region INotifyPropertyChanged
        public event PropertyChangedEventHandler PropertyChanged;
        private void NotifyPropertyChanged(String propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        #endregion
    }
}

Remarque: Idéalement, vous souhaitez utiliser un Command pour la Button à la place d'un gestionnaire d'événements Click

InformationsquelleAutor d.moncada

1
1. Vous ne pouvez pas lier à quelque chose qui est privé ou d'un champ afin de le convertir en propriété publique. Vous trouverez de plus que ce qui est valable de source de liaison ici
2. Si vous souhaitez que les modifications apportées à votre propriété sera repris par de l'INTERFACE utilisateur, vous devriez mettre en œuvre INotifyPropertyChanged de l'interface et de soulever des événement chaque fois la valeur de la propriété change. Donc idCounter devrait ressembler à ceci:
```
private int _idCounter;

public int idCounter
{
    get { return _idCounter; }
    set
    {
        if (_idCounter != value)
        {
            _idCounter = value;
            OnPropertyChanged("idCounter");
        }
    }
}
```
3. Lorsque vous créez de liaison à la propriété que vous utilisez Path
4. Liaison fonctionne en contexte de liaison de sorte que vous besoin de spécifier où prendre ce Path. La plus simple façon de le faire est de fixer DataContext. Si dans votre cas, l'initialisation doit ressembler à ceci:
```
Binding b = new Binding("idCounter");
b.Mode = BindingMode.OneWay;
b.UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged;

myLabel.SetBinding(Label.ContentProperty, b);
DataContext = this;
```
5. Comme @d.moncada a suggéré dans sa réponse, vous devez créer dédié au modèle de vue
InformationsquelleAutor dkozl

Vous devez vous connecter pour publier un commentaire.