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"]
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>
Navigation par ViewModel¶
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.
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;
}
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;
Navigation avec historique¶
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.