Les différents types d'applications pouvant être développées avec le C#

Formation

En Ligne

Prix sur demande

Appeler le centre

Avez-vous besoin d'un coach de formation?

Il vous aidera à comparer différents cours et à trouver la solution la plus abordable.

Description

  • Typologie

    Formation

  • Méthodologie

    En ligne

Grâce à cette formation vous pourrez acquérir les connaissances nécessaires qui vous permettrons d’ajouter des compétences à votre profil et obtenir de solides aptitude qui vous offriront de nombreuses opportunités professionnelles.

Questions / Réponses

Ajoutez votre question

Nos conseillers et autres utilisateurs pourront vous répondre

À qui souhaitez-vous addresser votre question?

Saisissez vos coordonnées pour recevoir une réponse

Nous ne publierons que votre nom et votre question

Les Avis

Les matières

  • C++

Le programme

Introduction du cours

Vous savez quoi ? Avec le C# on peut créer autre chose que des applications consoles !! Dingue non ? Des applications avec des boutons et des menus, ou des sites web et même des jeux.
Ces bonnes nouvelles sonnent la fin de nos applications console toutes noires et toutes tristes… mais grâce à ça, c’est le début d’une toute nouvelle aventure.
Dans ce chapitre, je vais vous présenter rapidement ce qu’on peut faire d’autre avec le C#. Chaque paragraphe de ce chapitre nécessite un livre entier pour être correctement traité. Aussi, je vais simplement vous montrer ce que l’on peut faire, histoire d’avoir un premier point de départ et de pouvoir décider vers quoi orienter vos prochaines lectures.

J’espère que vous me pardonnerez par avance de ce trop bref aperçu mais je souhaite néanmoins piquer votre curiosité pour vous donner envie d’aller explorer tous ces nouveaux mondes qui s’ouvrent à vous.
Il y aura sûrement des notions que vous ne comprendrez pas complètement en fonction des thèmes abordés. Il faudra aller jeter un œil complémentaire sur internet ou attendre un prochaine tutoriel ;) .

Créer une application Windows avec WPF

Les applications Windows sont ce qu’on appelle des applications clients lourds. Elles s’exécutent directement depuis notre système d’exploitation. Nous pouvons créer toutes sortes d’applications, comme un traitement de texte, une calculatrice, etc.

Nous avons déjà créé une application Windows à travers notre projet console, sauf que nous étions rapidement limités. Avec WPF, nous allons pouvoir créer des applications graphiques avec des boutons, des menus, … Bref, tout ce qui compose une application habituelle.
WPF signifie Windows Presentation Foundation. Il s’agit d’une bibliothèque permettant de réaliser des applications graphiques. Ces applications sont dites événementielles car elles réagissent à des événements (clic sur un bouton, redimensionnement de la fenêtre, saisie de texte, etc.)

Pour créer une application WPF, il faut commencer par choisir le type de projet adéquat. Dans Visual C# Express, nous choisissons le modèle « Application WPF » :

La première chose à savoir dans une application WPF est qu’elle se construit grâce à deux langages. Un langage de présentation qui va permettre de décrire le contenu de notre fenêtre : le XAML (prononcez xamelle) et du C# qui va permettre de faire tout le code métier.
Une application WPF est décomposée en fenêtres qui sont affichées à partir de l’application principale. Chaque fenêtre est composée d’un fichier .xaml qui contient la description de la fenêtre (l’emplacement des boutons, des images, …) et d’un fichier de code .xaml.cs qui contient le code associé à cette fenêtre. On appelle ce fichier le « code behind ».
Nous pouvons voir ceci après avoir créé notre projet car Visual C# Express créé automatiquement une fenêtre par défaut qui s’appelle MainWindow. Ce fichier est d’ailleurs ouvert automatiquement. Si nous déplions ce fichier dans l’explorateur de solutions, nous pouvons voir un autre fichier dessous qui possède l’extension .xaml.cs, le fichier de code behind.

Le XAML est une espèce de fichier XML qui va nous permettre de décrire le contenu de notre fenêtre. Cette fenêtre est composée de « contrôles », qui sont des éléments graphiques unitaires comme un bouton, une case à cocher, etc. Nous pouvons soit remplir ce fichier XAML à la main si nous connaissons la syntaxe, soit utiliser le designer pour y glisser les contrôles disponibles dans la boite à outils :

Positionnons un bouton par exemple grâce au glisser-déplacer. Nous obtenons :

Nous pouvons voir trois choses :

  • La première est le rendu de notre fenêtre dans la partie haute du fichier MainWindows.xaml. C’est ça qui sera affiché lors du lancement de notre application.

  • La deuxième est le descriptif de cette fenêtre dans le code XAML, c'est-à-dire le langage permettant de décrire la fenêtre. Ce XAML est modifié si nous ajoutons des contrôles avec le designer. Inversement, si nous modifions le code XAML, le designer se met à jour avec les modifications.

  • La troisième est que nous pouvons voir et modifier les propriétés du contrôle dans la fenêtre de propriétés. Ici par exemple, j’ai changé la propriété Content de mon bouton pour y mettre la phrase « Cliquez-moi », ce qui a pour effet de changer le texte du bouton et le code XAML.

