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));
}
public ICommand AddCmd { get; private set; }
public MainWindowViewModel()
{
AddCmd = new DelegateCommand(Add, CanAdd);
}
private void Add() {}
private bool CanAdd() => IsEnabled;
private bool _isEnabled;
public bool IsEnabled
{
get => _isEnabled;
set
{
SetProperty(ref _isEnabled, value);
// when IsEnabled value has chanded, force the re-evaluation of CanAdd
SubmitCommand.RaiseCanExecuteChanged();
}
}
ObservesProperty
MyViewModel.cs
public ICommand AddCmd { get; private set; }
public MainWindowViewModel()
{
AddCmd = new DelegateCommand(Add, CanAdd).ObservesProperty(() => IsEnabled);
// whenever the value of the supplied property changes
// the DelegateCommand will automatically call RaiseCanExecuteChanged to notify the UI of state changes
}
private void Add() {}
private bool CanAdd() => IsEnabled;
private bool _isEnabled;
public bool IsEnabled
{
get => _isEnabled;
set => SetProperty(ref _isEnabled, value);
}
ObservesCanExecute
If your CanExecute is the result of a simple Boolean property, you can eliminate the need to declare a CanExecute delegate, and use the ObservesCanExecute method instead.
MyViewModel.cs
public ICommand AddCmd { get; private set; }
public MainWindowViewModel()
{
AddCmd = new DelegateCommand(Add).ObservesCanExecute(() => IsEnabled);
}
private void Add() {}
private bool _isEnabled;
public bool IsEnabled
{
get => _isEnabled;
set => SetProperty(ref _isEnabled, value);
}
// 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;
}
