public DelegateCommand AddCmd => addCmd ?? (addCmd = new DelegateCommand(Add, CanAdd));
private void Add() {}
private void Add() {}
private bool CanAdd() { return true; }
private bool CanAdd() { return true; }
// Command avec paramètres
// Command with parameters, parameters must be nullable
// le paramètre doit être un type nullable
private DelegateCommand<int?> addCmd2;
private DelegateCommand<int?> addCmd2;
public DelegateCommand<int?> AddCmd2 => addCmd2 ?? (addCmd2 = new DelegateCommand<int?>(Add2, CanAdd2));
public DelegateCommand<int?> AddCmd2 => addCmd2 ?? (addCmd2 = new DelegateCommand<int?>(Add2, CanAdd2));
Version du 9 août 2020 à 13:12
Introduction
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é.
// classe de type PrismApplication qui hérite de PrismApplicationBase
public partial class App
{
protected override Window CreateShell()
{
return Container.Resolve<MainWindow>();
}
protected override void RegisterTypes(IContainerRegistry containerRegistry)
{
// RegisterServices available with Prism.Container.Extensions nuget package
containerRegistry.RegisterServices(serviceCollection => serviceCollection.AddApplicationInsightsTelemetryWorkerService());
}
public override void Initialize()
{
base.Initialize();
IRegionManager regionManager = ServiceLocator.Current.GetInstance<IRegionManager>();
var viewA = Container.Resolve<ViewA>();
IRegion region = regionManager.Regions["ContentRegion"];
region.Add(viewA);
}
public class MainWindowViewModel : BindableBase
{
private string _title = "Prism Application";
public string Title
{
get => _title;
set => SetProperty(ref _title, value);
}
public MainWindowViewModel()
{ }
}
Shell
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));
}
// 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;
}
