Prism est un framework qui permet de développer des applications composites.
SoC - Separation of Concerns: principe de conception visant à séparer un programme informatique en blocs, chaque bloc correspondant à une fonctionnalité.
public class MainWindowViewModel : BindableBase
{
private string _title = "Prism Application";
public string Title
{
get => _title;
set => SetProperty(ref _title, value);
}
public MainWindowViewModel()
{ }
}
Représente la fenêtre principale (MainWindow) qui contiendra le contenu de l'application.
Équivalent de la Master Page ASP.NET, représente le template de vue de l'application.
Le Shell contient des regions dans lesquelles les vues seront injectées.
Region
C'est un espace réservé (placeholder) pour du contenu dynamique. Permet de nommer un espace où placer une vue.
Une région n'a aucune connaissance de la vue qu'elle va contenir.
Une région n'est pas un Control mais une Attached Property qui s'applique à un Control.
Implémente IRegion.
Package regroupant toutes les fonctionnalités d'une partie de l'application. Un module correspond à une fonctionnalité majeure de l'application.
Les modules sont dans des projets séparés de type Prism Module ou WPF User Control Library.
Modules/Test/TestModule.cs
// Dans les cas où le module n'est pas chargé via le cas
// il peut définir lui même son ModuleName, son InitializationMode (par défaut WhenAvailable) et ses dépendances
[Module(ModuleName = "Test", OnDemand = true)]
[ModuleDependency("")]
public class TestModule : IModule
{
public TestModule(IUnityContainer container, IRegionManager regionManager)
{
_container = container;
_regionManager = regionManager;
}
public void Initialize()
{
_container.RegisterTypeForNavigation<ViewA>();
_regionManager.RegisterViewWithRegion("ContentRegion", typeof(ViewA));
Chargement depuis le code
Le projet principal (Shell) doit avoir une référence vers les modules.
protected override IModuleCatalog CreateModuleCatalog()
{
return new ConfigurationModuleCatalog();
}
Chargement avec MEF
Ajouter l'assembly System.ComponentModel.Composition au projet ModuleTest
Prism.MefExtension ?
View
Pour créer une nouvelle vue, ajouter un UserControl dans un Module.
TestModule.cs
public class TestModule : IModule
{
public void Initialize()
{
// enregistrer les types de vue
_container.RegisterTypeForNavigation<ViewA>();
// composition des vues
// View Discovery
_regionManager.RegisterViewWithRegion("ContentRegion", typeof(ViewA));
// View Injection
var viewA = _container.Resolve<ViewA>();
IRegion region = _regionManager.Regions["ContentRegion"];
region.Add(viewA);
// remplacer une vue par une autre
region.Deactivate(viewA);
var viewB = _container.Resolve<ViewB>();
region.Add(viewB);
ViewModel
BindableBase
Permet aux vue-modèles d'appeler RaisePropertyChanged.
class ViewAViewModel : BindableBase
{
private string myProperty;
public string MyProperty
{
get => _myProperty;
set => SetProperty(ref myProperty, value);
set {
myProperty = value;
RaisePropertyChanged(nameof(MyProperty));
}
public ICommand AddCmd { get; set; }
// in the ctor
AddCmd = new DelegateCommand(Add, CanAdd);
// other solution
private DelegateCommand addCmd;
public DelegateCommand AddCmd => addCmd ?? (addCmd = new DelegateCommand(Add, CanAdd));
private void Add() {}
private bool CanAdd() { return true; }
// Command avec paramètres
// le parametre doit être un type nullable
private DelegateCommand<int?> addCmd2;
public DelegateCommand<int?> AddCmd2 => addCmd2 ?? (addCmd2 = new DelegateCommand<int?>(Add2, CanAdd2));
private void Add2(int? parameter) {}
private bool CanAdd2(int? parameter) { return true; }
// Task-Based DelegateCommand
AddCmd = new DelegateCommand(AddAsync);
async void AddAsync()
{
await SomeAsyncMethod();
}
// force la réévaluation de CanExecute
AddCmd.RaiseCanExecuteChanged();
CompositeCommand
Une commande qui regroupe plusieurs autres commandes.
public static class GlobalCommands
{
public static CompositeCommand SaveAllCommand = new CompositeCommand();
}
// ajout de MyCommand dans la CompositeCommand SaveAllCommand
GlobalCommands.SaveAllCommand.RegisterCommand(MyCommand);
// interface commune
public interface IDataService
{
IList<string> GetData();
}
Modules/Services/DataService.cs
// une implémentation du service
public class DataService : IDataService
{
public IList<string> GetData()
{
return new List<string> { "un", "deux", "trois" };
}
}
Modules/Services/ServicesModule.cs
public class ServicesModule : IModule
{
public void RegisterTypes(IContainerRegistry containerRegistry)
{
// enregistrement de DataService comme implémentation de IDataService
containerRegistry.Register<IDataService, DataService>();
}
Modules/A/ViewModels/MyViewModel.cs
// injection de dépendance
private readonly IDataService dataService;
public MyViewModel(IDataService dataService)
{
this.dataService = dataService;
}
