Passing DataContext between windows in MVVM

Question

On the main window onClick I have

AddNoticeAboutWrongCity addNoticeAboutWrongCity = new AddNoticeAboutWrongCity();
addNoticeAboutWrongCity.DataContext = ((VerificationViewModule)this.DataContext).WrongCityNotice;
addNoticeAboutWrongCity.ShowDialog();

At popup window there a lot of textboxes and two buttons

Delete object:

this.DataContext = null;

And second option "Save edited notice" which is not usable , because every change of user affection datacontext on main window,and this is demand from design department :)

I don't know why first option(it's "implementation" doesn't work.

Second explanation:

On the ParentWindow I have list of Notices and I can click EditSelectedNotice.

On the EditNoticeWindow I can edit Notice or delete Notice.

Editinig works(After closing EditNoticeWindow I see changed notice on the ParentWindow), but deleting doesn't (Notice is still in collection - on control and in this.DataContext)

My ViewModel:

class VerificationViewModule
    {
        public ObservableCollection<ReporterNotice> ReporterNotices { get; set; }

        public ReporterNotice OtherNotice
        {
            get
            {
                return ReporterNotices.Where(n => n.Type == ReporterNoticeType.Other).FirstOrDefault();
            }
        }
        public ReporterNotice DuplicateNotice
        {
            get
            {
                return ReporterNotices.Where(n => n.Type == ReporterNoticeType.Duplicate).FirstOrDefault();
            }
        }
        public ReporterNotice WrongCityNotice
        {
            get
            {
                return ReporterNotices.Where(n => n.Type == ReporterNoticeType.WrongCity).FirstOrDefault();
            }
            set { if(value==null)
            {
                ReporterNotices.Remove(ReporterNotices.Where(n => n.Type == ReporterNoticeType.WrongCity).First());
            }
            else
            {
                if (ReporterNotices.Where(n => n.Type == ReporterNoticeType.WrongCity).FirstOrDefault()==null)//there is always only max one instance of this type of notice
                {
                    ReporterNotices.Add(value);
                }
                else
                {
                    var c = ReporterNotices.Where(n => n.Type == ReporterNoticeType.WrongCity).First();
                    c = value;

                }
            }}
        }

         public VerificationViewModule()
        {
            ObservableCollection<ReporterNotice> loadedReporterNotices = new ObservableCollection<ReporterNotice>();
            loadedReporterNotices.Add(new ReporterNotice() { Content = "Dublic", Type = ReporterNoticeType.WrongCity });
            loadedReporterNotices.Add(new ReporterNotice() { Content = "Hilton", Type = ReporterNoticeType.Duplicate });
            loadedReporterNotices.Add(new ReporterNotice() { Content = "Another notice", Type = ReporterNoticeType.Other });
            ReporterNotices = loadedReporterNotices;
        }


    }

Answer 1

You can try the following. Implement the mediator to display windows and make sure that you use view models for the DataContext for both the main and edit windows. It is important to tell the main view model that the object is being deleted. This is done via a callback and routing that through a command on the EditNoticeViewModel

    //This viewmodel is on the main windows datacontext
public class ParentViewModel
{
    private readonly IWindowMediator _mediator;
    public ParentViewModel(IWindowMediator mediator)
    {
        _mediator = mediator;
    }

    public ObservableCollection<Notice> Notices { get; private set; } //bound to list in xaml

    public void OpenNotice(Notice notice)
    {
        //open the window using the Mediator pattern rather than a new window directly

        _mediator.Open(new EditNoticeViewModel(notice, DeleteNotice));
    }

    private void DeleteNotice(Notice notice)
    {
        //This will remove it from the main window list
        Notices.Remove(notice);
    }
}

//view model for EditNoticeWindow
public class EditNoticeViewModel
{
    public EditNoticeViewModel(Action<Notice> deleteCallback, Notice notice)
    {
        Model = notice;

        DeleteCommand = new DelegateCommand((a) => deleteCallback(Model));
    }

    //Bind in xaml to the Command of a button
    DelegateCommand DeleteCommand { get; private set; }

    //bound to the controls in the xaml.
    public Notice Model { get; private set; }
}

//This is a basic interface, you can elaborate as needed
//but it handles the opening of windows. Attach the view model
//to the data context of the window.
public interface IWindowMediator
{
    void Open<T>(T viewModel);
}

Depending on implementation you might want to close the view when the delete button gets pushed. You can do this by implementing something like the as described here with respect to WorkspaceViewModel

Answer 2

Why don't you wrap the WrongCityNotice in a viewModel implementing IReporterNotice and having a reference to the parent viewmodel and a Delete method:

public void Delete() { _parentvm.Delete(_wrongCityNotice); }

You can use this wrapper as DataContext.