MVVM RadGridView doesnt reefresh

[Marcin]

I start to use mvvm pattern and i have situation like this:
On my View I have RadGridView implement in this way. On View exist button "Edit". When user click on this button i show new window to edit SelectedNews (in constructor i give this object). I implement IEditableObject on NewsModelItem. Problem is that when i click "Close" on my edit window and i call NewModelitem.EndEdit() my RadGridView is not refresh.

<telerik:RadGridView  DockPanel.Dock="Top" Width="auto"  SelectedItem="{Binding SelectedNews,Mode=TwoWay}"
                                    ItemsSource="{Binding NewsModelDTO.NewsItems}"
                                    Grid.Row="0"
                                    AutoGenerateColumns="False"
                                    CanUserDeleteRows="False"
                                    CanUserInsertRows="False"
                                    CanUserSelect="True"
                                    GridLinesVisibility="Horizontal"
                                    ShowInsertRow="False"
                                    ShowGroupFooters="False"
                                    ShowColumnHeaders="True"
                                    RowIndicatorVisibility="Collapsed">
              <telerik:RadGridView.Columns>
                      <telerik:GridViewDataColumn Header="Usuń" DataMemberBinding="{Binding NewsIsSelected}"
                         IsReadOnly="True">
                          <telerik:GridViewDataColumn.CellTemplate>
                              <DataTemplate>
                                  <CheckBox IsChecked="{Binding NewsIsSelected, Mode=TwoWay}"/>
                              </DataTemplate>
                          </telerik:GridViewDataColumn.CellTemplate>
                      </telerik:GridViewDataColumn>
                      <telerik:GridViewDataColumn IsReadOnly="True" MaxWidth="200"  Header="Nazwa" DataMemberBinding="{Binding NewsTitle}" />
                      <telerik:GridViewDataColumn IsReadOnly="True" Width="0.4*" Header="Treść" DataMemberBinding="{Binding NewsText}" />
                      <telerik:GridViewDataColumn IsReadOnly="True" Width="120"  Header="Uruchom" DataMemberBinding="{Binding NewsDateFrom}"/>
                      <telerik:GridViewDataColumn IsReadOnly="True" Width="120"  Header="Zakończ" DataMemberBinding="{Binding NewsDateTo}"/>
                      <telerik:GridViewCheckBoxColumn IsReadOnly="True" Width="120" Header="Czy aktywny" DataMemberBinding="{Binding NewsIsactive}"/>
              </telerik:RadGridView.Columns>
              </telerik:RadGridView>

In my VM class i have:

public class UcCommunicatesViewModel : ViewModelBase
    {
        private NewsModelDTO newsModelDTO = new NewsModelDTO();
        private NewsServiceClient newsService;
        private NewsItemModel selectedNews;
        private RelayCommand addNewsCommand;
        private RelayCommand editNewsCommand;
        private RelayCommand deleteNewsCommand;

        public RelayCommand AddNewsCommand
        {
            get
            {
                if (addNewsCommand == null)
                {
                    addNewsCommand = new RelayCommand(param => this.AddNewNews(),
                        param => this.CanAddNewNews());
                }
                return addNewsCommand;

            }
        }

        public RelayCommand EditNewsCommand
        {
            get
            {
                if (editNewsCommand == null)
                {
                    editNewsCommand = new RelayCommand(param => this.EditNews(),
                        param => this.CanEditNews());
                }
                return editNewsCommand;
            }
        }

        public RelayCommand DeleteNewsCommand
        {
            get
            {
                if (deleteNewsCommand == null)
                {
                    deleteNewsCommand = new RelayCommand(param => this.DeleteNews(),
                        param => this.CanDeleteNews());
                }
                return deleteNewsCommand;
            }
        }

        public bool CanAddNewNews()
        {

            return true;
        }

        public bool CanEditNews()
        {
            if (SelectedNews == null) return false;
            else return true;
        }

        public bool CanDeleteNews()
        {
            foreach (NewsItemModel ni in newsModelDTO.NewsItems)
            {
                if (ni.NewsIsSelected) return true;
            }
            if (SelectedNews == null) return false;
            else return true;
        }

        public void AddNewNews()
        {
            AddNewsPopup popup = new AddNewsPopup(false,new NewsItemModel());
            popup.ShowDialog();

            if (popup.DialogResult == true)
            {
                FillDataGrid();
                OnPropertyChanged("NewsModelDTO");
            }
            else
            {

            }
        }
        public void EditNews()
        {
            AddNewsPopup popup = new AddNewsPopup(true,SelectedNews);
            popup.ShowDialog();
            if (popup.DialogResult == true)
            {
                FillDataGrid();
                OnPropertyChanged("NewsModelDTO");
            }
            else
            {
                OnPropertyChanged("SelectedNews");
                OnPropertyChanged("NewsModelDTO");
            }

        }
        public void DeleteNews()
        {


        }
        public NewsServiceClient NewsService
        {
            get { return newsService; }
            set { newsService = value; }
        }

        public NewsModelDTO NewsModelDTO
        {
            get { return newsModelDTO; }
            set
            {
                newsModelDTO = value;
                OnPropertyChanged("NewsModelDTO");
            }
        }

        public NewsItemModel SelectedNews
        {
            get { return selectedNews; }
            set
            {
                selectedNews = value;
                OnPropertyChanged("SelectedNews");
            }
        }

        public UcCommunicatesViewModel()
        {
            EndpointAddress endpointAddress = new EndpointAddress("http://localhost:5737/Service/NewsService.svc");
            newsService = new NewsServiceClient(new BasicHttpBinding(), endpointAddress);
            FillDataGrid();
        }

        private void FillDataGrid()
        {
            NewsDTO newsDto = newsService.GetNews();
            NewsModelDTO NewsModelDTOCpy = new NewsModelDTO();
            foreach (NewsItem ni in newsDto.NewsItems)
            {
                NewsItemModel nim = new NewsItemModel
                (
                  ni.NewsId,
                  ni.NewsTitle,
                  ni.NewsText,
                  ni.NewsDatefrom,
                  ni.NewsDateto,
                  ni.NewsIsactive
                );
                NewsModelDTOCpy.NewsItems.Add(nim);
            }
            newsModelDTO = NewsModelDTOCpy;

        }

    }