Il y a beaucoup de contrôles dans la boite à outils. Rajoutons un Label, qui est une zone de texte non modifiable, ainsi qu’un Textbox, qui est une zone de texte modifiable, au-dessus du bouton.
Rajoutons également un autre Label en dessous du bouton.
Modifiez la propriété Content du premier label pour y saisir « Saisir votre nom : ». Dessinez le TextBox de manière à ce qu’il soit suffisamment grand pour accueillir un prénom et modifiez le nom du contrôle, en haut de la fenêtre de propriété, pour l’appeler « nom ». Enfin, dans le deuxième label, changez la propriété Foreground pour mettre du rouge et videz la propriété Content pour avoir une chaine vide.

Votre designer devrait ressembler à :

Et votre XAML à :

<Window x:Class="DemoWPF.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" Title="MainWindow" Height="350" Width="525"> <Grid> <Button Content="Cliquez-moi" Height="23" HorizontalAlignment="Left" Margin="214,86,0,0" Name="button1" VerticalAlignment="Top" Width="75" /> <Label Content="Saisir votre nom :" Height="28" HorizontalAlignment="Left" Margin="34,42,0,0" Name="label1" VerticalAlignment="Top" /> <TextBox Height="23" HorizontalAlignment="Left" Margin="155,44,0,0" Name="nom" VerticalAlignment="Top" Width="295" /> <Label Height="28" HorizontalAlignment="Left" Margin="94,132,0,0" Name="label2" VerticalAlignment="Top" Width="309" Foreground="Red" /> </Grid> </Window>

A noter que les valeurs des propriétés Margin ou Height seront sans doute différentes, vu qu’elles reflètent la façon dont j’ai dessiné les contrôles sur le designer.
Sélectionnez désormais le bouton dans le designer et cliquez sur le petit éclair dans la fenêtre des propriétés pour accéder à l’onglet des événements :

Dans l’événement Click, saisir un nom de méthode, par exemple OnClickBouton. A la validation, Visual C# Express nous génère une méthode dans le code behind :

private void OnClickBouton(object sender, RoutedEventArgs e) { }

C’est cette méthode qui va être appelée lorsque nous cliquerons sur le bouton.
En complément, le XAML se met à jour pour devenir :

<Button Content="Cliquez-moi" Height="23" HorizontalAlignment="Left" Margin="214,86,0,0" Name="button1" VerticalAlignment="Top" Width="75" Click="OnClickBouton" />

Nous pouvons y voir que la propriété Click (qui est un événement) est associée au nom de la méthode qui sera appelée lors du clic sur le bouton.

Le but de cette petite démo est de pouvoir saisir du texte dans le contrôle TextBox et d’afficher un message dans le label sous le bouton en fonction du nom saisi, par exemple « Bonjour [prénom] ». Pour accéder aux informations qui ont été saisies dans le champ, on utilise des variables qui ont été générées par Visual C# Express à partir du code XAML de description de la fenêtre. Il y a une variable générée par contrôle, sachant qu’elles possèdent le nom donné au contrôle. En l’occurrence, notre contrôle TextBox s’appelle « nom ». Nous allons pouvoir accéder à la valeur saisie grâce à la propriété Text de l’objet nom. A noter que la variable nom est du type TextBox qui est un contrôle de WPF. C’est la même chose pour le label, que nous n’avons pas renommé. Nous pouvons le modifier en utilisant sa propriété Content, ce qui donne :

private void OnClickBouton(object sender, RoutedEventArgs e) { label2.Content = "Bonjour " + nom.Text + " !!"; }

Lançons notre application avec F5, nous pouvons voir une fenêtre qui s’ouvre avec nos contrôles. Si nous saisissons un nom dans la zone de texte et que nous cliquons sur le bouton, nous pouvons voir :

