mvvm - viewmodelbase - xamarin bindingcontext

Cómo actualizar la vista desde un modelo de vista en WPF usando el diseño de MVVM

Question

Estoy usando el WFP con diseño MVVM para mi primer proyecto y estoy teniendo el problema de actualizar la vista después de procesar un comando del cliente para actualizar la entidad. En este momento, la vista puede hablar con el modelo de vista, pero el modelo de vista no pudo responder. ¿Alguien tiene alguna idea de cómo hacer que esto funcione? Gracias, Jdang

Answer 1

Debe hacer que ViewModel implemente INotifyPropertyChanged y desencadenar el evento PropertyChanged cuando cambien las propiedades de ViewModel. Suponiendo que la interfaz de usuario está vinculada a las propiedades de ViewModel, esto debería funcionar.

Answer 2

Si es nuevo en el patrón MVVM, recomiendo lo siguiente como excelentes recursos de MSDN que cubren tanto el patrón como la forma de implementarlo en las aplicaciones WPF y Silverlight:

1. Implementando el patrón MVVM
2. Escenarios MVVM avanzados

En función de lo que ha dicho, es posible que desee revisar el enlace de datos y cómo puede aprovechar las interfaces INotifyPropertyChanged , INotifyCollectionChanged e ICollectionView para habilitar la comunicación bidireccional entre sus vistas y los modelos de visualización.

El enlace de datos de Silverlight y WPF admite múltiples modos de enlace de datos. Con el enlace de datos unidireccional, los controles de UI pueden vincularse a un modelo de vista para que reflejen el valor de los datos subyacentes cuando se representa la pantalla. El enlace de datos bidireccional también actualizará automáticamente los datos subyacentes cuando el usuario lo modifique en la interfaz de usuario. Para garantizar que la UI se mantenga actualizada cuando los datos cambian en el modelo de vista, debe implementar la interfaz de notificación de cambio apropiada.

Answer 3

Además de las otras respuestas, también le sugiero que sus ViewModels extiendan DependencyObject .

Algunas personas creen que los DependencyObjects son muy pesados ​​(y pueden serlo, si creas miles de instancias de ellos) y un poco complejos para los usuarios nuevos (definitivamente hay situaciones en las que esto es cierto). Sin embargo, existen otras ventajas para DependencyObjects, como el soporte automático para la notificación de cambio de propiedad y la velocidad de evaluación de enlace.

Aquí está mi fragmento de DP (guardar como DependencyProperty.snippet en C: / Users [SU NOMBRE AQUÍ] / Documents / Visual Studio [2010, 2008] / Snippets de código / Visual C # / My Code Snippets):

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
  <CodeSnippet Format="1.0.0">
    <Header>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
      <Title>SnippetFile1</Title>
      <Author>will</Author>
      <Description>
      </Description>
      <HelpUrl>
      </HelpUrl>
      <Shortcut>dp</Shortcut>
    </Header>
    <Snippet>
      <Declarations>
        <Literal Editable="true">
          <ID>PropertyName</ID>
          <ToolTip>Property name</ToolTip>
          <Default>PropertyName</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="false">
          <ID>ClassName</ID>
          <ToolTip>Class name</ToolTip>
          <Default>ClassName</Default>
          <Function>ClassName()</Function>
        </Literal>
        <Literal Editable="true">
          <ID>Type</ID>
          <ToolTip>Property type</ToolTip>
          <Default>object</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="true">
          <ID>DefaultValue</ID>
          <ToolTip>Default value</ToolTip>
          <Default>null</Default>
          <Function>
          </Function>
        </Literal>
      </Declarations>
      <Code Language="csharp"><![CDATA[#region $PropertyName$
/// <summary>
/// The <see cref="DependencyProperty"/> for <see cref="$PropertyName$"/>.
/// </summary>
public static readonly DependencyProperty $PropertyName$Property =
    DependencyProperty.Register(
        $PropertyName$Name, 
        typeof($Type$), 
        typeof($ClassName$), 
        new UIPropertyMetadata($DefaultValue$));

/// <summary>
/// The name of the <see cref="$PropertyName$"/> <see cref="DependencyProperty"/>.
/// </summary>
public const string $PropertyName$Name = "$PropertyName$";

/// <summary>
/// $end$
/// </summary>
public $Type$ $PropertyName$
{
    get { return ($Type$)GetValue($PropertyName$Property); }
    set { SetValue($PropertyName$Property, value); }
}
#endregion  ]]></Code>
    </Snippet>
  </CodeSnippet>
</CodeSnippets>

Answer 4

En una aplicación MVVM típica, usa enlaces para conectar la vista al ViewModel. Los enlaces se actualizan automáticamente cuando ViewModel genera el evento PropertyChanged , definido por la interfaz INotifyPropertyChanged . Por lo tanto, debe implementar esa interfaz en ViewModel y generar el evento PropertyChanged cuando se modifique el valor de una propiedad, y la vista reflejará el cambio automáticamente.