Mvvm 正确处理viewmodel集合

我正在为Xamarin.Forms应用程序使用prism框架

这是一种常见的情况，但它让我头痛

MainPage
 - MainPageViewModel
  - ObserveableCollection<SomePageViewModel>

public class MainPageViewModel : BaseViewModel
{
    private ObservableCollection<SomePageViewModel> viewModels;

    public MainPageViewModel(INavigationService navigationService) : base(navigationService)
    {
        SomePageSelectedCommand = DelegateCommand.FromAsyncHandler(NavigateToSomePage);
    }

    public ICommand SomePageSelectedCommand { get; private set; }

    public ObservableCollection<SomePageViewModel> ViewModels
    {
        get { return viewModels; }
        set { SetProperty(ref viewModels, value); }
    }   

    private async Task NavigateToSomePage(SomePageViewModel viewModel)
    {
        var navParams = new NavigationParameters
        {
               {viewModel.typeof(SomePageViewModel).Name, viewModel}
        };
        await Navigation.NavigateAsync(NavigationConstants.SomePageUri, navParams, false);
    }
}

public class SomePageViewModel : BaseViewModel
{
    protected SomeModel someModel;

    public SomePageViewModel(INavigationService navigationService) : base(navigationService)
    {
        someModel = new SomeModel();
        EditCommand = DelegateCommand.FromAsyncHandler(Edit);
    }

    public ICommand EditCommand { get; private set; }

    public string Name
    {
        get { return SomeModel.Name; }
        set { SetProperty(ref SomeModel.Name, value); }
    }

    public string Description
    {
        get { return SomeModel.Description; }
        set { SetProperty(ref SomeModel.Description, value); }
    }   

    public override void OnNavigatedTo(NavigationParameters parameters)
    {
        if (parameters.ContainsKey(typeof(SomePageViewModel).Name))
        {
            var viewModel = (SomePageViewModel)parameters[typeof(SomePageViewModel).Name];
            Name = viewModel.Name;
            Description = viewModel.Name;
        }       
    }

    private async Task Edit()
    {
        var navParams = new NavigationParameters
        {
            {viewModel.typeof(SomePageViewModel).Name, this}
        };
        await Navigation.NavigateAsync(NavigationConstants.SomePageEditUri, navParams, false);
    }   
}

public class SomePageEditViewModel : BaseViewModel
{
    public SomePageEditViewModel(INavigationService navigationService) : base(navigationService)
    {
        SaveCommand = DelegateCommand.FromAsyncHandler(Save);
    }

    public ICommand SaveCommand { get; private set; }

    private async Task Save()
    {
        App.ContentService.Save(someModel);
        await Navigation.GoBackAsync();
    }
}

MainPage
-MainPageViewModel
-可观测采集
公共类MainPageViewModel:BaseViewModel
{
私有可观察收集视图模型；
公共主页视图模型（INavigationService navigationService）：基础（navigationService）
{
SomePageSelectedCommand=DelegateCommand.FromAsyncHandler（NavigateToSomePage）；
}
public ICommand SomePageSelectedCommand{get；private set；}
公共可观测集合视图模型
{
获取{return viewModels；}
set{SetProperty（ref viewModels，value）；}
}   
专用异步任务NavigateToSomePage（SomePageViewModel viewModel）
{
var navParams=新的导航参数
{
{viewModel.typeof（SomePageViewModel.Name，viewModel}
};
等待Navigation.NavigateAsync（NavigationConstants.SomePageUri，navParams，false）；
}
}
公共类SomePageViewModel:BaseViewModel
{
保护SomeModel SomeModel；
公共SomePageViewModel（INavigationService导航服务）：基础（导航服务）
{
someModel=新的someModel（）；
EditCommand=DelegateCommand.FromAsyncHandler（编辑）；
}
公共ICommand EditCommand{get；private set；}
公共字符串名
{
获取{return SomeModel.Name；}
设置{SetProperty（ref SomeModel.Name，value）；}
}
公共字符串描述
{
获取{return SomeModel.Description；}
set{SetProperty（ref SomeModel.Description，value）；}
}   
公共覆盖无效OnNavigatedTo（NavigationParameters）
{
if（parameters.ContainsKey（typeof（SomePageViewModel.Name））
{
var viewModel=（SomePageViewModel）参数[typeof（SomePageViewModel）.Name]；
Name=viewModel.Name；
Description=viewModel.Name；
}       
}
专用异步任务编辑（）
{
var navParams=新的导航参数
{
{viewModel.typeof（SomePageViewModel.Name，this}
};
等待Navigation.NavigateAsync（NavigationConstants.SomePageEditUri，navParams，false）；
}   
}
公共类SomePageEditViewModel:BaseViewModel
{
公共SomePageEditViewModel（INavigationService导航服务）：基础（导航服务）
{
SaveCommand=DelegateCommand.FromAsyncHandler（保存）；
}
公共ICommand SaveCommand{get；private set；}
专用异步任务保存（）
{
App.ContentService.Save（someModel）；
等待导航。GoBackAsync（）；
}
}

因此，让我们从

MainPage

导航到

SomePage

。我们希望编辑它，以便随后导航到

SomePageEdit

，最后保存

---

根据mvvm/prsim，什么是使更改对SomePage和主页可见的正确方法？对于第一个，我可以将更改作为NavigationParameter传递到GoBackAsync。但是主页呢

看来你的设计有点问题。要正确构建您想要的应用程序，请执行以下操作：