And my edit window

public class AddNewsPopupViewModel : ViewModelBase
    {
        private NewsItemModel newsItem;
        private RelayCommand saveNewsCommand;
        private RelayCommand closeCommand;

        private NewsServiceClient newsService;
        private bool isEditMode=false;
        public event Action RequestClose;

        public AddNewsPopupViewModel(bool isEditMode, NewsItemModel newsItem)
        {
            this.newsItem = newsItem;
            this.isEditMode = isEditMode;
            if (isEditMode)
            {
               ((IEditableObject)newsItem).BeginEdit();
            }
        }

        public RelayCommand SaveNewsCommand
        {
            get
            {
                if (saveNewsCommand == null)
                {
                    saveNewsCommand = new RelayCommand(param => this.SaveNews(), param => this.CanSaveNews());
                }
                return saveNewsCommand;
            }
        }

        public RelayCommand CloseCommand
        {
            get
            {
                if (closeCommand == null)
                {
                    closeCommand = new RelayCommand(param => Close(), param => CanClose());
                }
                return closeCommand;
            }
        }

        public bool CanSaveNews()
        {
            if (newsItem.NewsText == string.Empty || newsItem.NewsTitle == string.Empty)
            {
                return false;
            }
            return true;
        }

        public NewsItemModel NewsItem
        {
            get { return newsItem; }
            set
            {
                newsItem = value;
                OnPropertyChanged("NewsItem");
            }
        }

        public void SaveNews()
        {
            EndpointAddress endpointAddress = new EndpointAddress("http://localhost:5737/Service/NewsService.svc");
            newsService = new NewsServiceClient(new BasicHttpBinding(), endpointAddress);
            if (isEditMode)
            {
                NewsItem itemToSave = ReWriteDataToServiceItem(newsItem);
                newsService.SaveEditedNews(itemToSave);
                ((IEditableObject)NewsItem).EndEdit();
                Common.MessageBox.Show("Dane zostały zapisane", "Informacja", MessageBox.MesageBoxButtons.OK, MessageBox.MessageBoxImage.Information);
                DialogResult = true;
                this.Close();
            }
            else
            {
               NewsItem itemToSave = ReWriteDataToServiceItem(newsItem);
               newsService.AddNews(itemToSave);
               Common.MessageBox.Show("Dane zostały zapisane", "Informacja", MessageBox.MesageBoxButtons.OK, MessageBox.MessageBoxImage.Information);
               DialogResult = true;
               this.Close();

            }
        }
        public NewsItem ReWriteDataToServiceItem(NewsItemModel newsItemModel)
        {
            NewsItem newsItemService = new NewsItem();
            newsItemService.NewsId = newsItemModel.NewsId;
            newsItemService.NewsText = newsItemModel.NewsText;
            newsItemService.NewsTitle = newsItemModel.NewsTitle;
            newsItemService.NewsDatefrom = newsItemModel.NewsDateFrom;
            newsItemService.NewsDateto = newsItemModel.NewsDateTo;
            newsItemService.NewsIsactive = newsItemModel.NewsIsActive;
            return newsItemService;
        }


        public virtual void Close()
        {
            if (isEditMode)
            {
               ((IEditableObject)NewsItem).CancelEdit();

            }
            if (RequestClose != null)
            {
                RequestClose();
            }
        }

        public virtual bool CanClose()
        {
            return true;
        }



    }

[Nedyalko Nikolov]

Hello Marcin,

Could you confirm that your BO (NewsModelItem) implements INotifyPropertyChanged interface?
Indeed RadGridView supports IEditableObject interface, but from a different point of view - RadGridView calls IEditableObject methods BeginEdit, EndEdit and CancelEdit accordingly, but does not react when these methods are called, since there is no event provided by IEditableObject interface which RadGridView could handle. On the other hand INotifyPropertyChanged is just what you need.
Let me know if there is something unclear.

Regards,
Nedyalko Nikolov
the Telerik team

[Marcin]

yeah i adii inotify and all works fine now - thx.