在带有MVVM的wpf中使用Dialog的好还是坏做法？

我最近遇到了为wpf应用程序创建添加和编辑对话框的问题。

我想在代码中做的就是这样。（我主要在mvvm中使用viewmodel first方法）

调用对话框窗口的ViewModel：

var result = this.uiDialogService.ShowDialog("Dialogwindow Title", dialogwindowVM);
// Do anything with the dialog result

它是如何工作的？

首先，我创建了一个对话框服务：

public interface IUIWindowDialogService
{
    bool? ShowDialog(string title, object datacontext);
}

public class WpfUIWindowDialogService : IUIWindowDialogService
{
    public bool? ShowDialog(string title, object datacontext)
    {
        var win = new WindowDialog();
        win.Title = title;
        win.DataContext = datacontext;

        return win.ShowDialog();
    }
}

WindowDialog是一个特殊但简单的窗口。我需要它来保存我的内容：

<Window x:Class="WindowDialog"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    Title="WindowDialog" 
    WindowStyle="SingleBorderWindow" 
    WindowStartupLocation="CenterOwner" SizeToContent="WidthAndHeight">
    <ContentPresenter x:Name="DialogPresenter" Content="{Binding .}">

    </ContentPresenter>
</Window>

wpf中对话框的问题是dialogresult = true只能在代码中实现。这就是为什么我创建了一个接口dialogviewmodel来实现它的原因。

public class RequestCloseDialogEventArgs : EventArgs
{
    public bool DialogResult { get; set; }
    public RequestCloseDialogEventArgs(bool dialogresult)
    {
        this.DialogResult = dialogresult;
    }
}

public interface IDialogResultVMHelper
{
    event EventHandler<RequestCloseDialogEventArgs> RequestCloseDialog;
}

每当我的ViewModel认为是时候了dialogresult = true，请提出此事件。

public partial class DialogWindow : Window
{
    // Note: If the window is closed, it has no DialogResult
    private bool _isClosed = false;

    public DialogWindow()
    {
        InitializeComponent();
        this.DialogPresenter.DataContextChanged += DialogPresenterDataContextChanged;
        this.Closed += DialogWindowClosed;
    }

    void DialogWindowClosed(object sender, EventArgs e)
    {
        this._isClosed = true;
    }

    private void DialogPresenterDataContextChanged(object sender,
                              DependencyPropertyChangedEventArgs e)
    {
        var d = e.NewValue as IDialogResultVMHelper;

        if (d == null)
            return;

        d.RequestCloseDialog += new EventHandler<RequestCloseDialogEventArgs>
                                    (DialogResultTrueEvent).MakeWeak(
                                        eh => d.RequestCloseDialog -= eh;);
    }

    private void DialogResultTrueEvent(object sender, 
                              RequestCloseDialogEventArgs eventargs)
    {
        // Important: Do not set DialogResult for a closed window
        // GC clears windows anyways and with MakeWeak it
        // closes out with IDialogResultVMHelper
        if(_isClosed) return;

        this.DialogResult = eventargs.DialogResult;
    }
 }

现在至少我必须DataTemplate在资源文件（app.xaml或其他内容）中创建一个：

<DataTemplate DataType="{x:Type DialogViewModel:EditOrNewAuswahlItemVM}" >
        <DialogView:EditOrNewAuswahlItem/>
</DataTemplate>

好了，我现在可以从我的视图模型调用对话框：

 var result = this.uiDialogService.ShowDialog("Dialogwindow Title", dialogwindowVM);

现在我的问题是，您认为此解决方案有任何问题吗？

编辑：为了完整性。ViewModel应该实现IDialogResultVMHelper，然后可以在OkCommand或类似以下内容中引发它：

public class MyViewmodel : IDialogResultVMHelper
{
    private readonly Lazy<DelegateCommand> _okCommand;

    public MyViewmodel()
    {
         this._okCommand = new Lazy<DelegateCommand>(() => 
             new DelegateCommand(() => 
                 InvokeRequestCloseDialog(
                     new RequestCloseDialogEventArgs(true)), () => 
                         YourConditionsGoesHere = true));
    }

    public ICommand OkCommand
    { 
        get { return this._okCommand.Value; } 
    }

    public event EventHandler<RequestCloseDialogEventArgs> RequestCloseDialog;
    private void InvokeRequestCloseDialog(RequestCloseDialogEventArgs e)
    {
        var handler = RequestCloseDialog;
        if (handler != null) 
            handler(this, e);
    }
 }

编辑2：我使用此处的代码使EventHandler的注册功能变弱：
http : //diditwith.net/2007/03/23/SolvingTheProblemWithEventsWeakEventHandlers.aspx
（网站不再存在，WebArchive Mirror）

public delegate void UnregisterCallback<TE>(EventHandler<TE> eventHandler) 
    where TE : EventArgs;

public interface IWeakEventHandler<TE> 
    where TE : EventArgs
{
    EventHandler<TE> Handler { get; }
}