模型 模型集合页面视图模型

公共类TodoItemListPageViewModel:BaseViewModel，INavigationAware
{
私有INavigationService_导航服务{get；}
public-TodoItemListViewModel（INavigationService导航服务）
{
_导航服务=导航服务；
TodoItems=新的ObserverAgeCollection（）；
AddTodoItemCommand=新的DelegateCommand（OnAddTodoItemCommandExecuted）；
EditTodoItemCommand=新的DelegateCommand（onedittodoitemcommand已执行）；
}
公共ObserverAgeCollection TodoItems{get；}
公共DelegateCommand AddTodoItemCommand{get；}
公共DelegateCommand EditoDoItemCommand{get；}
导航到上的公共void（导航参数）
{
//初始化集合
}
public void OnNavigatedTo（NavigationParameters）
{
if（parameters.GetValue（KnownNavigationParameters.NavigationMode）=NavigationMode.Back）
{
//选择1
//从数据源获取更新的TodoItems列表
TodoItems.ReplaceRange（更新的TodoItems）；
//选择2
//替换更新的项目或添加新项目
}
}

编辑模型页面视图模型

public void OnNavigatedFrom（NavigationParameters）
{
}
私有异步void OnAddTodoItemCommandExecuted（）=>
wait_navigationService.NavigateAsync（“AddTodoItemPage”）；
private async void OnEditTodoItemCommandExecuted（TodoItem项）=>
wait{u navigationService.NavigateAsync（“EditTodoItemPage”，新的导航参数{{“item”，item}）；
}
公共类EditTodoItemPageViewModel:BaseViewModel
{
私有INavigationService_导航服务{get；}
公共编辑ToDoiTempageViewModel（INavigationService导航服务）
{
_导航服务=导航服务；
SaveCommand=newdelegateCommand（OnSaveCommandExecuted，（）=>IsNotBusy）
.observeProperty（（）=>IsBusy）；
}
私有TodoItem模型；
公共TodoItem模型
{
获取{return\u model；}
set{SetProperty（ref_model，value）；}
}
公共DelegateCommand SaveCommand{get；}
导航到上的公共void（导航参数）
{
模型=参数。GetValue（“项目”）；
}
私有异步void OnSaveCommandExecuted（）
{
IsBusy=true；
//坚持任何改变
//选择1
wait_navigationService.GoBackAsync（）；
//选择2
wait_navigationService.GoBackAsync（新的导航参数{{“updateItem”，Model}）；
IsBusy=false；
}
}

为什么。。。 您的ObservableCollection应该是

where
public class TodoItem : ObservableObject
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set { SetProperty(ref _name, value); }
    }

    private bool _done;
    public bool Done
    {
        get { return _done; }
        set { SetProperty(ref _done, value); }
    }
}

public class TodoItemListPageViewModel : BaseViewModel, INavigationAware
{
    private INavigationService _navigationService { get; }
    public TodoItemListViewModel(INavigationService navigationService)
    {
        _navigationService = navigationService;
        TodoItems = new ObservableRangeCollection<TodoItem>();
        AddTodoItemCommand = new DelegateCommand(OnAddTodoItemCommandExecuted);
        EditTodoItemCommand = new DelegateCommand<TodoItem>(OnEditTodoItemCommandExecuted);
    }

    public ObservableRangeCollection<TodoItem> TodoItems { get; }

    public DelegateCommand AddTodoItemCommand { get; }

    public DelegateCommand<TodoItem> EditTodoItemCommand { get; }

    public void OnNavigatingTo(NavigationParameters parameters)
    {
        // Initialize your collection
    }

    public void OnNavigatedTo(NavigationParameters parameters)
    {
        if(parameters.GetValue<NavigationMode>(KnownNavigationParameters.NavigationMode) == NavigationMode.Back)
        {
            // Option 1
            // Fetch an updated list of TodoItems from your data source
            TodoItems.ReplaceRange(updatedTodoItems);

            // Option 2
            // Replace the updated item or add a new item
        }
    }

    public void OnNavigatedFrom(NavigationParameters parameters)
    {

    }

    private async void OnAddTodoItemCommandExecuted() =>
        await _navigationService.NavigateAsync("AddTodoItemPage");

    private async void OnEditTodoItemCommandExecuted(TodoItem item) =>
        await _navigationService.NavigateAsync("EditTodoItemPage", new NavigationParameters { { "item", item } });
}

public class EditTodoItemPageViewModel : BaseViewModel
{
    private INavigationService _navigationService { get; }
    public EditTodoItemPageViewModel(INavigationService navigationService)
    {
        _navigationService = navigationService;
        SaveCommand = new DelegateCommand(OnSaveCommandExecuted, () => IsNotBusy)
                            .ObservesProperty(() => IsBusy);
    }

    private TodoItem _model;
    public TodoItem Model
    {
        get { return _model; }
        set { SetProperty(ref _model, value); }
    }

    public DelegateCommand SaveCommand { get; }

    public void OnNavigatingTo(NavigationParameters parameters)
    {
        Model = parameters.GetValue<TodoItem>("item");
    }

    private async void OnSaveCommandExecuted()
    {
        IsBusy = true;
        // Persist any changes

        // Option 1
        await _navigationService.GoBackAsync();

        // Option 2
        await _navigationService.GoBackAsync(new NavigationParameters { { "updatedItem", Model } });
        IsBusy = false;
    }
}