Discussion :

[daerlnaxe]

Bonjour à tous,

Peut être que je me casse la tête pour rien mais je me demandais quelle option était la meilleure entre deux solutions, point de vu lisibilité du code, mais également bonne habitudes.

Je dois changer le contenu d'un panel à gauche avec une combobox (c'est réglé), ce panel de gauche va aller piocher dans les résultats d'une Collection générée par une requêtes sqlite, et générer des boutons en relation. J'ai donc tout un taff de mise en forme d'autant que pour une des requêtes je vais faire une arbo à deux étages, sans quoi je me serais limité à changer l'itemsource. Ce panel de gauche pilote l'affichage d'un panel à droite quand on clique sur un des boutons générés, en interrogeant le contenu de la base.


Du coup niveau solution je m'interrogeais sur deux possibilités.
- La première assez classique, consiste à masquer ce qu'on ne veut pas afficher... Mais ça ne m'emballe pas trop car niveau lisibilité je fais partie des gens assez allergiques aux pavés, je me perds vite, j'aime bien segmenter.
- La seconde passerait par faire un Control utilisateur, j'ai déjà testé, ça se passe sans soucis jusqu'aux events... Là je vois deux solutions, soit utiliser un Func<> que j'utiliserais au clic et ça sera donc une fonction de la genêtre principale, soit générer un event (Je pourrais même rendre les boutons accessibles, mais bon... ) auquel jevais abonner une fonction depuis la fenêtre principale.

Si vous avez d'autres solutions en tête je suis preneur. J'ai déjà en tête une bonne dizaine de possibilités à faire via ce panneau qui sert à composer ou filter les requêtes et le panneau de droite servira à afficher lui même sous plusieurs présentations, je me dis que tout mettre dans la même fenêtre va être rapidement incompréhensible. D'ordinaire je passe plus par une solution comme la deux mais je me demandais ce qu'on préconisait "officiellement" dans des situations pareilles (je rappelle que je suis autodidacte). J'aimerai au max également conserver l'intérêt du wpf donc de ne pas utiliser la partie code c# pour générer du code wpf, du moins autant que possible.

Actuellement pour générer le menu de gauche en wpf j'utilise ça, je ne gère pas encore les events comme vous pouvez constater:

Code xaml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<Grid>
        <ItemsControl ItemsSource="{Binding Machines}">
            <ItemsControl.ItemsPanel>
                <ItemsPanelTemplate>
                    <StackPanel Orientation="Vertical"/>
                </ItemsPanelTemplate>
            </ItemsControl.ItemsPanel>
            <ItemsControl.ItemTemplate>
                <DataTemplate>
                    <Button Content="{Binding Machine}" Tag="{Binding ID}"/>
 
                </DataTemplate>
            </ItemsControl.ItemTemplate>
        </ItemsControl>
    </Grid>

[Noxen]

De façon générale évite les événements pour gérer les relations entre la vue et le modèle de vue. Par exemple pour les bouton il vaut mieux binder la propriété Command de la vue sur une ICommand du ViewModel. Si tu veux organiser l'affichage des détails tu peux créer des sections en utilisant des Expander. Et tu peux déjà avoir pas mal de flexibilité en utilisant la liaison de données (Binding/DataContext), les styles, les déclencheurs et les DataTemplates. Par exemple si tu as dans un vue Master-Detail (typiquement ce que tu es déjà en train de faire) une liste de véhicule contenant des voitures, des camions et des vélos, avec une classe pour chaque type de véhicule, tu peux créer un DataTemplate pour chacun et un DataTemplateSelector afin d'adapter l'affichage à l'élément sélectionné.

PS : Quand tu postes du code XAML dans la section C# tu peux modifier la balise code :

[CODE=XAML]

pour profiter pleinement de la coloration syntaxique.

[daerlnaxe]

Merci, je ne savais pas du tout pour command, j'étais resté à l'ancienne manière de faire. J'ai également modifié la balise code, comme tu m'as indiqué.

J'ai pas mal de soucis avec le wpf mais tu m'as donné des pistes très utiles et je te remercie d'avoir vu plus loin que ce que je pensais avoir besoin, je vais me pencher sur tout ça.

Merci !!!!

ps: pour l'affichage détail c'est une des parties, le panel de gauche sert à donner des catégories et celui de droite à afficher le contenu de ces catégories. Mais je suis en train de me dire qu'en fait ça serait peut être plus simple de faire un système de page, ou de dock panel avec un couplage à chaque fois gauche/droite et de switcher.

Bon, je ne sais pas si j'ai bien fait ou pas les choses, j'espère que oui... WPF et moi ... pas copains ^^ J'essaie..
Bon du coup j'ai opté pour intégrer entre les balises datatemplate, un controltemplate. J'ai testé via une checkbox pour le moment pour ne pas me casser la tête, il faut que je vois comment récupérer la valeur du tag de la combobox. Ca semble fonctionner.

