DevExpress.Mvvm.Free Framework

There are two distinct versions of the DevExpress MVVM Framework:

1. DevExpress.Mvvm: Included in the DevExpress WPF component suite. It is optimized for use with DevExpress WPF controls.
2. DevExpress.Mvvm.Free: A standalone version designed for use with standard WPF controls or third-party control suites. It is a mirror of the full framework, meaning you can use the same official DevExpress documentation for both.

Note: The DevExpress.Mvvm.Free version is not compatible with the DevExpress WPF suite.

The Module Injection Framework (MIF) facilitates the development of modular applications with loosely coupled modules. Key features include:

• Automatic persistence of logical state and layout.
• Code separation into logical modules with straightforward navigation.
• Support for Unit Testing.
• Use ModuleInjection.GetRegions to retrieve all regions from a specific ViewModel.

The Free DevExpress MVVM Framework can be installed as a NuGet package. This version is specifically designed for use with standard or third-party WPF controls and is not compatible with the full DevExpress WPF component suite.

# Install via NuGet package manager
Install-Package DevExpressMvvm

Both DelegateCommand and AsyncCommand inherit from CommandBase, which manages the relationship between the command's logic and the UI's ability to execute it.

1. CommandBase: Provides the foundation for CanExecute logic and the CanExecuteChanged event. It handles the logic of whether to use the WPF CommandManager or a local event handler.
2. DelegateCommandBase: A middle layer for synchronous commands that allows initializing the executeMethod and canExecuteMethod via a constructor.
3. AsyncCommandBase: A middle layer for asynchronous commands that adds INotifyPropertyChanged support (specifically for IsExecuting) and manages CancellationTokenSource for task cancellation.
4. Concrete Implementations: DelegateCommand and AsyncCommand are the final classes you instantiate to bind to your View or ViewModel.

POCO ViewModels and ViewModelBase descendants can automatically generate AsyncCommand instances for methods marked with the async keyword. You can also manually invalidate an auto-generated command using RaiseCanExecuteChanged by referencing the async method.

[AsyncCommand(UseCommandManager = false)]
public async Task Calculate() {
    for(int i = 0; i <= 100; i++) {
        Progress = i;
        await Task.Delay(20);
    }
}

void UpdateCalculateCommand() {
    // Invalidate the auto-generated command for the Calculate method
    this.RaiseCanExecuteChanged(x => x.Calculate());
}

The BindableBase and ViewModelBase classes provide simplified syntax for implementing properties with change notification. You can use GetValue<T> and SetValue for a cleaner implementation.

// Option 1: Using GetValue/SetValue
public string FullName {
    get { return GetValue<string>(); }
    set { SetValue(value, OnFullNameChanged); }
}

// Option 2: Using ref with SetValue
string fullName;
public string FullName {
    get { return fullName; }
    set { SetValue(ref fullName, value, OnFullNameChanged); }
}

The CommandBase class provides a static property to control whether commands globally use the WPF CommandManager to handle CanExecuteChanged events.

• Setting CommandBase.DefaultUseCommandManager = true (default) allows commands to automatically re-evaluate their CanExecute state when the WPF CommandManager.RequerySuggested event fires.
• Setting it to false requires you to manually call RaiseCanExecuteChanged() on your command instances to update the UI.

// Disable automatic CommandManager updates globally
DevExpress.Mvvm.CommandBase.DefaultUseCommandManager = false;

The UICommand class provides static factory methods to automatically generate a list of UICommand objects based on standard message box button sets. This is useful for creating consistent dialog button layouts.

Available methods:

• GenerateFromMessageButton(MessageButton dialogButtons, IMessageButtonLocalizer buttonLocalizer, MessageResult? defaultButton = null, MessageResult? cancelButton = null)
• GenerateFromMessageBoxButton(...) (Helper for MessageBoxButton types)

Supported MessageButton types include:

• OK
• OKCancel
• YesNo
• YesNoCancel

If you are implementing or using an IDelegateCommand, you can call RaiseCanExecuteChanged() to notify the command target (e.g., a UI button) that the result of CanExecute may have changed. This is useful when the state determining whether a command can run is updated outside of the command's own logic.

// Assuming 'myCommand' implements IDelegateCommand
myCommand.RaiseCanExecuteChanged();