使用 MVVM 在 wpf 中执行 Dialogs 是好还是坏？

最近我遇到了为我的 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;
}
}

现在，至少我必须在我的资源文件(app.xaml或其他)中创建一个 DataTemplate:

<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
(网站不再存在，网络档案镜像)

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;
}
}