wpf - Interacción de confirmación personalizada de prisma

mvvm notifications

Question

Creé una ventana de confirmación personalizada en una aplicación con Prism Unity, WPF y Mvvm. Necesito ayuda con las notificaciones que deben enviarse de vuelta al modelo de vista. Tengo esto en la vista de registro de detalles, llamémosle MyDetailView.

<!-- Custom Confirmation Window -->
<ie:Interaction.Triggers>
  <interactionRequest:InteractionRequestTrigger 
       SourceObject="{Binding ConfirmationRequest, Mode=TwoWay}">
     <mycontrols:PopupWindowAction1 IsModal="True"/>
  </interactionRequest:InteractionRequestTrigger>
</ie:Interaction.Triggers>

Como se muestra arriba, realicé el modo de interacción = TwoWay para que la ventana emergente de confirmación pueda devolver el resultado del botón para el botón Aceptar o Cancelar. La ventana de confirmación aparece como debería, pero no sé cómo enviar el resultado del clic del botón a mi modelo de vista, por ejemplo, MyDetailViewModel. Esa es la pregunta principal.

EDITAR: Este es el método MyDetailViewMmodel que aumenta la interacción de solicitud.

private void RaiseConfirmation()
{ConfirmationRequest
    .Raise(new Confirmation()
    {
        Title = "Confirmation Popup",
        Content = "Save Changes?"
    },  c =>{if (c.Confirmed)
{ UoW.AdrTypeRos.Submit();}

Esta es la clase PopupWindowAction1. Parte de la respuesta a la pregunta puede ser cómo implemento los métodos de notificación e interacción terminada.

class PopupWindowAction1 : PopupWindowAction, IInteractionRequestAware
{
    protected override Window GetWindow(INotification notification)
    { // custom metrowindow using mahapps
        MetroWindow wrapperWindow = new ConfirmWindow1();
        wrapperWindow.DataContext = notification;
        wrapperWindow.Title = notification.Title;

        this.PrepareContentForWindow(notification, wrapperWindow);

        return wrapperWindow;
    }

    public INotification Notification
    {
        get { throw new NotImplementedException(); }
        set { throw new NotImplementedException(); }
    }

    public Action FinishInteraction
    {
        get { throw new NotImplementedException(); }
        set { throw new NotImplementedException(); }
    }
}

¿Hay alguna interacción que necesito poner en mi ConfirmWindow1, algo como esto?

<i:Interaction.Triggers>
  <i:EventTrigger EventName="PreviewMouseLeftButtonUp">
    <ei:CallMethodAction 
      TargetObject="{Binding RelativeSource={RelativeSource AncestorType=UserControl}, 
        Path=DataContext}"
      MethodName="DataContext.ValidateConfirm"/>
  </i:EventTrigger>
</i:Interaction.Triggers>

¿Necesito hacer ese tipo de interacción dentro del botón? Si es así, ¿cómo codifico que necesita para que se corresponda con el modelo de vista particular que invocó la interacción? ¿Alguna sugerencia? Gracias.

Answer 1

Lo principal es que, cuando aumenta la interacción, proporciona una devolución de llamada que se activa cuando la interacción finaliza. Esta devolución de llamada recupera la notificación y su interacción debería haber almacenado todos los valores de retorno potencialmente interesantes allí.

Aquí hay un ejemplo ...

Partes relevantes de ViewModel:

public InteractionRequest<SelectQuantityNotification> SelectQuantityRequest
{
    get;
}

// in some handler that triggers the interaction
SelectQuantityRequest.Raise( new SelectQuantityNotification { Title = "Load how much stuff?", Maximum = maximumQuantity },
    notification =>
    {
        if (notification.Confirmed)
            _worldStateService.ExecuteCommand( new LoadCargoCommand( sourceStockpile.Stockpile, cartViewModel.Cart, notification.Quantity ) );
    } );

... y desde la Vista:

<i:Interaction.Triggers>
    <interactionRequest:InteractionRequestTrigger 
        SourceObject="{Binding SelectQuantityRequest, Mode=OneWay}">
        <framework:FixedSizePopupWindowAction>
            <interactionRequest:PopupWindowAction.WindowContent>
                <views:SelectSampleDataForImportPopup/>
            </interactionRequest:PopupWindowAction.WindowContent>
        </framework:FixedSizePopupWindowAction>
    </interactionRequest:InteractionRequestTrigger>
</i:Interaction.Triggers>

Además, necesitamos una clase para contener los datos que se pasan y un par ViewModel / View para la interacción en sí.

Aquí está la clase de retención de datos (tenga en cuenta que el Maximum se pasa a la interacción y la Quantity devuelta ):

internal class SelectQuantityNotification : Confirmation
{
    public int Maximum
    {
        get;
        set;
    }

    public int Quantity
    {
        get;
        set;
    }
}

Esta es la vista de la ventana emergente de interacción:

<UserControl x:Class="ClientModule.Views.SelectSampleDataForImportPopup"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
         xmlns:prism="http://prismlibrary.com/"
         prism:ViewModelLocator.AutoWireViewModel="True"
         mc:Ignorable="d" 
         d:DesignHeight="300" d:DesignWidth="300">
    <StackPanel Orientation="Vertical">
        <TextBlock>
            Amount: <Run Text="{Binding Quantity}"/>
        </TextBlock>
        <Slider Orientation="Horizontal" Minimum="0" Maximum="{Binding Maximum}" Value="{Binding Quantity}" TickPlacement="BottomRight"/>
        <Button Content="Ok" Command="{Binding OkCommand}"/>
    </StackPanel>
</UserControl>

y es ViewModel:

internal class SelectSampleDataForImportPopupViewModel : BindableBase, IInteractionRequestAware
{
    public SelectSampleDataForImportPopupViewModel()
    {
        OkCommand = new DelegateCommand( OnOk );
    }

    public DelegateCommand OkCommand
    {
        get;
    }

    public int Quantity
    {
        get { return _notification?.Quantity ?? 0; }
        set
        {
            if (_notification == null)
                return;
            _notification.Quantity = value;
            OnPropertyChanged( () => Quantity );
        }
    }

    public int Maximum => _notification?.Maximum ?? 0;

    #region IInteractionRequestAware
    public INotification Notification
    {
        get { return _notification; }
        set
        {
            SetProperty( ref _notification, value as SelectQuantityNotification );
            OnPropertyChanged( () => Maximum );
            OnPropertyChanged( () => Quantity );
        }
    }

    public Action FinishInteraction
    {
        get;
        set;
    }
    #endregion

    #region private
    private SelectQuantityNotification _notification;

    private void OnOk()
    {
        if (_notification != null)
            _notification.Confirmed = true;
        FinishInteraction();
    }
    #endregion
}