Dernière version du 25 février 2021 à 20:58

Liens

Prism release notes

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

App.xaml

<prism:PrismApplication x:Class="MyNamespace.App"
                        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                        xmlns:prism="http://prismlibrary.com/"
                        xmlns:local="clr-namespace:MyNamespace">
    <Application.Resources />
</prism:PrismApplication>

App.xaml.cs

// 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);
    }

Views/MainWindow.xaml

<Window x:Class="MyNamespace.Views.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:prism="http://prismlibrary.com/"
        prism:ViewModelLocator.AutoWireViewModel="True"
        Title="{Binding Title}" Height="350" Width="525">
    <Grid>
        <ContentControl prism:RegionManager.RegionName="ContentRegion" />
    </Grid>
</Window>

ViewModels/MainWindowViewModel.cs

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.

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

StackPanelRegionAdapter.cs

class StackPanelRegionAdapter : RegionAdapterBase<StackPanel>
{
    public StackPanelRegionAdapter(IRegionBehaviorFactory regionBehaviorFactory) : base(regionBehaviorFactory)
    {

    }

    protected override void Adapt(IRegion region, StackPanel regionTarget)
    {
        region.Views.CollectionChanged += (sender, e) =>
        {
            if (e.Action == NotifyCollectionChangedAction.Add)
            {
                foreach (FrameworkElement element in e.NewItems)
                {
                    regionTarget.Children.Add(element);
                }
            }
        };
    }

    protected override IRegion CreateRegion()
    {
        return new AllActiveRegion();
    }
}

Bootstrapper.cs

protected override RegionAdapterMappings ConfigureRegionAdapterMappings()
{
    var mappings = base.ConfigureRegionAdapterMappings();
    mappings.RegisterMapping(typeof(StackPanel), Container.Resolve<StackPanelRegionAdapter>());
    return mappings;
}

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.

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.

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.

Bootstrapper.cs

protected override void ConfigureModuleCatalog()
{
    var moduleCatalog = (ModuleCatalog)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
    });

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).

Bootstrapper.cs

protected override IModuleCatalog CreateModuleCatalog()
{
    return new DirectoryModuleCatalog()
    {
        ModulePath = @".\Modules"
    };

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.

XamlCatalog.xaml

<Modularity:ModuleCatalog xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                          xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                          xmlns:Modularity="clr-namespace:Prism.Modularity;assembly=Prism.Wpf">

    <Modularity:ModuleInfo Ref="file://TestModule.dll"
                           ModuleName="Test"
                           ModuleType="TestModule.TestModuleModule, TestModule, Version=1.0.0.0" 
                           InitializationMode="WhenAvailable" />

</Modularity:ModuleCatalog>

Bootstrapper.cs

protected override IModuleCatalog CreateModuleCatalog()
{
    return Prism.Modularity.ModuleCatalog.CreateFromXaml(new Uri("/MyApplication;component/XamlCatalog.xaml", UriKind.Relative));
}

Chargement depuis un fichier App.config

Ajouter au projet principal un Application Configuration File.

App.config

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="modules" type="Prism.Modularity.ModulesConfigurationSection, Prism.Wpf" />
  </configSections>

  <modules>
    <module assemblyFile="Modules/ModuleTest.dll"
            moduleType="ModuleTest.ModuleTestModule, ModuleTest, Version=1.0.0.0"
            moduleName="ModuleTest"
            startupLoaded="true" />
  </modules>
</configuration>

Bootstrapper.cs

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));
        }

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; }

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();
}

Update CanExecute state

RaiseCanExecuteChanged

MyViewModel.cs

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);
}

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; }

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
}

Shared Services

Permet de faire de l'injection de dépendance (implémentation de l'inversion de contrôle)

DryIoC

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;
    }
}

@@ Ligne 1 : / Ligne 1 : @@
 [[Category:WPF]]
+= Liens =
+* [https://github.com/PrismLibrary/Prism/releases Prism release notes]
 = Introduction =
 [http://prismlibrary.github.io/docs/ Prism] est un framework qui permet de développer des applications composites.
@@ Ligne 366 : / Ligne 369 : @@
 <filebox fn='MyView.xaml'>
 <Button Command="{Binding AddCmd}">Add</Button>
-<Button Command="{Binding AddCmd2}" CommandParameter="10">Add</Button>
 </filebox>
 <filebox fn='MyViewModel.cs'>
-public ICommand AddCmd { get; set; }
+public ICommand AddCmd { get; private set; }
-// in the ctor
-AddCmd = new DelegateCommand(Add, CanAdd);
-// other solution
+public MainWindowViewModel()
-private DelegateCommand addCmd;
+{
-public DelegateCommand AddCmd => addCmd ?? (addCmd = new DelegateCommand(Add, CanAdd));
+    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; }
-// force la réévaluation de CanExecute
-AddCmd.RaiseCanExecuteChanged();
 </filebox>
@@ Ligne 410 : / Ligne 400 : @@
 </filebox>
-== CompositeCommand ==
+== Update CanExecute state ==
-Une commande qui regroupe plusieurs autres commandes.
+=== RaiseCanExecuteChanged ===
-<kode lang='cs'>
+<filebox fn='MyViewModel.cs'>
-public static class GlobalCommands
+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();
+    }
+}
+</filebox>
+=== ObservesProperty ===
+<filebox fn='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);
+}
+</filebox>
+=== 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.
+<filebox fn='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);
+}
+</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()
 {
-     public static CompositeCommand SaveAllCommand = new CompositeCommand();
+     AddCmd = new DelegateCommand<int?>(Add, CanAdd);
 }
-// ajout de MyCommand dans la CompositeCommand SaveAllCommand
+private void Add(int? parameter) {}
-GlobalCommands.SaveAllCommand.RegisterCommand(MyCommand);
+private bool CanAdd(int? parameter) { return true; }
-</kode>
+</filebox>
-<kode lang='xaml'>
-<UserControl xmlns:myns="clr-namespace:MyNamespace;assembly=MyAssembly">
-    <Button Command="{x:Static myns:GlobalCommands.SaveAllCommand}">Save All</Button>
-</kode>
 = [https://prismlibrary.github.io/docs/event-aggregator.html Event Aggregator] =

« Prism 7 » : différence entre les versions

Dernière version du 25 février 2021 à 20:58

Liens

Introduction

Design de l'application

Install NuGet packages

Prism Template Pack

Fichiers de base

Shell

Region

Region Adapter

Custom Region Adapter

RegionContext

Module

Ajout du module

Module - OLD

Chargement depuis le code

Chargement depuis un chemin

Chargement depuis un fichier XAML

Chargement depuis un fichier App.config

Chargement avec MEF

View

ViewModel

BindableBase

ViewModelLocator

DelegateCommand

Task-Based DelegateCommand

Update CanExecute state

RaiseCanExecuteChanged

ObservesProperty

ObservesCanExecute

Command with parameters

Event Aggregator

Shared Services

Region Context

Menu de navigation

Rechercher

« Prism 7 » : différence entre les versions