Aller au contenu

DataTemplates et navigation

Un objet de données + un template = une vue. C'est la base de la navigation MVVM.

Template choisi par type

<Window.DataTemplates>
  <DataTemplate DataType="m:Cercle">
    <Ellipse Width="{Binding Diametre}" Height="{Binding Diametre}" Fill="#A78BFA" />
  </DataTemplate>
  <DataTemplate DataType="m:Carre">
    <Rectangle Width="{Binding Cote}" Height="{Binding Cote}" Fill="#6D28D9" />
  </DataTemplate>
</Window.DataTemplates>

<ItemsControl ItemsSource="{Binding Formes}" />

Chaque forme s'affiche avec le template de son type.

flowchart LR
  F["Formes = [Cercle, Carre, Cercle]"] --> Q{"type de l'objet ?"}
  Q -- Cercle --> T1["DataTemplate Cercle<br/>→ Ellipse"]
  Q -- Carre --> T2["DataTemplate Carre<br/>→ Rectangle"]
Aperçu

DataType vaut aussi x:DataType pour les compiled bindings.

Afficher un objet avec ContentControl

<ContentControl Content="{Binding ClientSelectionne}">
  <ContentControl.ContentTemplate>
    <DataTemplate x:DataType="m:Client">
      <StackPanel>
        <TextBlock Text="{Binding Nom}" FontSize="20" />
        <TextBlock Text="{Binding Email}" />
      </StackPanel>
    </DataTemplate>
  </ContentControl.ContentTemplate>
</ContentControl>

Les ViewModels

public abstract class PageViewModel : ObservableObject
{
    public abstract string Titre { get; }
}

public partial class AccueilViewModel : PageViewModel { public override string Titre => "Accueil"; }
public partial class ReglagesViewModel : PageViewModel { public override string Titre => "Réglages"; }

public partial class MainViewModel : ObservableObject
{
    public IReadOnlyList<PageViewModel> Pages { get; } =
        [new AccueilViewModel(), new ReglagesViewModel()];

    [ObservableProperty]
    public partial PageViewModel PageCourante { get; set; }

    public MainViewModel() => PageCourante = Pages[0];

    [RelayCommand]
    private void Aller(PageViewModel page) => PageCourante = page;
}

Les templates

App.axaml
<Application.DataTemplates>
  <DataTemplate DataType="vm:AccueilViewModel">
    <v:AccueilView />
  </DataTemplate>
  <DataTemplate DataType="vm:ReglagesViewModel">
    <v:ReglagesView />
  </DataTemplate>
</Application.DataTemplates>

La fenêtre

<DockPanel x:DataType="vm:MainViewModel">
  <ListBox DockPanel.Dock="Left" Width="200"
           ItemsSource="{Binding Pages}"
           SelectedItem="{Binding PageCourante}"
           DisplayMemberBinding="{Binding Titre}" />

  <TransitioningContentControl Content="{Binding PageCourante}" Margin="16">
    <TransitioningContentControl.PageTransition>
      <CrossFade Duration="0:0:0.2" />
    </TransitioningContentControl.PageTransition>
  </TransitioningContentControl>
</DockPanel>

La vue reçoit automatiquement le ViewModel comme DataContext.

Aperçu · changer PageCourante change la vue
AccueilViewDataContext = AccueilViewModel
ReglagesViewDataContext = ReglagesViewModel
flowchart LR
  VM["PageCourante =<br/>ReglagesViewModel"] --> CC["TransitioningContentControl"]
  CC --> DT{"DataTemplates :<br/>quel template pour<br/>ReglagesViewModel ?"}
  DT --> V["ReglagesView<br/>(DataContext = le VM)"]

ViewLocator (convention de noms)

Le template avalonia.mvvm fournit un ViewLocator : XxxViewModel → XxxView.

ViewLocator.cs
public class ViewLocator : IDataTemplate
{
    public Control? Build(object? data)
    {
        if (data is null) return null;

        var nom = data.GetType().FullName!.Replace("ViewModel", "View", StringComparison.Ordinal);
        var type = Type.GetType(nom);

        return type is not null
            ? (Control)Activator.CreateInstance(type)!
            : new TextBlock { Text = "Vue introuvable : " + nom };
    }

    public bool Match(object? data) => data is ObservableObject;
}
App.axaml
<Application.DataTemplates>
  <local:ViewLocator />
</Application.DataTemplates>

Trimming / AOT

Type.GetType + Activator utilisent la réflexion. Pour une appli publiée en AOT, préférez une table explicite :

private static readonly Dictionary<Type, Func<Control>> Vues = new()
{
    [typeof(AccueilViewModel)] = () => new AccueilView(),
    [typeof(ReglagesViewModel)] = () => new ReglagesView(),
};

public Control? Build(object? data)
    => data is not null && Vues.TryGetValue(data.GetType(), out var f) ? f() : null;
public partial class NavigationService : ObservableObject
{
    private readonly Stack<PageViewModel> _historique = new();

    [ObservableProperty]
    [NotifyCanExecuteChangedFor(nameof(RetourCommand))]
    public partial PageViewModel? Courante { get; set; }

    public void Aller(PageViewModel page)
    {
        if (Courante is not null) _historique.Push(Courante);
        Courante = page;
    }

    [RelayCommand(CanExecute = nameof(PeutRevenir))]
    private void Retour() => Courante = _historique.Pop();

    private bool PeutRevenir() => _historique.Count > 0;
}

Choisir un template selon une valeur

public class StatutTemplateSelector : IDataTemplate
{
    [Content]
    public Dictionary<string, IDataTemplate> Templates { get; } = new();

    public Control? Build(object? param)
        => Templates[((Commande)param!).Statut].Build(param);

    public bool Match(object? data) => data is Commande;
}
<ListBox.ItemTemplate>
  <local:StatutTemplateSelector>
    <DataTemplate x:Key="Payee" x:DataType="m:Commande">
      <TextBlock Text="{Binding Numero}" Foreground="SeaGreen" />
    </DataTemplate>
    <DataTemplate x:Key="EnAttente" x:DataType="m:Commande">
      <TextBlock Text="{Binding Numero}" Foreground="DarkOrange" />
    </DataTemplate>
  </local:StatutTemplateSelector>
</ListBox.ItemTemplate>

Navigation par pages

Avalonia 12 propose aussi NavigationPage (pile, bouton retour, transitions), idéale sur mobile. Voir Navigation.