Superbe !! Notre première application WPF fonctionnelle :) .
Regardons d’un peu plus près le code behind :

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Windows; using System.Windows.Controls; using System.Windows.Data; using System.Windows.Documents; using System.Windows.Input; using System.Windows.Media; using System.Windows.Media.Imaging; using System.Windows.Navigation; using System.Windows.Shapes; namespace DemoWPF { /// <summary> /// Logique d'interaction pour MainWindow.xaml /// </summary> public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void OnClickBouton(object sender, RoutedEventArgs e) { label2.Content = "Bonjour " + nom.Text + " !!"; } } }

Nous pouvons voir que Visual C# Express nous a inclus plein d’espace de noms qui nous serviront surement plus tard, mais aussi que la classe s’appelle du même nom que la fenêtre : MainWindow. Ce n’est pas un hasard, en fait la fenêtre est un objet qui hérite des fonctionnalités de base d’une fenêtre, en dérivant de la classe Window. WPF est composée de toute une hiérarchie de classes représentant les fenêtres, les contrôles et plein d’autres choses dans une approche orientée objet. Ces classes sont fortement réutilisables pour nos besoins.
En l’occurrence, notre fenêtre va hériter de plein de propriétés, comme sa taille, son titre, etc. A ces propriétés vont être rajoutées des variables membres qui servent à accéder aux contrôles que nous avons décrits dans le XAML.
En fait, le XAML a été transformé en code permettant de créer la fenêtre et ses composants. C’est ainsi que les label et le textbox ont été construits puis ajoutés au contenu de la fenêtre. Ce code généré est appelé depuis la méthode InitalizeComponent qui se trouve dans le constructeur de la classe. Une fois les contrôles initialisés, nous pouvons les utiliser grâce aux variables membres dont le nom est le même que celui des contrôles.
Nous retrouvons ici l’intérêt de la classe partielle. Le code automatique est généré dans la classe partielle et nous augmentons ses fonctionnalités, comme le traitement de l’événement de clic sur le bouton, dans un autre fichier sans risque d’écrasement des modifications.

Voilà ! Notre première application WPF est terminée. Plutôt pas mal non ? Il y aurait beaucoup de choses à dire encore, de contrôles à décrire, mais je vais terminer cet aperçu en vous parlant d’une fonctionnalité très pratique : le binding.

Le binding (ou liaison de données) est un moyen de lier des données à un contrôle. Cela permet de positionner automatiquement des valeurs aux propriétés des contrôles en fonction du contenu de la source de données. En effet, il est très fréquent de mettre des valeurs dans des TextBox ou dans des Label comme nous l’avons fait. Le binding est là pour faciliter tout ce qui peut être automatisable et risque d’erreurs. De plus, si la source de données change, il est possible de faire en sorte que le contrôle soit automatiquement mis à jour. Inversement, si des modifications sont faites depuis l’interface, alors on peut être notifié automatiquement des changements.
Pour illustrer son fonctionnement le plus simple, nous allons ajouter un contrôle de type ListBox à notre fenêtre de manière à ce que notre fenêtre contienne une ListBox et un label.
Puis nous allons modifier le code behind de la fenêtre pour avoir :

public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); listBox1.ItemsSource = new List<string> { "Nicolas", "Jérémie", "Delphine" }; } }

Lorsque nous démarrons l’application, nous pouvons voir que la ListBox s’est alimentée avec les valeurs de notre liste. Ici, c’est la propriété ItemsSource du contrôle qui va permettre la liaison de données. En fait, la propriété ItemsSource peut recevoir n’importe qu’elle source de données tant qu’elle implémente IEnumerable ou sa version générique. Cela peut être une requête Linq, issue d’une base de données ou non, ou simplement une liste comme ci-dessus. Cela donne :

Ici, nous lions les données à une source de données grâce au code behind. Il n’y a rien d’autre à faire, c’est le contrôle qui se charge tout seul d’afficher les données.
Ce genre de binding peut également se faire directement depuis le XAML et de manière plus ou moins complexe.
Illustrons ce fonctionnement en changeant le XAML du contrôle Label pour que sa propriété Content ressemble à :

<Label Content="{Binding ElementName=listBox1, Path=SelectedItem}" Height="28" HorizontalAlignment="Left" Margin="261,71,0,0" Name="label2" VerticalAlignment="Top" Width="230" Foreground="Red" />

C'est-à-dire modifier Content de cette façon :

Content="{Binding ElementName=listBox1, Path=SelectedItem}"

Cette syntaxe permet d’indiquer ici que nous souhaitons lier l’élément sélectionné de la listbox au contenu du label. Nous utilisons les accolades pour indiquer la liaison de données. Ici, la liaison se produit sur la propriété SelectedItem de la ListBox « listBox1 ».
Cela veut dire que lorsque nous allons démarrer l’application et sélectionner un élément de la ListBox, sa valeur va automatiquement s’afficher dans le label :

Plutôt pratique non ?
Le binding est une très vaste notion absolument indispensable pour toute application qui se respecte. A noter qu’il y a plusieurs modes de liaison :

Binding

Description

OneTime

La liaison se fait une unique fois au début. Si un changement se fait sur la source de données, on ne voit pas les modifications

One-way

La liaison ne se fait que dans un sens, de la source de données vers le contrôle. C’est celui que nous avons vu plus haut.

Two-way

La liaison se fait dans les deux sens. Cela veut dire qu’une modification dans l’interface se répercute automatiquement sur la source de données.

One-way-to-source

C’est le contraire du one-way, si la valeur du contrôle change, la source est mise à jour.

Il y a beaucoup de binding différents. Nous avons vu ici comment se lier à une liste à partir du code behind et comme lier une propriété d’un contrôle à la propriété d’un autre. Si vous étudiez en détail les différents bindinds de WPF, vous pourrez voir toute la puissance de la liaison de données à travers de multiples exemples.

Voilà pour ce petit tour de WPF. Il y aurait énormément d’autres choses à dire mais j’espère vous avoir donné envie de vous y plonger encore plus. Vous pouvez faire tout ce qu’une application de gestion fait...

Appeler le centre

Avez-vous besoin d'un coach de formation?

Il vous aidera à comparer différents cours et à trouver la solution la plus abordable.

Les différents types d'applications pouvant être développées avec le C#

Prix sur demande