WPF: cómo señalar un evento desde ViewModel a View sin código en codebehind?

Question

tengo bastante simple (espero :)) problema:

En MVVM, Vista general escucha en cambios de las propiedades del ViewModel. Sin embargo, a veces me gustaría escuchar el evento para que, por ejemplo, View pueda iniciar la animación o cerrar la ventana cuando las señales de VM.

Hacerlo a través de la propiedad bool con NotifyPropertyChanged (y comenzar la animación solo cuando cambia de falso a verdadero) es posible, pero se siente como un truco, prefiero exponer el evento, ya que es semánticamente correcto.

Además, me gustaría hacerlo sin código en código subyacente, ya que al hacer viewModel.myEvent += handler significaría que habría anulado el registro manualmente del evento para permitir que View sea GC'd - Las vistas de WPF ya son capaces de escucha las propiedades 'débilmente', y preferiría programar solo de manera declarativa en View.

La suscripción al evento fuerte estándar también es mala, porque necesito cambiar varios modelos de vista para una vista (porque la creación de la vista cada vez lleva demasiado tiempo de la CPU).

Gracias por las ideas (si hay una solución estándar, un enlace a msdn será suficiente)!

Answer 1

Algunos comentarios:

• Puede utilizar el weak event pattern para asegurar que la visión se puede GC'd incluso si todavía está unido a eventos del modelo de vista
• Si ya está cambiando múltiples máquinas virtuales para una vista, ¿no sería ese el lugar ideal para adjuntar/separar el controlador?
• Dependiendo de su escenario exacto, podría hacer que la VM exponga una propiedad de estado que la vista utiliza como activador de animaciones, transiciones y otros cambios visuales. Visual state manager es ideal para este tipo de cosas.

Answer 2

Como dijo adrianm, cuando activa su animación en una propiedad bool, en realidad está respondiendo a un evento. Específicamente el evento PropertyChanged que el subsistema WPF. Que está diseñado para conectarse/desconectarse correctamente de/para que no se pierda la memoria (puede olvidarse de hacer esto al cablear un evento usted mismo y causar una pérdida de memoria al tener una referencia activa a un objeto que de otra manera debería ser GC) .

Esto le permite exponer su ViewModel como DataContext para el control y responder correctamente al cambio de propiedades en el contexto de datos a través del enlace de datos.

MVVM es un modelo que funciona especialmente bien con WPF, porque de todas estas cosas que WPF le da, y el desencadenamiento de un cambio de propiedad es en realidad una manera elegante de utilizar todo el subsistema de WPF para lograr sus objetivos :)

Answer 3

Una pregunta más general es: "¿Por qué estoy tratando de lidiar con este evento en mi ViewModel?"

Si la respuesta tiene algo que ver con elementos de solo vista como animaciones, argumentaría que ViewModel no necesita saberlo: el código subyacente (cuando corresponda), Data/Event/Property Triggers y las construcciones más nuevas de VisualStateManager le servirá mucho mejor y mantendrá la separación limpia entre View y ViewModel.

Si algo tiene que suceder como resultado del evento, entonces lo que realmente quiere usar es un patrón de comando, ya sea usando el CommandManger, manejando el evento en el código e invocando el comando en el modelo de vista , o mediante el uso de comportamientos adjuntos en el sistema. Interactive libs.

De cualquier forma, desea mantener su ViewModel lo más "puro" que pueda: si ve algo específico de View allí, probablemente lo esté haciendo mal. :)

Answer 4

imho yYand separó

1. estado - para ser capaz de mover datos de nuevo/hacia atrás entre vista < -> vm
2. acciones - para ser capaz de llamar a las funciones de vista de modelo/comandos
3. notificaciones - para poder señalar a la vista que algo ha sucedido y desea que tome una acción visual como hacer que un elemento brille, cambiar estilos, cambiar el diseño, enfocar otro elemento, etc.

si bien es cierto que puede hacer esto con un enlace de propiedad, es más un truco como mencionó Tomas; Siempre me ha parecido así.

mi solución para poder escuchar 'eventos' desde un modelo de vista también conocido como notificaciones es simplemente escuchar cambios en el contexto de datos y cuando cambia verifico que el tipo es el que estoy buscando y conecto el eventos. crudo pero simple.

Lo que realmente me gustaría es una forma simple de definir algunos desencadenantes de 'ver evento de modelo' y luego proporcionarle algún tipo de controlador que reaccione en el lado de la vista de todas las cosas en el xaml y solo coloque el código detrás para la materia thats no factible en XAML

Answer 5

Este hilo es bastante viejo, pero me va a proporcionar mi $ 0,02 porque es algo que he luchado con y recientemente ...

similar a lo que otros dicen , pero aquí hay un ejemplo con algunos fragmentos de código ... Este ejemplo muestra cómo usar pub/sub para tener una vista suscribirse a un evento activado por la VM, en este caso hago una GridView. Volver a vincular a asegurar la GV está en sincronía con la máquina virtual ...

Ver (Sub):

using Microsoft.Practices.Composite.Events; 
using Microsoft.Practices.Composite.Presentation.Events; 

private SubscriptionToken getRequiresRebindToken = null; 

    private void SubscribeToRequiresRebindEvents() 
    { 
     this.getRequiresRebindToken = 
      EventBus.Current.GetEvent<RequiresRebindEvent>() 
      .Subscribe(this.OnRequiresRebindEventReceived, 
       ThreadOption.PublisherThread, false, 
       MemoryLeakHelper.DummyPredicate); 
    } 

    public void OnRequiresRebindEventReceived(RequiresRebindEventPayload payload) 
    { 
     if (payload != null) 
     { 
      if (payload.RequiresRebind) 
      { 
       using (this.gridView.DeferRefresh()) 
       { 
        this.gridView.Rebind(); 
       } 
      } 
     } 
    } 

    private void UnsubscribeFromRequiresRebindEvents() 
    { 
     if (this.getRequiresRebindToken != null) 
     { 
      EventBus.Current.GetEvent<RequiresRebindEvent>() 
       .Unsubscribe(this.getRequiresRebindToken); 
      this.getRequiresRebindToken = null; 
     } 
    } 

sospechoso de llamadas del método se cierran para evitar pérdidas de memoria.

ViewModel (bar):

private void PublishRequiresRebindEvent() 
{ 
     var payload = new RequiresRebindEventPayload(); 
     payload.SetRequiresRebind(); 
     EventBus.Current.GetEvent<RequiresRebindEvent>().Publish(payload); 
} 

clase de carga útil

using System; 
using Microsoft.Practices.Composite.Presentation.Events; 

public class RequiresRebindEvent 
    : CompositePresentationEvent<RequiresRebindEventPayload> 
{ 

} 

public class RequiresRebindEventPayload 
{ 
    public RequiresRebindEventPayload() 
    { 
     this.RequiresRebind = false; 
    } 

    public bool RequiresRebind { get; private set; } 

    public void SetRequiresRebind() 
    { 
     this.RequiresRebind = true; 
    } 
} 

Tenga en cuenta que también puede establecer el constructor para permitir el paso de un GUID, o alguna identificado en que se puede configurar en Pub y se puede verificar en sub para asegurarse de que pub/sub esté sincronizado.