csharp自定义对话窗口

using MvvmDialog1.View;
using MvvmDialog1.ViewModel.Interfaces;
using MvvmDialog1.ViewModel.Utils;
using MvvmDialog1.ViewModel.ViewModels;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
namespace MvvmDialog1
{
///

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
WindowStartupLocation="CenterScreen"
Title="ShowDialogWindow" Height="190.036" Width="300">

Margin="35,109,0,0" VerticalAlignment="Top" Width="75"
Command="{Binding OkCommand}"/>
VerticalAlignment="Top" Width="75"
Command="{Binding CancelCommand}"/>
VerticalAlignment="Top" Width="199"
Text="{Binding Message}" />



xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
WindowStartupLocation="CenterScreen"
Title="MainWindow" Height="350" Width="525">



Command="{Binding DisplayDialogWindow}"/>


Command="{Binding DisplayWindow}"/>




xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
WindowStartupLocation="CenterScreen"
Title="ShowWindow" Height="190.036" Width="300">

Text="{Binding Message, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}"
VerticalAlignment="Top" Width="225"/>
VerticalAlignment="Top"/>



using System.ComponentModel;
namespace MvvmDialog1.ViewModel.Utils
{
abstract class BaseViewModel : INotifyPropertyChanged
{
protected void OnPropertyChanged(string property)
{
if (this.PropertyChanged != null)
{
this.PropertyChanged(this, new PropertyChangedEventArgs(property));
}
}
public event PropertyChangedEventHandler PropertyChanged;
}
}

using MvvmDialog1.ViewModel.Interfaces;
using MvvmDialog1.ViewModel.Utils;
using System;
using System.Windows.Input;
namespace MvvmDialog1.ViewModel.ViewModels
{
class DialogWindowViewModel : IDialogRequestClose
{
public string Message { get; set; }
///


/// Komenda zatwierdzająca (zwr&＃243;cenie wyniku "prawda") i zamykająca okno.
///

public ICommand OkCommand { get; private set; }
///

/// Komenda zamykająca okno ze zwr&＃243;ceniem wyniku "fałsz".
///

public ICommand CancelCommand { get; private set; }
///

/// Domyślny konstruktor wymagany przez Xaml.
///

public DialogWindowViewModel() { }
///

/// Właściwy konstruktor stosowany przy tworzeniu instancji okna.
///

/// Wiadomość wyświetlana w oknie. Zamiast tego mogą być jakiekolwiek inne zmienne.
public DialogWindowViewModel(string message)
{
this.Message = message;
this.OkCommand = new RelayCommand(x => CloseRequested.Invoke(this, new DialogCloseRequestedEventArgs(true)));
this.CancelCommand = new RelayCommand(x => CloseRequested.Invoke(this, new DialogCloseRequestedEventArgs(false)));
}

public event EventHandler CloseRequested;
}
}

using System.Windows;
namespace MvvmDialog1.ViewModel.Interfaces
{
interface IDialog
{
object DataContext { get; set; }
bool? DialogResult { get; set; }
Window Owner { get; set; }
void Close();
bool? ShowDialog();
void Show();
}
}

using MvvmDialog1.ViewModel.Utils;
using System;
namespace MvvmDialog1.ViewModel.Interfaces
{
interface IDialogRequestClose
{
event EventHandler CloseRequested;
}
}

namespace MvvmDialog1.ViewModel.Interfaces
{
interface IDialogService
{
void Register()
where TViewModel : IDialogRequestClose
where TView : IDialog;
bool? ShowDialog(TVIewModel viewModel) where TVIewModel : IDialogRequestClose;
void Show(TVIewModel viewModel) where TVIewModel : IDialogRequestClose;
}
}

using MvvmDialog1.ViewModel.Interfaces;
using MvvmDialog1.ViewModel.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
namespace MvvmDialog1.ViewModel.ViewModels
{
class MainWindowViewModel : BaseViewModel
{
string _message;
readonly IDialogService _dialogService;
public ICommand DisplayDialogWindow { get; private set; }
public ICommand DisplayWindow { get; private set; }
public string Message
{
get
{
return this._message;
}
set
{
this._message = value;

this.OnPropertyChanged("Message");
}
}
public MainWindowViewModel() { }
public MainWindowViewModel(IDialogService dialogService)
{
this._dialogService = dialogService;
this.DisplayDialogWindow = new RelayCommand(x => displayMessage());
this.DisplayWindow = new RelayCommand(x => display());
}

private void displayMessage()
{
var viewModel = new DialogWindowViewModel("Hello");
bool? result = this._dialogService.ShowDialog(viewModel);
if (result.HasValue)
{
if (result.Value)
{
this.Message = viewModel.Message;
this.OnPropertyChanged("Message");
}
else
{
this.Message = "Cancel";
this.OnPropertyChanged("Message");
}
}
}
private void display()
{
var viewModel = new WindowViewModel("Hello");
this._dialogService.Show(viewModel);
}
}
}

using System;
namespace MvvmDialog1.ViewModel.Utils
{
class DialogCloseRequestedEventArgs : EventArgs
{
public bool? DialogResult { get; private set; }
public DialogCloseRequestedEventArgs(bool? dialogResult)
{
this.DialogResult = dialogResult;
}
}
}

using MvvmDialog1.ViewModel.Interfaces;
using System;
using System.Collections.Generic;
using System.Windows;
namespace MvvmDialog1.ViewModel.Utils
{
class DialogService : IDialogService
{
readonly Window _owner;
public IDictionary Mappings { get; set; }
public DialogService(Window owner)
{
this._owner = owner;
this.Mappings = new Dictionary();
}
public void Register()
where TViewModel : IDialogRequestClose
where TView : IDialog
{
if (this.Mappings.ContainsKey(typeof(TViewModel)))
{
throw new ArgumentException("Type " + typeof(TViewModel) + " is already mapped to type " + typeof(TView));
}
this.Mappings.Add(typeof(TViewModel), typeof(TView));
}
public bool? ShowDialog(TViewModel viewModel) where TViewModel : IDialogRequestClose
{
return getDialog(viewModel).ShowDialog();
}
public void Show(TViewModel viewModel) where TViewModel : IDialogRequestClose
{
getDialog(viewModel).Show();
}
private IDialog getDialog(TViewModel viewModel) where TViewModel : IDialogRequestClose
{
Type viewType = Mappings[typeof(TViewModel)];
IDialog dialog = (IDialog)Activator.CreateInstance(viewType);
EventHandler handler = null;

handler = (sender, e) =>
{
viewModel.CloseRequested -= handler;
if (e.DialogResult.HasValue)
{
dialog.DialogResult = e.DialogResult;
}
else
{
dialog.Close();
}
};

viewModel.CloseRequested += handler;
dialog.DataCOntext= viewModel;
dialog.Owner = _owner;
return dialog;
}
}
}

using System;
using System.Windows.Input;
namespace MvvmDialog1.ViewModel.Utils
{
class RelayCommand : ICommand
{
readonly Action _method;
readonly Predicate _condition;
public RelayCommand(Action method) : this(method, null) { }
public RelayCommand(Action method, Predicate condition)
{
this._cOndition= condition;
this._method = method;
}
public event EventHandler CanExecuteChanged
{
add
{
CommandManager.RequerySuggested += value;
}
remove
{
CommandManager.RequerySuggested -= value;
}
}
public bool CanExecute(object parameter)
{
return this._cOndition== null ? true : this._condition(parameter);
}
public void Execute(object parameter)
{
this._method(parameter);
}
public void Execute()
{
this._method(null);
}
}
}

using MvvmDialog1.ViewModel.Interfaces;
using MvvmDialog1.ViewModel.Utils;
using System;
using System.Windows;
using System.Windows.Input;
namespace MvvmDialog1.ViewModel.ViewModels
{
class WindowViewModel : BaseViewModel, IDialogRequestClose
{
string _message;
public string Message
{
get
{
return this._message;
}
set
{
this._message = value;
this.OnPropertyChanged("Message");
}
}
///


/// Domyślny konstruktor wymagany przez Xaml.
///

public WindowViewModel() { }
///

/// Właściwy konstruktor stosowany przy tworzeniu instancji okna.
///

/// Wiadomość wyświetlana w oknie. Zamiast tego mogą być jakiekolwiek inne zmienne.
public WindowViewModel(string message)
{
this.Message = message;
}
public event EventHandler CloseRequested;
}
}