wpf - implementar - Pasar parámetros entre viewmodels

wpf c# mvvm

Question

En mi aplicación tengo 2 visitas. Lista (GridView) y Formulario. Estoy cambiando las vistas según lo propuesto en este hilo: WPF MVVM switch usercontrols

Ahora tengo un problema sobre cómo pasar la identificación del elemento seleccionado después de hacer clic en editar para mostrar la nueva Vista con el formulario de edición.

Aplicación simple para enumerar todos los artículos, agregar nuevos, eliminar y editar. ¿Cómo puedo hacer esto en MVVWM?

ACTUALIZAR

Solo quiero crear una aplicación simple, que tenga un menú a la izquierda con:

1. Lista
2. Agregar nuevo

Cuando hace clic en Lista, muestra UC con la lista y 3 botones: Agregar, Editar, Eliminar. Después de hacer clic en Agregar, edita muestra UC con Formulario con valores específicos (durante la edición). ¿¿Cómo puedo conseguir esto??

Answer 1

Si tiene un padre común de los modelos de vista, puede usar ese elemento primario para pasar los valores de los parámetros por usted. Simplemente configure uno o más delegate en los modelos de vista relevantes:

En el modelo de vista con el parámetro relevante para actualizar ... vamos a llamarlo ParameterViewModel :

public delegate void ParameterChange(string parameter);
public ParameterChange OnParameterChange { get; set; }

En el padre:

ParameterViewModel viewModel = new ParameterViewModel();
viewModel.OnParameterChange += ParameterViewModel_OnParameterChange;
ListMenu.Add(viewModel);
// Add other view models

De vuelta en ParameterViewModel cuando el parámetro cambia:

public string Parameter
{
get { return parameter; }
set
{
parameter = value;
NotifyPropertyChanged("Parameter");
// Always check for null
if (OnParameterChange != null) OnParameterChange(parameter);
}
}

Ahora en el modelo de vista padre:

public void ParameterViewModel_OnParameterChange(string parameter)
{
// Do something with the new parameter data here
AnotherViewModel anotherViewModel = (AnotherViewModel)ListMenu[someIndex];
anotherViewModel.Parameter = parameter;
}

Puede encontrar más información sobre el uso de objetos delegate de la página Delegados (Guía de programación C #) en MSDN.

Answer 2

Por lo que yo entiendo, quieres algo como esto:

De modo que cuando haga clic en Add , se muestre esto:

¿Derecha?

Entonces necesitas el siguiente comportamiento:

• Agregar no necesita ninguna ID.
• La lista debe volver a cargarse después de que Add finalice.
• Editar recibe la ID del elemento seleccionado de la lista.
• La lista debe volver a cargarse después de que Add finalice.

Asumiré que estás trabajando con algún repositorio.

Propongo la siguiente estructura de MVVM:

• MainViewModel : DataContext para la pantalla principal.
  • BaseViewModel RightViewModel : El contenedor para viewmodels que se muestra en la parte derecha de la pantalla.
  • ICommand ViewListCommand : muestra la lista creando una nueva instancia de ListViewModel y asignándola a la propiedad BaseViewModel .
  • ICommand AddNewCommand : muestra la pantalla addnew creando una nueva instancia de AddViewModel y asignándola a la propiedad BaseViewModel .

Entonces:

• ListViewModel : DataContext para la parte derecha de la pantalla cuando se hace clic en la lista.
  • List<Items> Items : proporciona los elementos que se mostrarán.
  • Item SelectedItem : la propiedad que se vinculará al SelectedItem en la interfaz de usuario.
  • ICommand EditCommand : el comando que obtendrá el elemento seleccionado y notificará al MainViewModel que debe editarse.

Entonces, en algún momento, un modelo de vista recibirá una notificación de un modelo de vista hijo (es decir, la lista le dirá al principal que edite algo). Recomiendo hacer esto usando eventos como:

public class Item
{
public string Name { get; set; }
}
public class ItemEventArgs : EventArgs
{
public Item Item { get; set; }
public ItemEventArgs(Item selectedItem)
{
this.Item = selectedItem;
}
}
public class BaseViewModel
{
}
public class ListViewModel : BaseViewModel
{
public event EventHandler<ItemEventArgs> EditItem;
public Item SelectedItem { get; set; }
public ICommand EditItemCommand { get; private set; }
public ListViewModel()
{
this.EditItemCommand = new DelegateCommand(() => this.EditItem(this, new ItemEventArgs(this.SelectedItem)));
}
}
public class EditViewModel : BaseViewModel
{
}
public class MainViewModel
{
public BaseViewModel RightViewModel { get; private set; }
public ICommand ViewListCommand { get; private set; }
public MainViewModel()
{
this.ViewListCommand = new DelegateCommand(() =>
{
// unhook possible previous events
var listViewModel = new ListViewModel();
listViewModel.EditItem += listViewModel_EditItem;
this.RightViewModel = listViewModel;
});
}
void listViewModel_EditItem(object sender, ItemEventArgs e)
{
// unhook possible previous events
var editViewModel = new EditViewModel();
this.RightViewModel = editViewModel;
}
}

El enlace xaml no es necesario ya que será bastante directo.

Este es un ejemplo muy básico sobre cómo creo que se puede manejar este tipo de cosas. Lo importante aquí es desenganchar correctamente los eventos, de lo contrario, puede tener problemas.

Para este tipo de cosas, también puedes echarle un vistazo a UI reactiva .