Comment puis-je lier une ObservableCollection de zones de texte dans un DataTemplate?

Je suis tenté avec succès TwoWay lier une ObservableCollection de zones de texte dans un DataTemplate. Je peux obtenir les données pour les afficher correctement, mais je suis incapable de changer les données de la liste par le biais de l'INTERFACE utilisateur. J'ai un Modèle de classe nommé "modèle" qui contient une ObservableCollection nommé 'List'. La classe implémente l'interface INotifyPropertyChanged. Voici le code xaml pour le shell. Le DataContext pour Window1 de la grille est réglé sur "theGrid.DataContext=modèle"

<Window x:Class="BindThat.Window1"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="clr-namespace:BindThat"
Title="Window1" Height="300" Width="300">
<StackPanel x:Name="theGrid">
    <GroupBox BorderBrush="LightGreen">
        <GroupBox.Header>
            <TextBlock Text="Group" />
        </GroupBox.Header>
        <ItemsControl ItemsSource="{Binding Path=List}">
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <TextBox Text="{Binding Path=., Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" />
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </GroupBox> 
</StackPanel>

C'est le code de la classe de Modèle:

class Model : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    private void NotifyPropertyChanged(string name)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(name));
    }

    private ObservableCollection<string> _list = new ObservableCollection<string>();
    public ObservableCollection<string> List
    {
        get { return _list; }
        set 
        { 
            _list = value;
            NotifyPropertyChanged("List");
        }
    }

    public Model()
    {
        List.Add("why");
        List.Add("not");
        List.Add("these?");
    }
}

Quelqu'un pourrait-il indiquer si je vais sur ce le bon chemin?

OriginalL'auteur Johnathan1 | 2009-06-30

12

Vous avez besoin d'une propriété de lier les deux sens, de sorte que la chaîne n'est pas bon pour cela.

De l'envelopper dans un objet de type string, comme ceci:
```
public class Model
{
    public ObservableCollection<StringObject> List { get; private set; }
    public Model()
    {
        List = new ObservableCollection<StringObject>
                   {
                       new StringObject {Value = "why"},
                       new StringObject {Value = "not"},
                       new StringObject {Value = "these"},
                   };
    }
}

public class StringObject
{
    public string Value { get; set; }
}
```
et de se lier à la Valeur de la propriété au lieu de "."

Aussi, vous n'avez pas besoin d'aviser d'un changement dans la collection observable, donc, jusqu'à ce que votre modèle dispose de quelques autres propertis de son propre, il n'a pas besoin d'avoir INotifyPropertyChange. Si vous voulez que votre ItemsControl réagissent aux changements de l'individu StringObjects, alors vous devriez ajouter INotifyPropertyChanged pour un StringObject.

Et encore une fois, une liaison bidirectionnelle est par défaut, de sorte que vous devez
```
<TextBox Text="{Binding Path=Value}" />
```
dans votre liaison.

Fonctionne pour moi! Merci beaucoup!!
Je ne pense pas que vous avez besoin de mettre "Path=" dans le Texte de la propriété, Text="{Binding Value}" également de travailler
Pourquoi seule chaîne de la propriété fonctionne, mais pas List<string>?

OriginalL'auteur Sergey Aldoukhov

Je crois que vous avez besoin pour tirer votre collection d'articles de DependencyObject de liaison Bidirectionnelle de travail. Quelque chose comme:

public class DependencyString: DependencyObject {
    public string Value {
        get { return (string)GetValue(ValueProperty); }
        set { SetValue(ValueProperty, value); }
    }

    public static readonly DependencyProperty ValueProperty =
        DependencyProperty.Register("Value", typeof(string), typeof(DependencyString), new UIPropertyMetadata(""));

    public override string ToString() {
        return Value;
    }

    public DependencyString(string s) {
        this.Value = s;
    }
}

public class Model {
    private ObservableCollection<DependencyString> _list = new ObservableCollection<DependencyString>();
    public ObservableCollection<DependencyString> List {
        get { return _list; }
    }

    public Model() { 
        List.Add(new DependencyString("why")); 
        List.Add(new DependencyString("not"));
        List.Add(new DependencyString("these?"));
    }
}

...

<StackPanel x:Name="theGrid">
    <GroupBox BorderBrush="LightGreen">
        <GroupBox.Header>
            <TextBlock Text="Group" />        
        </GroupBox.Header>
        <ItemsControl ItemsSource="{Binding Path=List}">
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <TextBox Text="{Binding Path=Value, Mode=TwoWay}"/>
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </GroupBox>
</StackPanel>

Je ne pense pas qu'une DependencyProperty est requis dans ce cas. Qui n'est nécessaire que si vous souhaitez lier la propriété à autre chose.
Basé sur deux idées maintenant, j'ai été capable de trouver une solution pour mon application. Je vous remercie pour votre message!!
Cela m'a beaucoup aidé, je vous remercie. La partie qui me manquait était de définir le Mode=TwoWay pour que je puisse accéder à la mise à jour des données à partir de la zone de liste.itemsSource après que l'utilisateur avait fait de leur évolution.

OriginalL'auteur Stanislav Kniazev

Vous devez vous connecter pour publier un commentaire.