Moody DialogService is a service designed to handle WPF dialogs in an MVVM way (No more code behind!).
Before using the DialogService, we need to make sure the view is registered against the desired ViewModel (For later use).
Also, you need to make sure your IServiceCollection has all the services registered, otherwise, the service will not work. Why? This is because when we activate a view, we need to resolve any services you may be passing in the code behind.. (Although you shouldn't be). So if its not registered, we will have problems..
Anyway, You have 2 options on registering Dialogs
DialogService.RegisterDialog<DialogOne, DialogOneViewModel>();
DialogService.AutoRegisterDialogs<App>();
The reason we pass through App is so that the AutoRegister knows what assembly to look into.
NOTE: Your "Dialog" CANNOT be a window. It will have to be a type of UserControl. This is because the service uses a "DialogShell" and injects the UserControl into the shell content.
Also, for AutoRegister to work, you will need to add the 'DialogModule' attribute in the code behind of the desired Dialogs you would like to register.
[DialogModule]
public partial class DialogOne : UserControl
{
public DialogOne()
{
InitializeComponent();
}
}
To consume the service, you will need to register it to your IoC Container.
private void ConfigureServices(IServiceCollection services)
{
services.AddSingleton<IDialogService, DialogService>();
}
After you have added it to your IoC Conatiner, you can now start using it in your ViewModels!
//Constructor
public MainWindowViewModel(IDialogService dialogService)
{
_dialogService = dialogService;
}
You can show your dialog by calling ShowDialog and passing through your view model type.
public void ShowSomeDialog()
{
_dialogService.ShowDialog<SomeDialogViewModel>();
}
You can close your dialog by calling CloseDialog and passing through your view model type.
public void CloseSomeDialog()
{
_dialogService.CloseDialog<SomeDialogViewModel>();
}
When you add these properties in the control, the service will pick up these settings and apply it to this dialog. (All dialogs can be unique)
<UserControl
xmlns:moody="clr-namespace:Moody.DialogService.Settings;assembly=Moody.DialogService"
moody:DialogSettings.DialogName="Dialog One"
moody:DialogSettings.WindowStyle="ToolWindow">
<!--Some UI Code-->
</UserControl>
Incase you want to override the default settings, you can use the SetDefaultDialogSettings method to apply your own defaults!
_dialogService.SetDefaultDialogSettings(new DefaultDialogSettings()
{
DialogWindowDefaultStyle = WindowStyle.None,
DialogWindowDefaultTitle = "Window Title",
});
Lets say your Dialog needs to pass back an object to your ViewModel.. How would we do that?
We would use the DialogServices 'ReturnParameters'
//MainViewModel
public void ShowSomeDialogThatReturns()
{
var expectedObject = _dialogService.ShowDialog<SomeDialogViewModel, bool>();
}
//DialogViewModel
public void SomeMethodInDialog()
{
_dialogService.SetReturnParameters(true);
}
Once the above dialog closes, the expectedObject will be true (bool).
Now how you handle closing the dialog is up to you, But ensure you set the ReturnParameters before closing!
Now lets say you want to pass some data to your Dialog ViewModel.. How would we do that?
We would first mark the Dialog ViewModel as IDialogAware
public class DialogOneViewModel : IDialogAware
{
//VM Code
//Is called when the dialog is shown
public void OnDialogShown(DialogParameters dialogParameters)
{
//Logic
}
//Is called after setting the data context (Before showing)
public void OnDialogInitialized(DialogParameters dialogParameters)
{
//Logic
}
//Is called after the dialog has closed
public void OnDialogClosed(DialogParameters dialogParameters)
{
//Logic
}
}
This interface comes with 3 methods. OnDialogShown, OnDialogInitialized, and OnDialogClosed, all of which take in some dialog parameters. DialogParameters is just a simple dictionary<string, object> allowing you to pass multiple key-value pairs to another ViewModel. For example, In OnDialogClosed, you could set some return parameters and use them on the ViewModel that called the dialog.
To pass the parameters, we would call ShowDialog and pass them through there:
public void ShowDialog()
{
var parameters = new DialogParameters()
{
{ AppConstants.MY_BOOL_OBJECT, true }
};
_dialogService.ShowDialog<DialogOneViewModel>(parameters);
}
We can then use these parameters in the above aware methods (OnDialogShown, OnDialogInitialized) to get these values back.
If you have any questions or comments, please send me a message on one of the platforms below!