Refresh ObservableCollection when a property in T changes - WPF MVVM

Question

I have a ListBox which I bind to an ObservableCollection in the view model. Everytime users click on the "Delete" button the Delete DelegateCommand for the specific item is executed inside the Series class and the item is removed from the Database.

I'm looking for some way to update the ObservableCollection when this happens so that the relevant item is removed from the XAML view as soon as it's deleted.

Currently this is not happening, I'm relatively new to WPF and have been trying to get this working for days, please suggest where I'm going wrong:

Relevant XAML:

View model:

using System;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Data;
using SeriesTracker.Functions;
using System.Linq;

namespace SeriesTracker.Client
{
    public class SeriesTrackerViewModel : INotifyPropertyChanged
    {
        public DelegateCommand NewSeries { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;

        private ObservableCollection _series = new ObservableCollection();
        public ObservableCollection SeriesCollection
        {
            get { return _series; }
            set
            {
                _series = value;
                RaisePropertyChanged("SeriesCollection");
            }
        }

        public SeriesTrackerViewModel()
        {
            NewSeries = new DelegateCommand(AddNewSeries);

            DataTable table = DataAccessLayer.GetSeries();
            if (table.Rows.Count > 0)
                LoadSeries(table);
        }

        private void LoadSeries(DataTable table)
        {
            foreach (DataRow row in table.Rows)
            {
                int id = Int32.Parse(row["Id"].ToString());
                string name = row["Name"].ToString();

                int season = 0;
                int episode = 0;

                if (Int32.TryParse(row["Season"].ToString(), out season) &&
                    Int32.TryParse(row["Episode"].ToString(), out episode))
                {
                    var series = new Series(id, name, season, episode);
                    SeriesCollection.Add(series);
                }
            }
        }

        public void AddNewSeries()
        {
            SeriesCollection.AddSeries();
        }

        private void RaisePropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Series class:

using System;
using System.ComponentModel;
using System.Collections.ObjectModel;

namespace SeriesTracker.Functions
{
    public class Series : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        private DelegateCommand _save;
        public DelegateCommand Save 
        {
            get { return _save; }
            set
            {
                _save = value;
                RaisePropertyChanged("Save");
            }
        }

        private DelegateCommand _delete;
        public DelegateCommand Delete 
        { 
            get{return _delete;}
            set
            {
                _delete = value;
                RaisePropertyChanged("Delete");
            }
        }

        public int Id { get; set; }

        string _name;
        public String Name
        {
            get { return _name; } 
            set
            {
                _name = value;
                RaisePropertyChanged("Name");
            }
        }

        int _season;
        public Int32 Season 
        {
            get { return _season; } 
            set
            {
                _season = value;
                RaisePropertyChanged("Season");
            }
        }

        int _episode;
        public Int32 Episode 
        {
            get { return _episode; }
            set
            {
                _episode = value;
                RaisePropertyChanged("Episode");
            }
        }

        string _information;
        public String Information 
        {
            get { return _information; }
            set
            {
                _information = value;
                RaisePropertyChanged("Information");
            }
        }

        public Series(int id,string name,int season, int episode)
        {
            Id = id;
            Name = name;
            Season = season;
            Episode = episode;

            Save = new DelegateCommand(SaveItem);
            Delete = new DelegateCommand(DeleteItem);
        }

        public void DeleteItem()
        {
            var selectedItem = this;
            if (selectedItem.Id != -1)
            {
                DataAccessLayer.Delete(selectedItem.Id);
            }
        }

        public void SaveItem()
        {
            var selectedItem = this;
            if (selectedItem.Id == -1)
                DataAccessLayer.AddEntry(selectedItem.Name,selectedItem.Season,selectedItem.Episode);
            else
                DataAccessLayer.Update(selectedItem.Id,
                    selectedItem.Name,selectedItem.Season,selectedItem.Episode);
        }

        private void RaisePropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null)
                handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

pchajer · Accepted Answer

You should not keep the DeleteCommand in Series class, it should be on the view model.

And in view model you can easily update the ObservableCollection.

You need to use Generic delegate command of Type Series on ViewModel and on XAML you need to pass {Binding} on command Parameter.

View Model C#:-

DelegateCommand DeleteCommand { get; set; } 
DeleteCommand = new RelayCommand(OnDelete); 

// This method will gets execute on click the of Delete Button1
private void OnDelete(Series series) 
{
}

XAML :- On Delete button change the binding and command parameter value

CommandParameter="{Binding }"
Command="{Binding DataContext.DeleteCommand, RelativeSource={RelativeSource Mode=FindAncestor, AncestorType={x:Type Window}}}"

Hope this will help you

Refresh ObservableCollection<T> when a property in T changes - WPF MVVM

Answers (2)

Related Questions

Refresh ObservableCollection&lt;T&gt; when a property in T changes - WPF MVVM

Answers (2)

Related Questions

Refresh ObservableCollection<T> when a property in T changes - WPF MVVM