public class WeakEventHandler<T, TE> : IWeakEventHandler<TE> 
    where T : class 
    where TE : EventArgs
{
    private delegate void OpenEventHandler(T @this, object sender, TE e);

    private readonly WeakReference mTargetRef;
    private readonly OpenEventHandler mOpenHandler;
    private readonly EventHandler<TE> mHandler;
    private UnregisterCallback<TE> mUnregister;

    public WeakEventHandler(EventHandler<TE> eventHandler,
                                UnregisterCallback<TE> unregister)
    {
        mTargetRef = new WeakReference(eventHandler.Target);

        mOpenHandler = (OpenEventHandler)Delegate.CreateDelegate(
                           typeof(OpenEventHandler),null, eventHandler.Method);

        mHandler = Invoke;
        mUnregister = unregister;
    }

    public void Invoke(object sender, TE e)
    {
        T target = (T)mTargetRef.Target;

        if (target != null)
            mOpenHandler.Invoke(target, sender, e);
        else if (mUnregister != null)
        {
            mUnregister(mHandler);
            mUnregister = null;
        }
    }

    public EventHandler<TE> Handler
    {
        get { return mHandler; }
    }

    public static implicit operator EventHandler<TE>(WeakEventHandler<T, TE> weh)
    {
        return weh.mHandler;
    }
}

public static class EventHandlerUtils
{
    public static EventHandler<TE> MakeWeak<TE>(this EventHandler<TE> eventHandler, 
                                                    UnregisterCallback<TE> unregister)
        where TE : EventArgs
    {
        if (eventHandler == null)
            throw new ArgumentNullException("eventHandler");

        if (eventHandler.Method.IsStatic || eventHandler.Target == null)
            throw new ArgumentException("Only instance methods are supported.",
                                            "eventHandler");

        var wehType = typeof(WeakEventHandler<,>).MakeGenericType(
                          eventHandler.Method.DeclaringType, typeof(TE));

        var wehConstructor = wehType.GetConstructor(new Type[] 
                             { 
                                 typeof(EventHandler<TE>), typeof(UnregisterCallback<TE>) 
                             });

        IWeakEventHandler<TE> weh = (IWeakEventHandler<TE>)wehConstructor.Invoke(
                                        new object[] { eventHandler, unregister });

        return weh.Handler;
    }
}

这是一个好方法，我过去也使用过类似的方法。去吧！

我绝对要做的一件事是，当您需要在DialogResult中设置“ false”时，使事件接收一个布尔值。

event EventHandler<RequestCloseEventArgs> RequestCloseDialog;

和EventArgs类：

public class RequestCloseEventArgs : EventArgs
{
    public RequestCloseEventArgs(bool dialogResult)
    {
        this.DialogResult = dialogResult;
    }

    public bool DialogResult { get; private set; }
}

我使用一种几乎相同的方法已有几个月了，对此我感到非常满意（即，我还没有完全重写它的冲动……）

在我的实现中，我使用IDialogViewModel来显示诸如标题，要显示的标准按钮（以便在所有对话框中保持一致的外观），RequestClose事件以及其他一些可以控制窗口大小和行为

如果您在谈论对话窗口，而不仅仅是弹出消息框，请考虑以下我的方法。关键点是：

1. 我将引用传递给Module Controller每个构造函数ViewModel（可以使用注入）。
2. 它Module Controller具有用于创建对话窗口的公共/内部方法（只需创建而不返回结果）。因此，ViewModel我在其中打开一个对话窗口：controller.OpenDialogEntity(bla, bla...)
3. 每个对话窗口都会通过弱事件通知其结果（例如OK，Save，Cancel等）。如果您使用PRISM，那么使用此EventAggregator可以更轻松地发布通知。
4. 为了处理对话结果，我使用了通知的订阅（对于PRISM，同样是弱事件和EventAggregator）。为了减少对此类通知的依赖，请对标准通知使用独立的类。

优点：

• 更少的代码。我不介意使用接口，但是我看到了太多的项目，其中过度使用接口和抽象层导致的麻烦多于帮助。
• 打开对话窗口Module Controller是一种避免使用强引用的简单方法，并且仍然允许使用模型进行测试。
• 通过弱事件进行通知可以减少潜在的内存泄漏次数。

缺点：

• 在处理程序中将所需的通知与其他通知区分开来并不容易。两种解决方案：
  • 在打开对话窗口时发送唯一令牌，并检查订阅中的令牌
  • 使用泛型通知类<T>，其中T实体是枚举的（或为简单起见，它可以是ViewModel的类型）。
• 对于项目，应该就使用通知类防止重复创建一个协议。
• 对于大型项目Module Controller，创建窗口的方法可能会淹没它。在这种情况下，最好将其分成几个模块。

PS我已经使用这种方法已有很长时间了，并准备捍卫其在评论中的资格，并在需要时提供一些示例。