Code xaml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 <ItemsControl ItemsSource="{Binding Machines}" Background="#FFEBFF26">
                        <ItemsControl.ItemsPanel>
                            <ItemsPanelTemplate>
                                <StackPanel Orientation="Vertical"/>
                            </ItemsPanelTemplate>
                        </ItemsControl.ItemsPanel>
                        <ItemsControl.ItemTemplate>
                            <DataTemplate>
                                <ContentControl >
                                    <ContentControl.Style>
                                        <Style TargetType="ContentControl">
                                            <Style.Triggers>
                                                <DataTrigger Binding="{ Binding ElementName=cboxTest, Path=IsChecked}" Value="true">
 
                                                    <Setter Property="Template" Value="{StaticResource SimpleArbo}" />
                                                </DataTrigger>
 
                                            </Style.Triggers>
                                        </Style>
                                    </ContentControl.Style>
                                </ContentControl>
 
                            </DataTemplate>
                        </ItemsControl.ItemTemplate>

[daerlnaxe]

Ayant besoin de quelques éléments de réponse je poste à nouveau, j'espère que ça ne gènera pas...

J'en ai un peu bavé pour trouver un tuto que j'arrive à comprendre finalement je me suis rabattu sur un en Anglais sur wpf-tutorial, je pense pas avoir fait d'erreur c'était assez clair mais je préfère demander. Les tutos que j'ai vu ne parlaient pas de customcommands mais de commandes intégrées nativement.

J'ai donc fait une classe static avec mes commandes, mais par contre vu que je vais gérer dans la fenêtre ce qui s'affiche, je conserve donc la fonction qui sert pour executed dans la partie code (ça s'appelle comment du coup en syntaxe wpf ? le code c# de la partial class d'une fenêtre c'est le model view ? j'ai du mal à distinguer 3 parties), qui va lancer une fonction que j'ai ailleurs qui permet de récupérer des données dans la base. Je me dis que si je fais gérer l'éxecution de la commande dans une classe qui hérite de ICommand, il faudra que je passe nécessairement un Function<T,Y> quelque part et je me dis que c'est pas spécialement judicieux d'autant que de toute manière ça portera forcément dans el cas présent sur cette fenêtre là... plus l'objet conteneur qui servirait à recevoir ces informations ça serait plutôt étrange, non ?. Mais du coup je me demande du coup si en procédant ainsi je respecte le MVVM....


Rajout dans la partie xaml de la fenêtre

Code xaml :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
<window  [...]
 xmlns:commandes="clr-namespace:MaGameCollec.Commandes"
[...]
</window>
[....]
    <Window.CommandBindings>
        <CommandBinding Command="commandes:ShowGames.ForPlatform" CanExecute="Test_CanExecute" Executed="Test_Executed"/>
    </Window.CommandBindings>
[...]
        <ControlTemplate x:Key="SimpleArbo">
 
            <Button Content="{Binding Machine}" Tag="{Binding ID}" Command="commandes:ShowGames.ForPlatform" />
        </ControlTemplate>

[Noxen]

Concernant le découpage MVVM :
- le code XAML fait partie de la vue ;
- le code behind en C#, nonobstant des iconoclastes issus de WinForms, fait partie de la vue et ne devrait contenir que du code concernant le comportement graphique et la logique interne du composant ;
- les ViewModels sont des classes implémentant INotifyPropertyChanged représentant la vue en terme de contenu métier ; c.à.d des propriétés (généralement levant l'événement PropertyChanged) correspondant aux données manipulées et des commandes représentant les actions possibles sur ces données ;
- concernant les modèles il s'agira en principe des données renvoyées par ta couche de services métier ;
- ça n'est pas mentionné dans MVVM mais tu peux avoir des contrôleurs, qui auront en charge l'orchestration de l'ensemble, notamment l'instanciation des services, des modèles de vue et des vues.

Concernant les commandes :
Le seul impératif est d'avoir des objets qui implémentent ICommand. Personnellement je préfère les placer dans le ViewModel, car à mon sens ça fait partie de la description fonctionnelle de la vue. En plus tu peux lier le contexte de la commande au contexte en cours ; par exemple, une commande pour supprimer un objet peut être désactivée s'il n'y a pas d'objet sélectionner. Pour l'implémentation tu peux faire une classe dédiée, mais le traitement lui-même peut être une méthode provenant d'un autre objet. Tu peux également importer la bibliothèque MVVMLight de Laurent Bugnion et profiter des RelayCommand qui insèrent les traitements par des delegates.

Concernant les ControlTemplates :
Une chose à comprendre concernant WPF est que ses composants sont conçus "headless", c.à.d d'un point de vue fonctionnel et non visuel. Par exemple, une ListBox n'est pas un composant présentant une liste d'objets affichés dans une grille dont l'un peut être sélectionné, mais un composant présentant une liste d'items, dont l'un peut être sélectionné ; à cet égard plusieurs modèles peuvent répondre à cette exigence. Une grille affichant une liste de villes françaises dans une grille est valide. Mais une carte de France affichant une liste de villes est également valide. La conception d'un composant se fait donc au départ sans spécifier la façon dont il sera affiché. L'affichage lui-même se fait par le biais d'un ControlTemplate. Il faut en principe disposer pour chaque composant d'un ControlTemplate par défaut, ce qui est le cas pour ceux fournis par l'API WPF. Ils sont habituellement suffisamment souples pour que tu puisses les adapter à tes besoins, si tu décides d'en recréer un il vaut mieux que ce soit pour répondre à quelque chose de très spécifique qui s'écarte fortement de ce qui est disponible en standard.