WPF / C# mise à Jour de changement de propriété d'un élément dans une ObservableCollection à la zone de liste

J'ai une zone de liste:

<ListBox x:Name="lbxAF" temsSource="{Binding}">

qui obtient ses données de cette de cette nouvelle Collection Observable:

public ObservableCollectionEx<FileItem> folder = new ObservableCollectionEx<FileItem>();

qui est créé à l'intérieur d'une classe qui utilise FileSystemWatcher pour surveiller un dossier spécifique pour l'ajout, la suppression et la modification de fichiers.

L'ObservableCollection a été modifié (d'où son Ex à la fin) pour que je puisse le modifier à partir d'un filetage extérieur (le code n'est pas le mien, j'ai fait des recherche par le biais de ce site web et l'ont trouvé, il fonctionne comme un charme):

    //This is an ObservableCollection extension
    public class ObservableCollectionEx<T> : ObservableCollection<T>
    {
        //Override the vent so this class can access it
        public override event System.Collections.Specialized.NotifyCollectionChangedEventHandler CollectionChanged;

        protected override void OnCollectionChanged(System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
        {
            using (BlockReentrancy())
            {
                System.Collections.Specialized.NotifyCollectionChangedEventHandler eventHanlder = CollectionChanged;
                if (eventHanlder == null)
                    return;

                Delegate[] delegates = eventHanlder.GetInvocationList();

                //Go through the invocation list
                foreach (System.Collections.Specialized.NotifyCollectionChangedEventHandler handler in delegates)
                {
                    DispatcherObject dispatcherObject = handler.Target as DispatcherObject;

                    //If the subscriber is a DispatcherObject and different thread do this:
                    if (dispatcherObject != null && dispatcherObject.CheckAccess() == false)
                    {
                        //Invoke handler in the target dispatcher's thread
                        dispatcherObject.Dispatcher.Invoke(DispatcherPriority.DataBind, handler, this, e);
                    }
                    //Else, execute handler as is
                    else
                    {
                        handler(this, e);
                    }
                }
            }
        }
    }

La collection est constituée de ces:

public class FileItem
{
    public string Name { get; set; }
    public string Path { get; set; }
}

qui me permettent de stocker des noms et des chemins de fichiers.

Tout fonctionne très bien aussi loin que la suppression et l'ajout de fichiers, et la Zone de Liste est mise à jour sans faille à l'égard de ces deux... cependant, si je change le nom de tous les fichiers, il n'a pas de mise à jour de la zone de liste.

Comment aurais-je informer zone de liste des changements dans FileItem propriétés? Je suppose que ObservableCollection réagirais, mais apparemment, il hisse le drapeau uniquement lorsque FileItem est ajouté ou supprimé, pas quand son contenu est modifié.

  • Votre FileItem n'est pas la mise en œuvre de INotifiyPropertyChanged...aussi comment êtes-vous mise à jour de nom de fichier dans le viewmodel/code-behind?
InformationsquelleAutor B.K. | 2013-09-11
  1. 9

    Votre FileItem classe doit implémenter INotifyPropertyChanged. Ci-dessous est un simple travail de mise en œuvre.

    public class FileItem : INotifyPropertyChanged
{
    private string _Name;

    public string Name
    {
        get { return _Name; }
        set {
            if (_Name != value)
            {
                _Name = value;
                OnPropertyChanged("Name");
            }
        }
    }

    private string _Path;

    public string Path
    {
        get { return _Path; }
        set {
            if (_Path != value)
            {
                _Path = value;
                OnPropertyChanged("Path");
            }
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;

    public void OnPropertyChanged(String propertyName)
    {
        if (PropertyChanged != null)
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }


}
    InformationsquelleAutor Anand Murali
  2. 3

    C'est ainsi que le ObservableCollection fonctionne - il surveille l'insertion, la suppression ou le déplacement d'éléments.

    Mettre à jour la Vue lors de chaque élément (ou FileItem, dans votre cas), les changements, les FileItem doit mettre en œuvre INotifyPropertyChanged et le feu de l'événement approprié lorsque vous définissez chaque propriété que vous voulez observer.

    Voici un exemple de comment faire cela: http://msdn.microsoft.com/en-us/library/system.componentmodel.inotifypropertychanged.aspx

    • Comment pourrais-je aller sur le faire? J'étais à la recherche par le biais de la documentation MSDN et je suis extrêmement confus. Je suis nouveau sur WPF et C#, mais il est impératif que je reçois de ce travail.
    • J'ai mis à jour le post avec un lien vers un exemple
    • Ouais, c'est ce que je regardais. Quand j'ai essayé avec la mienne, ça n'a pas fonctionné. Il était réellement lancer une sorte d'exception.
    • Quel est l'exception? Puisque vous avez mentionné quelque chose à propos de mises à jour à partir d'un autre thread, il se pourrait que vous obtenez le cross-thread accès exception
    • J'ai juste regardé le code que AnandMurali fourni et j'ai été d'oublier de les ajouter si (PropertyChanged != null) OnPropertyChanged méthode.
    InformationsquelleAutor New Dev
  3. 1

    Essayez ce simple: 

    public class NotifyObservableCollection<TItem> : ObservableCollection<TItem>
    where TItem : class , INotifyPropertyChanged, new()
{
    #region Fields

    private Action _itemPropertyChanged;

    #endregion

    #region Constructor

    public NotifyObservableCollection(Action itemPropertyChanged)
    {
        _itemPropertyChanged = itemPropertyChanged;
    }

    #endregion

    #region Methods

    protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
    {
        if (e.Action == NotifyCollectionChangedAction.Add)
        {
            foreach (var item in e.NewItems)
            {
                var notifyItem = item as INotifyPropertyChanged;
                if (notifyItem != null)
                {
                    notifyItem.PropertyChanged += ItemPropertyChanged;
                }
            }
        }
        else if (e.Action == NotifyCollectionChangedAction.Remove)
        {
            foreach (var item in e.OldItems)
            {
                var notifyItem = item as INotifyPropertyChanged;
                if (notifyItem != null)
                {
                    notifyItem.PropertyChanged -= ItemPropertyChanged;
                }
            }
        }
        base.OnCollectionChanged(e);
    }

    #endregion

    #region Private Methods

    private void ItemPropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if(_itemPropertyChanged!=null)
        {
            _itemPropertyChanged();
        }
    }

    #endregion
}
    InformationsquelleAutor Berezh