« Prism 7 » : différence entre les versions
Ligne 366 : | Ligne 366 : | ||
<filebox fn='MyView.xaml'> | <filebox fn='MyView.xaml'> | ||
<Button Command="{Binding AddCmd}">Add</Button> | <Button Command="{Binding AddCmd}">Add</Button> | ||
</filebox> | </filebox> | ||
<filebox fn='MyViewModel.cs'> | <filebox fn='MyViewModel.cs'> | ||
public ICommand AddCmd { get; set; } | public ICommand AddCmd { get; private set; } | ||
public MainWindowViewModel() | public MainWindowViewModel() | ||
Ligne 379 : | Ligne 378 : | ||
private void Add() {} | private void Add() {} | ||
private bool CanAdd() { return true; } | private bool CanAdd() { return true; } | ||
</filebox> | |||
== Command with parameters = | |||
{{warn | Parameters must be nullable}} | |||
<filebox fn='MyView.xaml'> | |||
<Button Command="{Binding AddCmd}" CommandParameter="10">Add 10</Button> | |||
</filebox> | |||
<filebox fn='MyViewModel.cs'> | |||
public DelegateCommand<int?> AddCmd { get; private set; } | |||
public MainWindowViewModel() | |||
{ | |||
AddCmd = new DelegateCommand<int?>(Add, CanAdd); | |||
} | |||
private void | private void Add(int? parameter) {} | ||
private bool | private bool CanAdd(int? parameter) { return true; } | ||
// force la réévaluation de CanExecute | // force la réévaluation de CanExecute |
Version du 9 août 2020 à 13:15
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é.
- Loose coupling: les blocs du programme n'ont pas connaissance des autres. (Exemple Dependency injection)
Design de l'application
- Shell: contient les regions
- Regions: les vues sont injectées dans les regions au runtime
- Modules: fonctionnalités majeures de l'application
- Bootstrapper: initialise Prism
Install NuGet packages
Package | Dependencies | Content |
---|---|---|
Prism.Wpf | Prism.Core CommonServiceLocator | base packages |
Prism.DryIoc | DryIoc | depency injection |
Prism.Container.Extensions | extension methods making the Prism Container easier to use with IServiceCollection IServiceProvider |
Prism Template Pack
Ajoute des templates Prism dans les nouveaux projets Visual Studio Visual C# → Prism.
À la création d'un BlankApp, choix du conteneur IoC:
- DryIoc
- Autofac
- Unity
Ajoute aussi des snippets: propp cmd cmdfull cmdg cmdgfull
Fichiers de base
afficherApp.xaml |
afficherApp.xaml.cs |
afficherViews/MainWindow.xaml |
afficherViewModels/MainWindowViewModel.cs |
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.
Shell.xaml |
<Window xmlns:prism="http://prismlibrary.com/">
<DockPanel>
<ContentControl prism:RegionManager.RegionName="ToolbarRegion" DoclkPanel.Dock="Top" />
<ContentControl prism:RegionManager.RegionName="ContentRegion" />
|
Region Adapter
Permet d'adapter un UI Control pour qu'il devienne une région. Il faut un adapter pour chaque type de UI Control.
ContentControlRegionAdapter | |
ItemsControlRegionAdapter | |
SelectorRegionAdapter | TabControl |
Custom Region Adapter
afficherStackPanelRegionAdapter.cs |
afficherBootstrapper.cs |
RegionContext
Attached Property permettant de propager les données de la région à la vue.
Module
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 |
public class TestModule : IModule
{
public void OnInitialized(IContainerProvider containerProvider)
{
IRegionManager regionManager = ServiceLocator.Current.GetInstance<IRegionManager>();
regionManager.RegisterViewWithRegion("ContentRegion", typeof(ViewA));
}
public void RegisterTypes(IContainerRegistry containerRegistry)
{ }
|
Ajout du module
Le projet principal (Shell) doit avoir une référence vers les modules.
App.xaml.cs |
protected override void ConfigureModuleCatalog(IModuleCatalog moduleCatalog)
{
moduleCatalog.AddModule(typeof(TestModule));
// autre méthode d'ajout
Type testModuleType = typeof(TestModule);
moduleCatalog.AddModule(new ModuleInfo()
{
ModuleName = testModuleType.Name,
ModuleType = testModuleType.AssemblyQualifiedName,
InitializationMode = InitializationMode.WhenAvailable
});
|
Module - OLD
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. |
afficherModules/Test/TestModule.cs |
Chargement depuis le code
Le projet principal (Shell) doit avoir une référence vers les modules.
afficherBootstrapper.cs |
Chargement depuis un chemin
Un dossier Modules doit être présent au même niveau que MyApplication.exe. Ce dossier doit contenir les dll des modules (TestModule.dll).
afficherBootstrapper.cs |
Chargement depuis un fichier XAML
- Ajouter au projet principal un dictionnaire de ressources.
- Passer la Build Action à Resource
- Les dll des modules doivent être présents au même niveau que MyApplication.exe.
afficherXamlCatalog.xaml |
afficherBootstrapper.cs |
Chargement depuis un fichier App.config
- Ajouter au projet principal un Application Configuration File.
afficherApp.config |
afficherBootstrapper.cs |
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));
}
|
ViewModelLocator
Associe à ViewA le VM ViewAViewModel.
Modules/A/Views/ViewA.xaml |
<UserControl x:Class="A.Views.ViewA"
prism:ViewModelLocator.AutoWireViewModel="True"
d:DataContext="{d:DesignInstance local:ViewAViewModel}"> <!-- auto-completion during design -->
|
DelegateCommand
MyView.xaml |
<Button Command="{Binding AddCmd}">Add</Button>
|
MyViewModel.cs |
public ICommand AddCmd { get; private set; }
public MainWindowViewModel()
{
AddCmd = new DelegateCommand(Add, CanAdd);
}
private void Add() {}
private bool CanAdd() { return true; }
|
= Command with parameters
Parameters must be nullable |
MyView.xaml |
<Button Command="{Binding AddCmd}" CommandParameter="10">Add 10</Button>
|
MyViewModel.cs |
public DelegateCommand<int?> AddCmd { get; private set; }
public MainWindowViewModel()
{
AddCmd = new DelegateCommand<int?>(Add, CanAdd);
}
private void Add(int? parameter) {}
private bool CanAdd(int? parameter) { return true; }
// force la réévaluation de CanExecute
AddCmd.RaiseCanExecuteChanged();
|
Task-Based DelegateCommand
MyViewModel.cs |
AddCmd = new DelegateCommand(async () => await AddAsync());
private async Task AddAsync()
{
await SomeAsyncMethod();
}
AddCmd = new DelegateCommand(AddAsync);
private async void AddAsync()
{
await SomeAsyncMethod();
}
|
Event Aggregator
Système de distribution de message (event bus) sans couplage entre le destinataire et l'expéditeur.
- un objet envoie un message, sans savoir qui le recevra
- un ou des objets s'inscrivent pour recevoir ces messages, sans savoir qui les envoie
Ce mécanisme permet:
- d'appeler une méthode de la vue depuis le Vue-Modèle.
- de communiquer entre Vue-Modèle.
Modules/A/ViewModels/View1ViewModel.cs |
private readonly IEventAggregator eventAggregator;
public View1ViewModel(IEventAggregator eventAggregator)
{
this.eventAggregator = eventAggregator;
}
private void MyAction()
{
// publie l'évenement TestEvent avec "MyValue" comme payload
eventAggregator.GetEvent<PubSubEvent<string>>().Publish("MyValue");
}
|
Modules/B/ViewModels/View2ViewModel.cs |
private readonly IEventAggregator eventAggregator;
public View2ViewModel(IEventAggregator eventAggregator)
{
this.eventAggregator = eventAggregator;
var myEvent = this.eventAggregator.GetEvent<PubSubEvent<string>>();
myEvent.Subscribe(MessageReceived);
// recevoir l'évenement sur le thread UI pour pouvoir modifier l'UI
myEvent.Subscribe(MessageReceived, ThreadOption.UIThread);
// filter
myEvent.Subscribe(MessageReceived, ThreadOption.PublisherThread, false,
message => message.StartsWith("x"));
// se désincrire
myEvent.Unsubscribe(MessageReceived);
}
private void MessageReceived(string message)
{
// reception des évenements TestEvent et de leur payload
}
|
Permet de faire de l'injection de dépendance (implémentation de l'inversion de contrôle)
Common/IDataService.cs |
// 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;
}
|
Region Context
Permet aux vues de partager des données (context) avec ses vues filles.
<UserControl prism:RegionManager.RegionContext="{Binding SelectedElement.Id}">
|
private void GetRegionContext()
{
var id = (int)RegionContext.GetObservableContext(this).Value;
}
// suivre les changements dans le context
ObservableObject<object> viewRegionContext = RegionContext.GetObservableContext(this);
viewRegionContext.PropertyChanged += this.ViewRegionContext_OnPropertyChangedEvent;
private void ViewRegionContext_OnPropertyChangedEvent(object sender, PropertyChangedEventArgs args)
{
if (args.PropertyName == "Value")
{
var context = (ObservableObject<object>)sender;
int newValue = (int)context.Value;
}
}
|