Le #ifdef de C/C++ est ici un simple #if (valeur)

Les #define valeur doivent être placés en tête de fichier.

1. 1.Application Windows Form (WF): Application windows fenêtrée utilisant la techno Windows Forms. Il y a deux versions :  

• • ◦.Framework qui accède à toutes les fonctionnalités du Framework sans avoir rien à préciser 

  • ◦.NET pour lequel il faut ajouter une à une toutes les dépendances nécessaires à l'application. 

  La majorité des applications c# Windows non Console que j'écris sont des WF. 

1. 2.Application WPF : Application windows fenêtrée utilisant la techno Windows Presentation Fooundation basée sur une description de type *.xaml. Plus ancienne, mais intéressante car intègre des libraires 3D. Il existe des passerelles permettant d'activer une WPF depuis une WF (voir D:\MesProgs_Langages\MICROSOFT_VISUAL_STUDIO\C#-WPF\WF2WPF et WF2WPF_02) 

2. 3.Application console : Application utilisable en ligne de commande (.Framework ou .Net) 

3. 4.Projet partagé : Contient du code utilisable par d'autres projets. 

4. 5.Bibliotèque de classes : Code de classes utilisables par d'autres exécutables. 

5. 6.Application de navigateur WPF : Application pouvant être ouverte par un navigateur web. 

6. 7.Bibliothèque de contrôles utilisateur WPF : Pour étendre ceux offerts par Windows 

7. 8.Bibliothèque de contrôles personnalisés WPF : Idem. 

8. 9.Service Windows : programmes qui s'exécutent en tâche de fond. 

F1 direct : Aide sur mot clé.

SHIFT-F1 : Aide Editeur

using System;

class Hello

{

    static void Main()

    {

        Console.WriteLine("Hello, World");

    }

}

La directive using fait référence à un espace de noms donné. Elle permet l’utilisation non qualifiée des types membres de cet espace de noms. En raison de la directive using System,  un programme peut utiliser Console.WriteLine comme raccourci pour System.Console.WriteLine.

La classe Hello a un membre unique, la méthode nommée Main déclarée avec le modificateur static. Elle sert de point d’entrée au programme.

Les fichiers sources C# ont généralement l’extension de fichier .cs et sont compilés comme ceci :

csc hello.cs

Les programmes sont constitués de fichiers sources organisés en namespace (espace de nom). Les espaces de nom ont une structure hiérachque comme les fichiers ou les classes et sous-classes. Les innombrables méthodes fournies par Microsoft sont décrite dans la MSDN que l'on peut consulter ici :  https://docs.microsoft.com/fr-fr/dotnet/api/

Par exemple, la doc sur system.environment.username  se trouve ici :

https://docs.microsoft.com/fr-fr/dotnet/api/system.environment.username?view=net-5.0

Les programmes déclarent des types (class, interface, ...).

Les types ont des membres qui sont des champs, des méthodes, des propriétés, des évènements...

Lorsque les programmes .NET (C#, etc)  sont compilés, ils sont physiquement empaquetés dans des assemblys (assenblages de code executable) qui ont généralement l’extension de fichier .exe ou .dll, selon qu’ils implémentent des applications ou des bibliothèques.

Exemple de fichier acme.cs qui déclare une classe nommée Stack dans un espace de noms appelé Acme.Collections, ce qui fait que le nom complet de cette classe est Acme.Collections. Stack.

using System;

namespace Acme.Collections

{

    public class Stack

    {

        Entry top;

        public void Push(object data)

        {

            top = new Entry(top, data);

        }

        public object Pop()

        {

            if (top == null)

            {

                throw new InvalidOperationException();

            }

            object result = top.data;

            top = top.next;

            return result;

        }

        class Entry

        {

            public Entry next;

            public object data;

            public Entry(Entry next, object data)

            {

                this.next = next;

                this.data = data;

            }

        }

    }

}

La classe Stack contient

• •une classe imbriquée nommée Entry. 

• •un champ nommé top du type de la classe Entry, 

• •deux méthodes nommées Push et Pop 

La classe interne Entry contient trois membres en plus : deux champs nommés next et data et un constructeur.

Pour compiler cette routine en librairie et générer acme.dll faire :

csc /t:library acme.cs

Les assemblys contiennent un langage intermédiaire (IL) et des métadonnées. Au moment de l'utilisation, le compilateur juste à temps (JIT) du Common Language Runtime .NET (CLR) convertit le tout en code spécifique au processeur.

Les métadonnées des assemblys rendent inutiles les directives #include et les fichiers d’en-tête en C# pour accéder depuis un autre programme aux membres et types publics contenus dans un assembly. L'accès est direct par simple référence à cet assembly lors de la compilation du programme.

Ci-après le programme example.cs qui utilise la classe Acme.Collections.Stack à partir de l’assembly acme.dll :

using System;

using Acme.Collections;

class Example

{

    static void Main()

    {

        Stack s = new Stack();

        s.Push(1);

        s.Push(10);

        s.Push(100);

        Console.WriteLine(s.Pop());

        Console.WriteLine(s.Pop());

        Console.WriteLine(s.Pop());

    }

}

On compile en faisant référence à la dll comme suit :

csc /r:acme.dll example.cs

• •Entier signé : sbyte, short, int, long 

• •Entier non signé : byte, ushort, uint, ulong 

• •Caractères UTF-16  : char 

• •Virgule flottante pour valeur binaire IEEE : float, double 

• •Virgule flottante pour valeur décimale haute précision : decimal 

• •Booléen : bool : true ou false  

Ils sont tous initialisés par défaut par des  0000000...

Types définis par l'utilisateur de la forme enum E {...}

Types définis par l'utilisateur de la forme struct S {...}

Extensions de tous les autres types de valeurs avec une valeur null.  La syntaxe Nullable<T> ou T? étend le type T en lui permettant d'avoir la valeur null, par example lorsqu'il n'est pas défini. Exemples : int? x = 10; ou int? x = null; déclarent une variabe x de type Nullable<int> et l'initialisent respectivement à 10 et null.

Les propriétés HasValue et Value qui sont en lecture seule permettent de n'accéder à la valeur d'une variable nullable que lorsqu'elle existe, par ex : if (x.HasValue) y = x.Value;

Si Value est utilisé alors que HasValue est false a pour effet de lèver une InvalidOperationException. Remarque :  On aurait aussi pu écrire : if (x != null) y = x.Value;

Les  types objets simples sont des références sur des types valeur. La zone mémoire associée au nom de la variable contient le type de la variable et null ou l'adresse de la zone ou la valeur sera stockée.

• •Classe de base fondamentale de tous les autres types : object 

• •Chaînes Unicode : string 

• •Types définis par l'utilisateur de la forme class C {...} 

Types définis par l'utilisateur de la forme interface I {...}

Syntaxe très proche du C/C++ :

Types définis par l'utilisateur de la forme delegate int D(...)

Un delegate est un type référence qui peut être utilisé pour encapsuler une méthode anonyme ou nommée. Les délégués sont comparables aux pointeurs de fonction de C/C++ qui de plus sont sûrs et de type sécurisé. Un délégué peut être instancié en l’associant à une méthode nommée ou anonyme. Ils sont nécessaires pour appeler les méthodes des widgets des Forms depuis un autre thread (timer, ...) car ces méthodes ne sont normalement appelables que depuis le thread de la Form.

Chaque type dans C# dérive directement ou indirectement du type object, et object est la classe de base fondamentale de tous les types. Les valeurs des types référence sont considérées comme des objets simplement en affichant les valeurs en tant que type object. Les valeurs des types valeur sont considérées comme des objets en effectuant des opérations de boxing et d’unboxing. Dans l’exemple suivant, une valeur int est convertie en object et à nouveau en int.

using System;

class BoxingExample

{

    static void Main()

    {

        int i = 123;

        object o = i;    // Boxing : Allocation de o et copie de la valeur 123 à l'intérieur

        int j = (int)o;  // Unboxing (avec vérification de compatibilité avant affectation)

    }

}

A l'intérieur d'une fonction, on peut déclarer var une variable locale dont le type est évident. Le compilateur associe à la variable le bon type qu'il déduit du contexte. Exemple :

var x = 10; // x sera déclaré int

var s = Console.ReadLine(); // s sera déclaré string.

Ce sont tous des structure sauf  string et object qui sont des classes. Le type int est un alias C# qui désigne la structure .NET System.Int32. De même, le type C# string est un alias pour le type .NET System.String qui est une classe et non une structure.

Remarques :

• •pas de suffixe pour int et double 

• •suffixe L pour long, F pour float et M pour décimal 

• •la chaine verbatim @"c:\chap1\par3" commençant par @ où les caractères qui suivent les \ ne sont pas interprêtés. 

• •On peut utiliser le caractère _ pour séparer les groupes de milliers dans les décimaux, les octets dans les hexa et les blocs de 4 bits dans les binaires comme dans 0b0100_0100_0111_1100_0010. 

Opérateur (cast) comme en C/C++.

Un objet est créé par :

Toto toto ; // mais comme i n'est pas instancié (toto is null) est true.

Toto toto = new Toto; // là il est instancié.

toto.Dispose() ; détruit toto, mais (toto is null) est toujours vrai

toto = null; // permet ensuite de tester (toto is null).

La classe string est très proche de celle qu'on trouve en java et en Visual Basic, avec :

• •la concatenation offerte par l'opérateur + : "Lac Titi" + "caca"; 

• •conversion automatique de tous les objets concaténés en string par le biais de leur méthode ToString() qui peut prendre 0, 1 ou 2 arguments. S'il est présent le premier spécifie le type de sortie désirée : 

  • ◦"G"        : général 

  • ◦"C"        : currentie (monnaie -> $, £, € à la fin. 

  • ◦"Dn"   :  "D3" cad 3 chiffres  avec des 0 par devant 

  • ◦"En"        :  "E2" cad format XX.ddE+003 par exemple avec n d après le . 

  • ◦"F"        :  décimal ordinaire 

  • ◦"N"        : décimal avec regroupement des chiffres par groupes de 3 

  • ◦"P"        : suivi de % 

  • ◦"Xn"   : "X8" par exemple hexadécimal avec 8 chiffres  

Le caractère \ est un caractère d'échappement pour :

\'   \"   \\   \a (bip)  \b (backspace)  \f (saut de page)  \n  (saut de ligne) \r  (retour début de ligne)  \t (tab. horiz)  \v  (tab. vert.) \0  (null) et \uXXXX (unicode XXXX).

Dans une chaine préfixée par le caratère @ tous les caractères sont traités littéralement, même les caractères d'échappement, à l'exception du " qui doit être doublé. Exemple :

string nomfich = @"D:\DocsDiverses\Usinage\adresses.txt";

Le préfixe @ permet d'utilser les \ comme des caractères ordinaires.

En précédent une chaine par le caracère $ les éléments intérieurs compris entre accolades comme {var} sont évalués et remplacés par leur expression en chaine de caractères.

double pi = 3.141516; string s2 = $"Pi = {pi}";  

Peut éventuellement être plus pratique que le formatage utilié dans Console.WriteLine:

Console.WriteLine("La somme {0} + {1} vaut {2}",3,4,7);

Remarque : Dans le deux cas, entre les accolades que ce soit la variable {pi} de la chaine interpolée ou le rang {0}, {1}... de la chaine formatée de Writeline, la variable ou le rang peuvent être suivis d'une expression précisant le Format comme par exemple : {pi,7:F3} qui précise que le string généré va comporté 7 places de caractères, que la conversion en string sera de type F (flottant) et qu'il y aura 3 chiffres après le point décimal.

Le nombre de caractères est facultatif. S'il est absent la virgule aussi  : {pi:F3}

Le nombre de décimales est facultatif : {pi:F}

Le format est facultatif : {pi}

Pour mettre des zéros par devant il faut utiliser le format D suivi du nombre total de caractères, par exemple {45:D5} génère "00045"

Exemple : Lecture d'un tableau de valeurs dans un fichier :

StreamReader sr = new StreamReader("trajnum4.txt");

String line = sr.ReadLine(); // Saute la première ligne

while (true)

{

   line = sr.ReadLine();

   if (line == null) break;

   string[] ss = line.Split(' ');

   string[] vals = new string[6];

   int k = 0; // Enleve les strings vides, ne conserve que ceux qui ont une valeur

   foreach(var s in ss){ if (s.Length > 0){vals[k++] = s; if (k >= 6) break;}

   t = double.Parse(vals[0]);

   ah = double.Parse(vals[1]);

   dec = double.Parse(vals[2]);

   ad = double.Parse(vals[3]);

   va = double.Parse(vals[4]);

   vd = double.Parse(vals[5]);

   Console.WriteLine(String.Format("{0,4:F0} {1,9:F5} {2,9:F5} {3,9:F5} {4,9:F6} {5,9:F6} ", t, ah, dec, ad, va, vd));

}

sr.Close();

La méthode Split retourne un string pour chaque zone ne contenant pas d'espace, mais aussi un string vide pour chaque caractère espace, string qu'il faut éliminer.

int[] entiers = new int[4];

Avec la dimension déduite de l'initialisation :

int[] entiers = new int[] {0,10,20,30};

ou plus simplement

int[] entiers = {0,10,20,30};

Les tableaux multidimensionnels existent comme en C/C++ avec la possibilité de dimensions internes variables, mais il existe en plus des tableaux plus simples avec les dimensions internes fixes :

int[,] t1 = new int[2, 3];

int[,] t2 = { { 1, 2, 3 },{ 4, 5, 6 } };

Ici t2[1,1] == 5. en ligne 1, c'est-à-dire 2ème ligne, colonne 1, c'est-à-dire 2ème colonne.

Autre exemple :

double[,] tablo = new double[,] {{ 0.5, 1.7}, { 8.4, -6 }, {2.3, 1.2 }};

            Console.WriteLine("\ntablo est de dimension {0}x{1}",tablo.GetLength(0), tablo.GetLength(1));

Résultat :

tablo est de dimension 3x2

Les tuples sont des structures hyper simplifiées utilisées pour regrouper des éléments divers rangés entre parenthèses. On peut déclarer un tuple comme ceci :

(double taille, int age, int numero) individu;

Généralement on utilise des tuples anonymes comme retour de méthodes qui renvoient pluiseurs paramètres :

        public (double jdec, int mois, int annee) jul2dmy(double JJ)

        {

            double jd; int m, a;

            /* Calcul de jd, m, a */

            return (jd, m, a);

        }

Et on utilise directement les éléments internes, sans passer par un tuple nommé :

            double jde; int mo, an;

            (jde, mo, an) = A.jul2dmy(JJ);

Mais on peut aussi passer par l'intermédiaire d'un tuple nommé:

            (double, int, int) res = A.jul2dmy(JJ);

            Console.WriteLine($"Jdec = {res.Item1}, mois = {res.Item2}, an = {res.Item3}");

et accéder aux éléments par le biais des champs Item1,...

On peut affecter un tuple nommé ou anonyme à un autre tuple nommé ou anonyme de même composition.

Fonctionne de manière basique comme l'enum C/C++, mais c'est de plus une instance de la classe System.Enum qui offre de nombreuses méthodes assez complexes. Voir :

https://docs.microsoft.com/fr-fr/dotnet/api/system.enum?view=netframework-4.8

public const double PI = 3.14159;

Be peut plus être modifié.

private : accès réduit à la classe

protected : accès réduit à la classe et ses filles

internal : accès réduit aux classes de l'assembly qui déclarent la variable

protected internal : accès réduit aux classes de l'assembly qui déclarent la variable et aux classes filles de ces classes.

public : accès universel.

L'accès indexé aux membres d'un tableau par [ ] et aux membres d'une classe par . (point) comme en Java.

Pour éviter l'exception levée par l'accès à une référence nulle de classe ou de tableau, on peut précéder le . ou les [] d'un caractère ?. Ainsi personne?.nom ou tablo?[1,1] renverront la valeur null si personne ou tablo sont eux même null.

x = y ?? z;

Si y est non null, x vaut y, sinon il vaut z.

Comme en C/C++, java...

Les arguments des fonctions sont passés par valeur. C'est-à-dire que c'est une copie qui est utilisé dans la fonction.

Mais le mot clé ref, permet le passage par référence.

            int inc10(int x) { x += 10; return x; }

            int inc20(ref int x) { x += 20; return x; }

            int a = 1, b = inc10(a);

            Console.WriteLine($"a = {a}, b = {b}");

            int c = 1, d = inc20(ref c);

            Console.WriteLine($"c = {c}, d = {d}");

Résultat :

a = 1, b = 11

c = 21, d = 21

Un argument passé en mode out peut être modifié dans la fonction, même s'il n'est pas initialisé !

            void bizarre(out int x) { x = 12; }

            int a;

            bizarre(out a);

            Console.WriteLine($"a = {a}");

Résultat :

a = 12

Le mot clé params permet de passer des arguments en nombre variable. Il doit être le dernier de la liste d'arguments.

            void UseParams(int a, params int[] list)

            {

                Console.Write(a + " ");

                for (int i = 0; i < list.Length; i++) Console.Write(list[i] + " ");

                Console.WriteLine();

            }

            void UseParams2(params object[] list)

            {

                for (int i = 0; i < list.Length; i++) Console.Write(list[i] + " ");

                Console.WriteLine();

            }

            UseParams(1, 3, 4);

            UseParams2("Bonjour", "Michel");

            Console.ReadKey();

Résultat :

1 3 4

Bonjour Michel

Des arguments prédéfinis peuvent être omis dans la liste d'appel. Attention : Le premier omis force l'omission des suivants.

           void imprime (int a, int b = 12) {Console.WriteLine($"a = {a}, b = {b}");}

            imprime(3, 4);

            imprime(5);

Résultat :

a = 3, b = 4

a = 5, b = 12

On peut utiliser le nom des arguments pour les affecter dans l'appel, en ordre quelconque :

           void imprime (int a, int b = 12) {Console.WriteLine($"a = {a}, b = {b}");}

            imprime(b : 5, a : 10);

            imprime(5);

Résultat :

a = 10, b = 5

a = 5, b = 12

Bien sur, il y a des règles de cohérence à respecter pour que le compilateur s'y retrouve.

Comme dans Java ce sont des méthodes de la classe Math. Elles commencent par une majuscule.

Les classiques du C/C++ avec E/S  doubles : Acos, Asin, Atan, Atan2, Cos, Cosh, Exp, Log, Log10, Pow, Sin, Sqrt, Tan, Tanh.

BigMul : I32 x I32 : I64

Ceiling : E/S double ou Decimal : Arrondi vers + l'∞.

Floor :  E/S double ou Decimal : Arrondi vers - l'∞

Truncate :  E/S Decimal : Arrondi vers 0.

Round : E/S double ou Decimal : Arrondi vers le plus proche

DivRem  : int quotient = DivRem(int a, int b, out int reste) avec reste = a%b du signe de a.

IEEERemainder : double reste = IEEERemainder (double x, double y) en prenant pour quotient q l'entier le plus proche de x/y.

Abs, Max, Min : Sortie du même type que l'entrée.

Sign : int32 -1, 0 ou +1 selon le nombre.

E, PI.

• •if... else 

• •switch 

• •for 

• •do while 

comme en C/C++, java, mais de plus la condition testée peut être :

(val is v)

(val is TType v) ou TType est int, var, String...

(val is TType v when (v > 7)) ou TType est int, var, String...

Les deuxième arguments (V, TType, TType v when (v > 7)) peuvent intervenir aussi dans les case d'un switch.

En plus :

• •foreach(<type> <nomVar> in <collection>) { traitement de nomVar } 

• •goto etiquette; fait un saut à la ligne qui est commence par etiquette : 

• •using (...) {   ...   } garantit que le Dispose() sur la ressource non gérée sera effectué. 

L'information retournée par typeof est de la classe Type. Exemple :

Type t = typeof(String);

C'est le principal moyen d’accéder aux métadonnées. Les membres de Type permettent d'obtenir des informations sur une déclaration de type, sur les membres d’un type (tels que les constructeurs, les méthodes, les champs, les propriétés et les événements d’une classe), ainsi que le module et l’assembly dans lequel la classe est déployée.

Pour comparer le type d'un élément à une classe, on le fait avec is, qui permet en particulier de savoir si un élément est instancié en le comparant à null, pas avec == mais avec "is", comme ceci :

if (toto is null) ....;

E is T renvoie true s'ils sont de même type ou si on peut convertir E en type un élément de type T.

E as T où T est un type est équivalent à l'instruction E is T ? (T)(E) : (T)null  

c'est-à-dire, si E est de type convertible en T on fait un cast de E en type T, sinon on renvoi null de type T, ce qui est plus pratique que d'utiliser directement le cast du langage C : (T)(E) qui peut produire une erreur.

Modificateur mis devant une opération ou définition de fonction dans laquelle des pointeurs sont utilisé. On peut aussi déclarer un bloc unsafe.

    instructions;

}

où collection est une collection d'objets énumerables (tableaux, listes, ...)

Le mot clé yield permet de définir un itérateur sans classe explicite supplémentaire pour générer des énumérateurs. Dans l'example suivant, la fonction Power renvoie une énumération de int grace à l'utilisation de  yield return. cette énumération est utilisée dans l'instruction foreach du Main.

public class PowersOf2

{

    static void Main()

    {

        // Display powers of 2 up to the exponent of 8:

        foreach (int i in Power(2, 8))

        {

            Console.Write("{0} ", i);

        }

    }

  public static System.Collections.Generic.IEnumerable<int> Power(int number, int exponent)

    {

        int result = 1;

        for (int i = 0; i < exponent; i++)

        {

            result = result * number;

            yield return result;

        }

        yield break; // Inutile ici

    }

    // Output: 2 4 8 16 32 64 128 256

}

Les deux formes de l'instruction yield sont :

yield return <expression>; // Pour retourner les éléments un par un

yield break; // Pour terminer l'itération

Il ne peut pas y avoir d'instruction yield return dans un bloc try-catch. Une instruction yield return peut se trouver dans le bloc try d'une instruction try-finally.

Une instruction yield break peut se trouver dans un bloc try ou un bloc catch mais pas dans un bloc finally.

Si le corps foreach (en dehors de la méthode Iterator) lève une exception, un bloc finally de la méthode Iterator est exécuté.

Example :

static double Divide(double x, double y)

{

    if (y == 0)

        throw new DivideByZeroException();

    return x / y;

}

static void TryCatch(string[] args)

{

    try

    {

        if (args.Length != 2)

        {

            throw new InvalidOperationException("Two numbers required");

        }

        double x = double.Parse(args[0]);

        double y = double.Parse(args[1]);

        Console.WriteLine(Divide(x, y));

    }

    catch (InvalidOperationException e)

    {

        Console.WriteLine(e.Message);

    }

    finally

    {

        Console.WriteLine("Good bye!");

    }

}

Remarque :

• •catch (Exception e) : on traite toutes les exceptions 

• •catch (IndexOutOfRangeException e) : on ne traite que les débordements de tableau 

• •il peut y avoir plusieurs catch à la suite pour les différents types d'exception. 

• •la clause finally (facultative) a son code exécuté dans tous les cas, exception ou non. 

• •on peut ne pas mettre l'argument e si on ne l'utilise pas. 

• •on a intérêt au minimum d'imprimer le string e.Message. 

Example :

static void CheckedUnchecked(string[] args)

{

    int x = int.MaxValue;

    unchecked

    {

        Console.WriteLine(x + 1);  // Overflow

    }

    checked

    {

        Console.WriteLine(x + 1);  // Exception

    }

}

class Account

{

    decimal balance;

    private readonly object sync = new object();

    public void Withdraw(decimal amount)

    {

        lock (sync)

        {

            if (amount > balance)

            {

                throw new Exception("Insufficient funds");

            }

            balance -= amount;

        }

    }

}

static void UsingStatement(string[] args)

{

    using (TextWriter w = File.CreateText("test.txt"))

    {

        w.WriteLine("Line one");

        w.WriteLine("Line two");

        w.WriteLine("Line three");

    }

}

Un argument de fonction préfixé par le mot clé ref devient modifiable dans la fonction : il est passé par référence au lieu d'être passé par valeur, et de même avec le mot clé out. La différence est que l'argument préfixé ref doit obligatoirement être initialisé avant l'appel de la fonction.

Exposé limité aux apports par rapport aux autres langages.

Classe minimale avec un membre statique :

        class Toto { public int contenu = 10; }

        static void Main(string[] args)

        {

            Toto t = new Toto();

            Console.WriteLine("Contenu = {0}", t.contenu);

        }

Des membres peuvent être initialisés, entre accolades, après le new :

        class Toto { public int aa; public int bb; public int cc; }

        static void Main(string[] args)

        {

            Toto t = new Toto() {cc = 3, aa = 10 };

            Console.WriteLine("aa = {0}, bb = {1}, cc = {2}", t.aa, t.bb, t.cc);

        }

Les membres sont initialisés à 0 par défaut.

Sortie :

aa = 10, bb = 0, cc = 3

Appuyez sur une touche pour continuer...

Idem avec un constructeur qui initiale un membre :

        class Toto

        { public int aa; public int bb; public int cc;

            public Toto(int valb) { bb = valb; }

        }

        static void Main(string[] args)

        {

            Toto t = new Toto(5) {cc = 3, aa = 10 };

            Console.WriteLine("aa = {0}, bb = {1}, cc = {2}", t.aa, t.bb, t.cc);

        }

Sortie :

aa = 10, bb = 5, cc = 3

Appuyez sur une touche pour continuer...

Les membres affectés des attributs get et ou set peuvent être accédés comme les membres publics

Pour modifier la valeur ou accéder à la valeur d'un membre ou peut utliser les accessuers set et get, comme ci_après :

        class Toto { private int _aa;

            public int aa { get { return _aa; } set { _aa = value;} }

            public int bb { get; set; }

            public int cc;

            public Toto(int valb) { bb = valb; } }

        static void Main(string[] args)

        {

            Toto t = new Toto(5) {cc = 3, aa = 10 };

            Console.WriteLine("aa = {0}, bb = {1}, cc = {2}", t.aa, t.bb, t.cc);

        }

Ici pour le membres aa, quand on écrit x = t.aa c'est la fonction t.aa.get() qui est appelée, et quand on écrit t.aa = y, c'est la fonction t.aa.set(y) qui est appelée. Le membre interne privée _aa est utilisée pour stocker la valeur (remarquer le mot clé value qui pallie l'absence d'argument.

Il en est exactement de même pour le membre bb, mais ici les fonctions get et set sont créées avec le comportement par défaut comme pour aa, mais la valeur interne de stockage est anonyme.

Le membre cc est accessible directement.

Intérêt des get et set (?):

Le set comme celui utilisé dans le cas de aa, permet vérifier la valeur fournie avant de l'affecter, et de ne pas faire cette affection si elle ne convient pas.

Le get comme celui de aa permet de vérifier si certaines conditions sont réunies avant de délivrer la valeur demandée, ou éventuellement appeler une fonctionnalité pour la rafraichir.

Remarque : On utilise ci-dessous le raccourci => pour le corps d'une méthode qui peut se résumer à un return :

class Toto { private int _aa;

            public int aa { get =>_aa;  set { _aa = value;} }

            public int bb { get; set; }

            public int cc;

            public Toto(int valb) { bb = valb; } }

Une calsse existante, et en particulier les classes des API système et cie, peuvent être étendues très facilement par des méthodes statiques. Il suffit de les déclarer en statique dans une classe statique (dont le nom importe peu car il ne sera jamais utilisé) et de leur donner comme premier argument l'objet instance de la classe que l'on veut étendre, précédé du mot clé this dans sa définition.

Exemple : On étend la classe string avec une méthode qui compte les voyelles :

using System;

public static class MonExtension

{

    // La méthode d'extension pour le type string

    public static int CountVowels(this string str)

    {

        if (str == null) throw new ArgumentNullException(nameof(str));

        int count = 0;

        foreach (char c in str.ToLower()) { if ("aeiou".Contains(c)) count++;}

        return count;

    }

}

class Program

{

    static void Main()

    {

        string phrase = "Hello, World!";

        int vowelCount = phrase.CountVowels(); // Appel de la méthode d'extension

        Console.WriteLine($"Nombre de voyelles : {vowelCount}");

    }

}

Remarque : En mettant la méthode statique CountVowels directement dans la classe Program sans le mot clé this et en appellant int vowelCount = CountVowels(phrase); on obtient le même résultat. Morale !!!

Un objet délégué a des similitudes avec les pointeurs de fonction C ou les classes interface Java. Il définit une signature de méthode. Dans .NET, les types System.Action et  System.Func fournissent des définitions génériques pour de nombreux délégués courants qui permettent de créer des instanciations des types génériques fournis. Une instance de cette classe permet de passer une méthode en argument, ce qui ne serait pas possible autrement.

    class Program

    {

        // Nous définissons un type délégué int bidon(int, int)

        // de même signature que les méthodes qu'on va empaqueter

        // à l'EXTERIEUR de la METHODE qui l'utilise (ici Main).

        delegate int MyDelegate(int i, int j);

        delegate void MyPrint(string s);

        static MyPrint print = Console.WriteLine;

        static void Main(string[] args)

        {

            // Les méthodes

            int somme(int i, int j){return i + j;}

            int produit(int i, int j) { return i * j; }

            int rapport(int i, int j) { return i / j; }

            MyDelegate op1 = new MyDelegate(somme);

            MyDelegate op2 = produit; // Le new est inutile

            var op3 = new MyDelegate(rapport); // Ici, il l'est

            // Une méthode qui prend une fonction inconnue en argument

            int work(int i, int j, MyDelegate op) {return op(i,j);}

            // En argument de work, on peut passer la fonction ou le délégué

            print("Le somme de {0}+{1}={2}", 3, 5, work(3, 5, op1));

            Console.WriteLine("Le produit  {0}+{1}={2}", 5, 7, work(5, 7, produit));

            Console.WriteLine("Le rapport  {0}/{1}={2}", 9, 3, work(9, 3, rapport));

            // On peut utiliser un délégué à la place de la fonction

            print("Le produit  {0}+{1}={2}", 5, 7, produit(5, 7));

            Console.WriteLine("Le rapport  {0}/{1}={2}", 9, 3, op3(9,3));

        }

    }

Remarquons que le délégué de signature int bidon(int, int) est déclaré à l'extérieur de la méthode (ici Main) qui s'en sert, alors que le délégué print qui est déclaré à l'extérieur doit être déclaré static, comme le Main.

On définit ici 3 délégués op1, op2 et op3 des méthodes somme, produit et rapport. de 3 manières différentes. La seconde MyDelegate op2 = produit;  est la plus simple et la plus fréquemment utilisée.

La définition de ce MyDelegate est nécessaire à l'écriture de la fonction

int work(int i, int j, MyDelegate op) qui prend en argument une fonction parmi plusieurs, quelconque a priori. En C#, il n'y a pas d'autre moyen de lui fournir l'argument op.

Par contre lors de l'utilisation de la fonction work dans les Console.WriteLine, on peut mettre en argument le nom du délégué (exemple op1) ou de la fonction (exemple produit et rapport).  

Remarquer la différence entre les arguments op1, produit, rapport des méthodes work qui représente bien une référence sur une fonction et l'argument  work(..) dans Console.WriteLine qui représente la valeur renvoyée par work(..).

Enfin dans l'avant dernier  Console.WriteLine on utilise directement le résultat renvoyé par la fonction produit alors que dans le dernier on utilise le résultat renvoyé par le délégué op3 de la fonction rapport, qui peut lui être substitué.

Un délégué peut être réaffecté à une autre fonction de même signature :

    class Program

    {

        public class Person

        {

            public string nom, prenom;

            public Person(string _nom, string _prenom){nom = _nom; prenom = _prenom;}

            public void ShowNom(string msg) {Console.WriteLine(msg + nom);}

            public void ShowPrenom(string msg) {Console.WriteLine(msg + prenom);}

        }

        public delegate void MonDelegue(string msg);

        static void Main(string[] args)

        {

            var per = new Person("Brassens", "Georges");

            MonDelegue unDelegue = per.ShowNom;

            unDelegue("Nom : ");

            unDelegue = per.ShowPrenom;

            unDelegue("Prénom : ");

        }

    }

Ici unDelegue est d'abord affecté à la méthode per.ShowNom, puis il est affecté à la méthode per.ShowPrenom .

Remarque : Void plus loin le delegate Func qui simplifie tout cela !

Un type délégué de signature renvoyant un void peut être instancié avec plusieurs méthodes qui seront appelées en séquence à l'invocation du délégué. On ajoute une méthode par += et on retranche une méthode présente par -=. Exemple :

        public class Oper

        {

            public static void Add(int x, int y)

            {Console.WriteLine("{0} + {1} = {2}", x, y, x + y);}

            public static void Sub(int x, int y)

            {Console.WriteLine("{0} - {1} = {2}", x, y, x - y);}

        }

        delegate void MyDelegate(int x, int y);

        static void Main(string[] args)

        {

            var ops = new MyDelegate(Oper.Add);

            Console.WriteLine("Addition seulement :");

            ops(9, 3);

            Console.WriteLine("Addition et soustraction :");

            ops += new MyDelegate(Oper.Sub);

            ops(6, 4);

            Console.WriteLine("Soustraction seulement :");

            ops -= new MyDelegate(Oper.Add);

            ops(2, 8);

        }

Sortie :

Addition seulement :

9 + 3 = 12

Addition et soustraction :

6 + 4 = 10

6 - 4 = 2

Soustraction seulement :

2 - 8 = -6

Remarque : un délégué defini dans une classe ne peut pas être défini à l'extérieur de cette classe par un = . On ne peut qu'utiliser  += ou -= pour lui ajouter ou retrancher des méthodes.

Il existe de nombreux délégués prédéfinis pour les méthodes prenant de 0 à 16 arguments et renvoyant un résultat. Ce délégué est invoqué par le type Func<Targ1,...TargN, Tret>.

Exemple avec un délégué ordinaire delegate int MyDelegate(int i) utilisé pour carre et un délégué prédéfini Func<int,int,long>  utilisé pour somme.

    class Program

    {

        delegate int MyDelegate(int i);

        static void Main(string[] args)

        {

            int carre(int i) { return i*i; } // Une methode

            MyDelegate degCarre = carre; // Un delegué sur cette méthode

            Console.WriteLine("Le carre de {0}={1}", 7, degCarre(7));

            long somme(int i, int j) { return i + j; } // Une methode

            Func<int,int,long> degSomme = somme; // Un delegué sur cette méthode

            Console.WriteLine("Le somme de {0}+{1}={2}", 3, 5, degSomme(3, 5));

        }

    }

Autre exemple : L'ancien code suivant :

        delegate int MyDelegate(int i, int j);

        static void Main(string[] args)

        {

            int somme(int i, int j){return i + j;}

            MyDelegate op1 = new MyDelegate(somme);

            int work(int i, int j, MyDelegate op) {return op(i,j);}

            print("Le somme de {0}+{1}={2}", 3, 5, work(3, 5, op1));

      ....

est avantageusement remplacé par :

        static void Main(string[] args)

        {

            int somme(int i, int j){return i + j;}

            int work(int i, int j, Func<int, int, int> op) {return op(i,j);}

            print("Le somme de {0}+{1}={2}", 3, 5, work(3, 5, op1));

      ....

Pour 0 ou 1 paramètre et pas de retour on utilise le type Action<> qui serait l'équivalent du type Func, sans Tret et avec au plus un Targ.

Ce type défini un délégué sur un prédicat, c'est-à-dire une méthode qui retournent un booléen. Il est invoqué par Predicate<Targ..>. Exemple

        static void Main(string[] args)

        {

            // Le prédicat : méthode qui renvoie un booleen

            bool greaterThanThree(int x) { return x > 3; }

            // Un delegue sur un prédicat qui prend un int en argument

            Predicate<int> myPred = greaterThanThree;

            // Une liste d'entiers

            List<int> vals = new List<int> { 4, 2, 3, 0, 6, 7, 1, 9 };

            // On applique un tri basée sur le prédicat

            List<int> valsupa3 = vals.FindAll(myPred);

            // On imprime le résultat

            foreach (int i in valsupa3) { Console.WriteLine(i); }

        }

Lorsque la méthode qui sera instanciée pour le délégué delegate int MyDelegate(string s);

ne sert qu'à cette instanciation, il est inutile de la définir en tant que méthode nommée, on peut la définir en tant que méthode anonyme comme suit :

MyDelegate op = new MyDelegate(delegate (string s) { Console.WriteLine(s);  return 100; });  

ou plus simplement comme suit :

MyDelegate op = delegate (string s) { Console.WriteLine(s);  return 100; };

ou encore plus simplement, avec l'opérateur lambda =>.

MyDelegate op = (string s) => { Console.WriteLine(s); return 100; };

Le symbole => peut être utilisé comme opérateur Lambda de définition d'une instance de délégué (pointeur sur une méthode) anonyme ou pour définir le corps de l'expression d'un constructeur , finaliseur ou setteur d'un membre d'une classse

L'opérateur Lamda (=>) permet de définir la méthode anonyme, instance d'un délégué de manière plus concise (mais assez cabalistique), en omettant le terme delegate et le nom de la fonction (elle devient anonyme), et en faisant suivre les arguments éventuels entre parenthèse () des symboles => : Plusieurs formes possibles :

MyDelegate op = new MyDelegate((string s) => { Console.WriteLine(s); return 100; });

peu utilisée car assez lourde, ou :

MyDelegate op = (string s) => { Console.WriteLine(s); return 100; };  

Cette expression peut encore être simplifiée

• •en supprimant les parenthèses autour de l'argument de la méthode s'il est unique (on met les parenthèses pour 0 argument ou > =2) 

  MyDelegate op = s => { Console.WriteLine(s); return 100; };   

• •en supprimant les {} s'il n'y a qu'une expression dans le corps de la méthode 

• •et de plus en supprimant le mot clé return et le ; dans le cas d'un simple transfert de données, exemple : 

  MyDelegate op = a => b; dans le cas d'une méthode prenant un argument du même type que celui de a et renvoyant un élément du même type que celui de b. 

Délégué de méthode nommée :

Tref methode(Targs){..., return tref;} // La méthode nommée

delegate Tret MyDel(Targs); // La signature du délégué

MyDel op = new MyDel(methode);  // version delayée

MyDel op = methode; // version succinte

Délégué de méthode anonyme

delegate Tret MyDel(Targs); // La signature du délégué

MyDel op = new MyDel(delegate(Tref) => {..., return tref;});  // version delayée

MyDel op = delegate(Tref){..., return tref;};  // version succinte

MyDel op = (Tref) => {..., return tref;}; // version lambda

Pour passer un gestionnaire d'événements en arguments de méthode, on est conduit à définir un délégué retournant un void et prenant deux arguments, un objet et un EventArgs, comme suit :

public delegate void MonDeleg(object sender, EventArgs e);

(on peut mettre autre chose à la place de l'EventArgs, un String par exemple).

Pour que ce délégué soit associé à un événement c'est assez compliqué car il faut passer par l'intermédiaire d'une classe ClassEmettriceEvent à l'intérieur de laquelle on mettra une instance non initialisée de ce délégué, préfixée du mot clé event, comme suit :

public event MonDeleg monDelegEvent;  

Cette classe sera également pourvue d'une méthode qui, le moment sera venu, permettra d'émettre l'événement :       

public void emitTheEvent()

{ if (monDelegEvent != null) monDelegEvent(this, EventArgs.Empty);}  

le délégué est testé à null, au cas où il ne serait pas initialisée lors d'une tentative d'émission de l'événement.

La callback, définie généralement dans une autre partie du code, sera du genre :

void OnMyEventCallback(object sender, EventArgs e)

{ Console.WriteLine("On a reçu ..."); }

Dans cette autre partie du code (classe) pour pouvoir émettre l'événement, on créera une instance emetteur de ClassEmettriceEven, et on associera notre callback au délégué de gestion d'événement :

var emetteur = new ClassEmettriceEvent();

emetteur.monDelegEvent += new MonDeleg(OnMyEventCallback);

Puis dans cette classe (ou ailleurs ?) on pourra, au moment adéquat, émettre l'événement par :

emetteur.emitTheEvent();

Exemple : Tire des nombres au hasard et émet un événement si c'est un 5

    class Program

    {

        public delegate void MonDeleg(object sender, EventArgs e);

        public class ClassEmettriceEvent

        {

            public event MonDeleg monDelegEvent;

            public void emitTheEvent()

            { if (monDelegEvent != null) monDelegEvent(this, EventArgs.Empty);}

        }

        // Tire des nombres au hasard et émet un événement si c'est un 5

        static void Main(string[] args)

        {

            void OnMyEventCallback(object sender, EventArgs e)

            { Console.WriteLine("On a reçu un 5");}

            var emetteur = new ClassEmettriceEvent();

            emetteur.monDelegEvent += new MonDeleg(OnMyEventCallback);

            var random = new Random();

            for (int i = 0; i < 20; i++)

            {

                int rn = random.Next(6);

                Console.WriteLine(rn);

                if (rn == 5) emetteur.emitTheEvent();

            }

        }

    }

Remarque : Dans l'exemple ci-après, on a remplacé le deuxième argument EventArgs e par un string e pour pouvoir passer une information supplémentaire lors de l'émission de l'événement :

    class Program

    {

        public delegate void MonDeleg(object sender, string e);

        public class ClassEmettriceEvent

        {

            public event MonDeleg monDelegEvent;

            public void emitTheEvent(string s)

            { if (monDelegEvent != null) monDelegEvent(this, s);}

        }

        // Tire des nombres au hasard et émet un événement si c'est un 5

        static void Main(string[] args)

        {

            void OnMyEventCallback(object sender, string e)

            { Console.WriteLine("On a reçu un 5 au tirage n°"+e);}

            var emetteur = new ClassEmettriceEvent();

            emetteur.monDelegEvent += new MonDeleg(OnMyEventCallback);

            var random = new Random();

            for (int i = 0; i < 20; i++)

            {

                int rn = random.Next(6);

                Console.WriteLine(rn);

                if (rn == 5) emetteur.emitTheEvent(i.ToString());

            }

        }

    }

Mais il est plus judicieux d'utiliser une classe dérivée de EventsArgs, comme dans l'exemple ci-après :

    public class Program

    {

        public delegate void MonDeleg(object sender, MyEventArgs e);

        public class MyEventArgs : EventArgs

        {

            public int count; public DateTime time;

            public MyEventArgs(int _count, DateTime _time)

            { count = _count; time = _time; }

        }

        public class ClassEmettriceEvent

        {

            public event MonDeleg monDelegEvent;

            public void emitTheEvent(MyEventArgs e)

            { if (monDelegEvent != null) monDelegEvent(this, e); }

        }

        static void Callback(object sender, MyEventArgs e)

        { Console.WriteLine("Tirage d'un 5 n°{0} intervenu à {1}", e.count, e.time); }

        static void Main(string[] args)

        {

            int count = 0;

            MyEventArgs evArgs;

            var emetteur = new ClassEmettriceEvent();

            emetteur.monDelegEvent += Callback;

            var random = new Random();

            for (int i = 0; i < 20; i++)

            {

                int rn = random.Next(6);

                Console.WriteLine(rn);

                if (rn == 5)

                {

                    count++;

                    evArgs = new MyEventArgs(count, DateTime.Now);

                    emetteur.emitTheEvent(evArgs);

                }

            }

        }

    }

VOIR https://zetcode.com/csharp/delegate/

Invoke est une méthode de certains widgets et en particulier de la classe Form. Ses prototypes sont les suivants :

        public object Invoke(Delegate method);

        public object Invoke(Delegate method, params object[] args);

Dans le premier cas, le délégué représente une méthode qui ne prend aucun arguments, et dans le deuxième cas la méthode peut predre un ou plusieurs arguments.

On ne peut pas appeler appeler une méthode d'un widget d'une Forme depuis un thread différent de celui de la Form, mais depuis ce thread différent, on peut appeler la méthode Invoke, qui sert à cette communication.

On définiera donc un délégué comme suit :

delegate Toto MethodeDelegate(Titi a, Tata b);

et on en crééra une instance, non encore initialisée.

MethodeDelegate methodDelegue;

Supposons que la méthode candidate soit :

Toto methode(Titi a, Tata b)

{ ... }

On initialisera le délégué dans une des méthodes d'initialisation :

  methodDelegue =  methode;

Et dans le thread qui veut appeler methode(a, b), on fera :

object[] args = new object[2];

// On affecte les valeurs des Titi x et Tata y au tableau d'objects args

args[0] = x; args[1] = y; Invoke(methodDelegue, args);

et cela doit marcher !

MethodInvoker simplifie légèrement la procédure précédente. Il représente un délégué simple  un qui permet d'exécuter toute méthode retournant un void et n'acceptant aucun paramètre. Ce délégué peut être utilisé lors de l’appel à la méthode d’un contrôle Invoke et lorsqu'on a besoin d’un délégué simple rapidement codé.

Exemple, dans une callback associée à la réception de signaux série, on veut activer un radioButton de la forme this. On fait alors l'appel suivant dans la callback :

this.Invoke(new MethodInvoker(delegate () { radioButtonPPS.Checked = port.CDHolding; }));

que l'on peut simplifier en

this.Invoke((MethodInvoker) delegate () { radioButtonPPS.Checked = port.CDHolding; });

alors que le codage direct de :

radioButtonPPS.Checked = port.CDHolding;

produit ce message d'erreur : System.InvalidOperationException : 'Opération inter-threads non valide : le contrôle 'radioButtonPPS' a fait l'objet d'un accès à partir d'un thread autre que celui sur lequel il a été créé.'

Les sorties écran se font avec System.Console.Out (sur out = 1) et  System.Console.Out (sur error = 2) au moyen des méthodes Write et WriteLine, etc... On peut abréger  System.Console.Out.Write en  System.Console.Write etc...

Les entrées clavier se font avec avec System.Console.In (sur in = 0)  au moyen de la méthodes ReadLine()...  On peut abréger  System.Console.In.ReadLine() en  System.Console.ReadLine().

Ces entrées sorties peuvent être redirigées depuis ou vers des fichier en ajoutant sur la ligne de commande les classiques chevrons de redirection :

0<in.txt,  1>out.txt ,  1>>out.txt,  2>error.txt,  2>>error.txt,

1>out.txt 2>error.txt, ...

On peut formater chaque paramètre par une expression entre accolades {}. Les types de formatage suivant existent :

            "(C) Currency: . . . . . . . . {0:C}\n" +

            "(D) Decimal:. . . . . . . . . {0:D}\n" +

            "(E) Scientific: . . . . . . . {1:E}\n" +

            "(F) Fixed point:. . . . . . . {1:F}\n" +

            "(G) General:. . . . . . . . . {0:G}\n" +

            "    (default):. . . . . . . . {0} (default = 'G')\n" +

            "(N) Number: . . . . . . . . . {0:N}\n" +

            "(P) Percent:. . . . . . . . . {1:P}\n" +

            "(R) Round-trip: . . . . . . . {1:R}\n" +

            "(X) Hexadecimal:. . . . . . . {0:X}\n",

Exemple : Console.Writeline("Pi = {0:F}",3.1415) va imprimer 3.1415

Dans l'accolade le 1er paramètre est le rang (base 0) de l'argument. Il peut être le seul paramètre.

Après le ":" figure le format (C, D, E, ....)

Le caractère ":" peut être précédé de la longueur du champ qui est alors précédé d'une virgule ","

Le format peut être suivi du nombre de décimales.

Le format {x,y:Zz} affiche le paramètre n° x en utilisant exactement y caractères dans le format de type Z avec z caractères après le point décimal pour les types E, F et G.

Console.WriteLine(String.Format("{0,4:F0} {1,9:F5} {2,9:F5} {3,9:F5} {4,9:F6} {5,9:F6} ", t, ah, dec, ad, va, vd));

Pour un format entier avec les espaces antérieurs remplacés par des 0, utiliser :Dn.

produit :

   3  93.63420  11.23390 -173.09020 -0.013740  0.123890

// This code example demonstrates the Console.WriteLine() method.

// Formatting for this example uses the "en-US" culture.

using System;

class Sample

{

    enum Color {Yellow = 1, Blue, Green};  

 static DateTime thisDate = DateTime.Now;

    public static void Main()

    {

        Console.Clear();

        // Format a negative integer or floating-point number in various ways.

        Console.WriteLine("Standard Numeric Format Specifiers");

        Console.WriteLine(

            "(C) Currency: . . . . . . . . {0:C}\n" +

            "(D) Decimal:. . . . . . . . . {0:D}\n" +

            "(E) Scientific: . . . . . . . {1:E}\n" +

            "(F) Fixed point:. . . . . . . {1:F}\n" +

            "(G) General:. . . . . . . . . {0:G}\n" +

            "    (default):. . . . . . . . {0} (default = 'G')\n" +

            "(N) Number: . . . . . . . . . {0:N}\n" +

            "(P) Percent:. . . . . . . . . {1:P}\n" +

            "(R) Round-trip: . . . . . . . {1:R}\n" +

            "(X) Hexadecimal:. . . . . . . {0:X}\n",

            -123, -123.45f);

        // Format the current date in various ways.

        Console.WriteLine("Standard DateTime Format Specifiers");

        Console.WriteLine(

            "(d) Short date: . . . . . . . {0:d}\n" +

            "(D) Long date:. . . . . . . . {0:D}\n" +

            "(t) Short time: . . . . . . . {0:t}\n" +

            "(T) Long time:. . . . . . . . {0:T}\n" +

            "(f) Full date/short time: . . {0:f}\n" +

            "(F) Full date/long time:. . . {0:F}\n" +

            "(g) General date/short time:. {0:g}\n" +

            "(G) General date/long time: . {0:G}\n" +

            "    (default):. . . . . . . . {0} (default = 'G')\n" +

            "(M) Month:. . . . . . . . . . {0:M}\n" +

            "(R) RFC1123:. . . . . . . . . {0:R}\n" +

            "(s) Sortable: . . . . . . . . {0:s}\n" +

            "(u) Universal sortable: . . . {0:u} (invariant)\n" +

            "(U) Universal full date/time: {0:U}\n" +

            "(Y) Year: . . . . . . . . . . {0:Y}\n",

            thisDate);

        // Format a Color enumeration value in various ways.

        Console.WriteLine("Standard Enumeration Format Specifiers");

        Console.WriteLine(

            "(G) General:. . . . . . . . . {0:G}\n" +

            "    (default):. . . . . . . . {0} (default = 'G')\n" +

            "(F) Flags:. . . . . . . . . . {0:F} (flags or integer)\n" +

            "(D) Decimal number: . . . . . {0:D}\n" +

            "(X) Hexadecimal:. . . . . . . {0:X}\n",

            Color.Green);      

    }

}

/*

This code example produces the following results:

Standard Numeric Format Specifiers

(C) Currency: . . . . . . . . ($123.00)

(D) Decimal:. . . . . . . . . -123

(E) Scientific: . . . . . . . -1.234500E+002

(F) Fixed point:. . . . . . . -123.45

(G) General:. . . . . . . . . -123

    (default):. . . . . . . . -123 (default = 'G')

(N) Number: . . . . . . . . . -123.00

(P) Percent:. . . . . . . . . -12,345.00 %

(R) Round-trip: . . . . . . . -123.45

(X) Hexadecimal:. . . . . . . FFFFFF85

Standard DateTime Format Specifiers

(d) Short date: . . . . . . . 6/26/2004

(D) Long date:. . . . . . . . Saturday, June 26, 2004

(t) Short time: . . . . . . . 8:11 PM

(T) Long time:. . . . . . . . 8:11:04 PM

(f) Full date/short time: . . Saturday, June 26, 2004 8:11 PM

(F) Full date/long time:. . . Saturday, June 26, 2004 8:11:04 PM

(g) General date/short time:. 6/26/2004 8:11 PM

(G) General date/long time: . 6/26/2004 8:11:04 PM

    (default):. . . . . . . . 6/26/2004 8:11:04 PM (default = 'G')

(M) Month:. . . . . . . . . . June 26

(R) RFC1123:. . . . . . . . . Sat, 26 Jun 2004 20:11:04 GMT

(s) Sortable: . . . . . . . . 2004-06-26T20:11:04

(u) Universal sortable: . . . 2004-06-26 20:11:04Z (invariant)

(U) Universal full date/time: Sunday, June 27, 2004 3:11:04 AM

(Y) Year: . . . . . . . . . . June, 2004

Standard Enumeration Format Specifiers

(G) General:. . . . . . . . . Green

    (default):. . . . . . . . Green (default = 'G')

(F) Flags:. . . . . . . . . . Green (flags or integer)

(D) Decimal number: . . . . . 3

(X) Hexadecimal:. . . . . . . 00000003

*/

On peut formater à notre convenance, jusqu'à la précision du tick (100 nanosecondes, soit 7 chiffres après la virgule des secondes), par exemple :

System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffffff")

La lecture dans un fichier texte se fait avec un objet StreamReader via ses méthodes Read et ReadLine, et les écritures dans un fichier texte se font avec un objet StreamWriter via ses méthodes Write et WriteLine.

Elle est déclarée comme suit :

avec un argument facultatif. S'il est présent, on obtient le nombre des éventuels arguments de la ligne de commande par args.Length.

La méthode main est obligatoirement déclaré static ce qui permet à runtime d'activer cette méthode sans créer d'objet de la classe englobante.

Pour associer une callback à un widget, le sélectionner dans la fenêtre Form1.cs[Design], puis, à gauche afficher la liste des propriétés du widget, sélectonner la liste des événements (icone éclair) et dans cette liste choisir l'événement adéquat et donner un nom à la callback. Puis remplir son champ d'instructions dans le Form1.cs.

MessageBox.Show("Texte", "Titre", MessageBoxButtons.OK, MessageBoxIcon.Information);

Le paramètre de MessageBoxButtons peut prendre les valeurs suivantes :
AbortRetryIgnore, Ok, OkCancel, RetryCancel, YesNo, YesNoCancel.

Le paramètre de MessageBoxIcon peut prendre les valeurs suivantes :
Asterisk|Exclamation|Information, Question, Warning

On peut récupérer le résultat et le traiter :

Avec les possibilités suivantes pour DialogResult :
Abort, Cancel, Ignore, No, None, OK, Retry, Yes

La classe ToolTip permet de faire apparaitre un message lorsque l'utilisateur laisse la souris sur un widget.

On peut détourner le Tooltip pour faire l'équivalent des Toast Android, c'est-à-dire un message furtif. Par exemple lors de l'appui sur un bouton, si dans la callback associée au click sur ce bouton, on veut, dans certaines circonstance, envoyer un message furtif, on pourra faire :

new ToolTip().Show("le message a envoyer", this, Cursor.Position.X - this.Location.X, Cursor.Position.Y - this.Location.Y, 1000);

ou en windowsForm :

Application.exit().

Autocheck : Pour les radioButton, etc... pour permettre ou non l'acces à l'utilisateur (= readonly).

Cette classe permet d'accéder à des intervalles de temps assez précis.

Stopwatch.IsHighResolution est un bool qui indique si le système  offre un compteur de haute résolution (< ms) ou non.

Stopwatch.GetTimestamp() donne le nombre de ticks écoulés depuis le démarrage de l'ordinateur.

Stopwatch.Frequency est le nombre de ticks par secondes.

On peut créer une Stopwatch : Stopwatch chrono; et le démarrer par :

chrono = Stopwatch.StartNew();  

et l'arrêter par : chrono.stop();.

Les propriétés :

• •chrono.ElapsedTicks fournit le nombre de ticks écoulés depuis le dernier Stopwatch.StartNew(); 

• •chrono.ElapsedMilliseconds fournit le nombre de millisecondes écoulées depuis le dernier Stopwatch.StartNew(); 

Les Stopwatch créés dans différents threads sont indépendants.

using System;

Propriétés :

string CommandLine (get)

string CurrentDirectory  (get,set)

int CurrentManagedThreadId { get; }

int ExitCode { get; set; }

bool HasShutdownStarted { get; }

bool Is64BitOperatingSystem { get; }

bool Is64BitProcess { get; }

string MachineName { get; }

string NewLine { get; }

OperatingSystem OSVersion { get; }

        OperatingSystem os = Environment.OSVersion;

        Console.WriteLine("Current OS Information:\n");

        Console.WriteLine("Platform: {0:G}", os.Platform);

        Console.WriteLine("Version String: {0}", os.VersionString);         Console.WriteLine("Version Information:");

        Console.WriteLine(" Major: {0}", os.Version.Major);

        Console.WriteLine(" Minor: {0}", os.Version.Minor);

        Console.WriteLine("Service Pack: '{0}'", os.ServicePack);

int ProcessorCount { get; }

string StackTrace { get; }

string SystemDirectory { get; }

int SystemPageSize { get; }

int TickCount { get; } // nombre de millisecondes écoulées depuis le démarrage du système (signé passe en négatif)

string UserDomainName { get; }

bool UserInteractive { get; } // indique si le processus en cours est exécuté en mode interactif avec l'utilisateur.

string UserName { get; }

Version Version { get; }

long WorkingSet { get; } //quantité de mémoire physique mappée au contexte du processus.

Une Windows Form est un objet fenêtre qui hérite de la classe Form (parfois traduite en français par Formulaire).

Une windows Form standard utilise les références suivantes :

• •Analyseur, 

• •Microsoft.Csharp 

• •System 

• •System.Core 

• •System.Data 

• •System.Data.DataSetExtensions 

• •System.Deployment 

• •System.Drawing 

• •System.Net.Http 

• •System.Windows.Forms 

• •System.Xml 

• •System.Xml.Linq 

On ajoute une référence par un clic droit sur Référence dans l'Explorateur de solution (Ajouter référence) et en la choississant dans la liste des Assemblys. Par exemple pour compiler l'application Invoke2 récupérée sur Codes-Source, les ajouts suivants (à partir de zéro) ont suffit :

System, System.ComponentModel.Composition, System.Data, System.Drawing et System.Windows.forms.

• •Créer un projet/Projet vide (.Net Framework) 

• •Projet/Ajouter nouvel élément/Fichier de code (puis le renommer à sa guise) 

Le code minimal suivant fonctionne :

using System;

using System.Windows.Forms;

namespace WindowsFormsApp1

{

    static class Program

    {

        [STAThread]

        static void Main() { Application.Run(new Form1()); }

    }

    public class Form1 : Form

    {

        private Label label1;

        public Form1()

        {

            label1 = new Label();

            label1.Text = "Bonjour Michel !";

            SuspendLayout();

            Controls.Add(label1);

            ResumeLayout(false);

        }

    }

}

Mais il faut ajouter les références aux assemblys System et System.Windows.Forms.

Voir documentation ICI : https://learn.microsoft.com/en-us/troubleshoot/developer/visualstudio/csharp/language-compilers/add-controls-to-windows-forms

Remarque :

Dans void Main() l'instruction Application.Run(new Form1()); lance la boucle d'attente des événements qui du temps de win32 s'crivait comme suit :

 while (GetMessage (&msg, NULL, 0, 0))

 {

   TranslateMessage (&msg) ;  

   DispatchMessage (&msg) ;

 }

Doc ici : https://bpesquet.developpez.com/tutoriels/csharp/programmation-evenementielle-winforms/

Pour créer Hello world en windowds Form : choisir Créer un nouveau projet c#, windows Form pour .NET (ou plutôt pout .Net Framework ?)

Trois fichiers .cs sont créés : Program.cs et Form1.cs que l'on peut modifier, et Form1.Designer.cs qui est modifié par Visual Studio, qui gère également un fichier Form1.resx et divers autres fichiers projets.

VS s'ouvre avec la fenêtre en question ouverte dans le panneau d'édition, sous forme graphique (concepteur), avec son nom, a priori Form1.cs en onglet. On commute avec sa forme textuelle (code) en donnant le focus à cette partie édition, puis par le menu affichage/code (F7) et on retourne à la forme graphique par affichage/concepteur (Maj+F7). Attention ces lignes de menu ne sont présentes que si la fenêtre d'édition à le focus.

Contenu de Program.cs :

using System;

using System.Windows.Forms;

namespace WindowsFormsApp1

{

    static class Program

    {

        [STAThread]

        static void Main()

        {

            Application.EnableVisualStyles();

            Application.SetCompatibleTextRenderingDefault(false);

            Application.Run(new Form1());

        }

    }

}

Deux appels de méthodes pour assurer des compatibilités (éventuellement non nécessaires), suivis  de Application.Run(new Form1()); qui crée notre classe Form1 et qui la lance.

Le code du fichier  Form1.cs qui déclare cette classe est le suivant :

using System.Windows.Forms;

namespace WindowsFormsApp1

{

    public partial class Form1 : Form

    {

        public Form1()

        {

            InitializeComponent();

        }

    }

}

Le constructeur ne fait qu'appeler a méthode InitializeComponent() qui est déclarée dans le fichier auto-généré Form1.Designer.cs :

namespace WindowsFormsApp1

{

    partial class Form1

    {

        private System.ComponentModel.IContainer components = null;

        protected override void Dispose(bool disposing)

        {

            if (disposing && (components != null)) components.Dispose();          

            base.Dispose(disposing);

        }

        private void InitializeComponent()

        {

            this.components = new System.ComponentModel.Container();

            this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;

            this.ClientSize = new System.Drawing.Size(800, 450);

            this.Text = "Form1";

        }

    }

}

Ici, les trois fichiers appartiennent au même namespace qui a pour nom celui de l'application, a priori.

Le main est dans la static class Program. Il lance la boucle de gestion des évènements en appelant Application.Run() avec comme argument notre windowsForm Form1.

Le code de la Form1 est divisé est deux : une partie gérée par Visual Studio se trouve dans le fichier Form1.Designer.cs sous la rubrique partial class Form1 { ...} et l'autre partie que l'on gère, se trouve dans le fichier Form1.cs sous la rubrique public partial class Form1 : Form {...}.

Au niveau de la windowsForm, en mode designer, on peut faire glisser des widgets qui se trouvent dans la Boite à outils  (Affichage/Boite à outils ou CTRL+ALT+X si on ne la voit pas) sur la forme.

La fenêtre Propriétés permet de gérer ce widget. Cette fenêtre présentent 2 onglets qui organisent ces propriétés diversement :

• •Propriétés (clé plate) : présentation des propriétés 

• •Événements  (éclair zigzag) : présentation des évèment associables 

De plus 2 onglets permettent de les classer différemment :

• •Catégories : organisation en catégories 

• •Alphabétique : organisation alphabétique 

On change le nom d'un widget par sa propriété  (name) qui apparait en début de liste en mode priétés&alphabétique

Dans Qt, on change le texte d'unt Label par label.setText("bonjour"). Dans c# c'est tout simplement label.Text = "bonjour".

Les widgets héritent pratiquement tous de la classe Control qui leur fournit énormément de propriétés et de méthodes communes et ils héritent aussi d'une autre classe de base relative à leur usage général. Les proprités suivantes sont essentiellement héritées de la classe Control, d'où l'appellation courante de controle pour un widget.

Depuis une Form classique on peut créer une nouvelle Form entièrement gérée en code. Exemple :

using System;

using System.Windows.Forms;

namespace Bidon

{

    public partial class Form1 : Form // Classe gérée par Form1.Designer.cs

    {

        public Form1() {InitializeComponent();}

        private void button1_Click(object sender, EventArgs e)

        { new MaWin("Une autre fenêtre").ShowDialog();}

    }

    public class MaWin : Form // Classe isolée et complète ici

    {

        public MaWin(string titre)

        {

            Button bouton = new Button();

            bouton.Text = "Créer une nouvelle fenêtre";

            bouton.Size = new System.Drawing.Size(208, 23);

            bouton.Click += new System.EventHandler(this.bouton_Click);

            this.SuspendLayout();

            this.Text = titre;

            this.Controls.Add(bouton);

            this.ResumeLayout(false);

        }

        private void bouton_Click(object sender, EventArgs e)

        { MessageBox.Show("Clic sur autre fenêtre"); }

    }

}

(Name) : le nom donné à ce widget dans le code.

Dock : Pour spécifier un positionnement qui occupe tout un bord du conteneur. Dock peut valoir DockStyle.Left | Top | Right | Bottom : Le widget est collé à ras sur le bord en question de son conteneur et occupe toute la longueur de ce bord, ou Fill : le widget rempli son conteneur, ou None : le widget n'occupe pas tout un bord du conteneur.

Anchor : Permet de préciser le positionnement dans le conteneur (si Dock.None) ou le compléter en précisant de quel bord préserver la distance lors du redimensionnement : AnchorStyle.None ou < <Top | Bottom> , <Left | Right>. Après un redimensionnement, None => centré,  sinon, la distance au bord du conteneur indiqué par la/les propriété(s) sera conservée.

Enabled : indique si le contrôle est actif ou non ;

Text : le texte affiché par le contrôle ;

Visible : indique si le contrôle est visible ou non.

Tag : propriété de type objet qui permet de mémoriser une propriété ou méthode qcq, à toutes fins utiles, par exemple l'objet qui doit être activé quand un checkbox est coché.

Si on a mis un bouton dans le designer, en double-cliquant dessus, cela ajoute la callback suivante dans le code :

        private void button1_Click(object sender, EventArgs e) { }

qu'il n'y a plus qu'à remplir entre les accolades.

Un double-clic sur un textbox produit les ajouts suivants :

       this.textBox1.TextChanged += new System.EventHandler(this.textBox1_TextChanged);    

dans la zone d'initialisation et :

           private void textBox1_TextChanged(object sender, EventArgs e) { }

dans les méthodes. Mais comme l' EventArgs e n'e pas de membres accessibles, si on veut tester les caractères entrés, on remplacera ces fonctions par :

            this.textBox1.KeyPress += new System.Windows.Forms.KeyPressEventHandler(keypressed);

dans la zone d'initialisation et :

        private void keypressed(Object o, KeyPressEventArgs e)

        {if (e.KeyChar == (char)Keys.Return) blabla();}

dans les méthodes.

Remarque. Il est aussi simple d'ajouter soi-même, les liaisons aux callbacks dans le constructeur de la Form1, après le InitializeComponent(); par les instructions :

       button1.Click += new EventHandler(this.button1_Click);

       textBox1.KeyPress += new KeyPressEventHandler(keypressed);

De plus on peut encore simplifier et écrire directement :

       button1.Click += button1_Click;

       textBox1.KeyPress += keypressed;

Load : événement émis au chargement de le Form

Shown : événement émis lors du premier affichage de la Form

FormClosing : évènement émis lors de la  demande de fermeture

FormClosed :évènement émis lors de la  fermeture

Paint : Lorsque le widget doit être redessiné

Layout : Lors de l'ajout ou suppression de widgets enfants

Resize : Lorsque le conteneur du widget a été redimensionné

Click : Lorsque le widget a été cliqué

DoubleClick

MouseClick

MouseDoubleClick

MouseDown

PreviewMouseDown

MouseEnter

MouseHover

MouseLeave

MouseMove

MouseUp

MouseWheel

Click

KeyDown

KeyPress (déprécié ?)

KeyUp

PreviewKeyDown

PreviewKeyUp

Click : se produit lorsque le contrôle est cliqué par la souris.
MouseDown : se produit lorsqu'un bouton de la souris est enfoncé alors que  lorsque le pointeur de la souris se trouve sur un contrôle,

PreviewMouseDown : se produit lorsque n'importe quel bouton de la souris est enfoncé relativement à l'élément surveillé.

Preview existe pour preque tous les événements et se produit avant son homologue.

Pour ajouter une méthode de gestion de l'évènement de fermeture de la fénêtre, le plus simple est de passer par le designer de la Forme, dans la fenêtre droite des propriétés, sélectionner l'onglet éclair (zigzag) et faire un double clic sur FormClosing dans la rubrique Comportement. Cela ajoute la méthode suivante :
       private void Form1_FormClosing(object sender, FormClosingEventArgs e)

        {

        }

qu'il n'y a qu'à remplir. Par exemple pour éventuellemnt empêcher la fermeture :
       private void Form1_FormClosing(object sender, FormClosingEventArgs e)

        {

            var res = MessageBox.Show(this, "Etes-vous sûr de vouloir quitter?",

                        "Exit", MessageBoxButtons.YesNo, MessageBoxIcon.Warning,                                  MessageBoxDefaultButton.Button2);

            if (res != DialogResult.Yes)

            {

                e.Cancel = true;

                return;

            }

        }

Remarque : la ligne suivante :
           this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.Form1_FormClosing);
a été ajoutée dans la méthode InitializeComponent() située dans le fichier Form1.Designer.cs.

On peut effectuer tout cela manuellement, en ajoutant nous-même une ligne équivalente dans le constructeur de la Form1 après l'appel de la méthode et ensuite en ajoutant la méthode.

Exemple :

Après l'appel d' mettre :

        this.FormClosing += this.MaFermeture;

ou bien

        this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MaFermeture);

et ensuite on instancie la méthode :

        private void MaFermeture(object sender, FormClosingEventArgs e)

        {

        }

Les Formulaires Form peuvent être modal (bloquante) ou non modal (exécution en //).

C'est une sous-forme ordinaire qui, après avoir été instanciée, est affichée en appelant sa méthode Show(). Elle a sa vie indépendante à coté des autres formes de l'application.

Une sous forme modale est affichée par l'appel de la méthode ShowDialog().

Une sous-forme modale bloque le reste de l'application tant qu'elle est affichée : exemple boite de dialogue.

Elle renvoie un résultat de type DialogResult.

SubForm subForm = new SubForm();

if (subForm.ShowDialog() == DialogResult.OK)

{

    // ...

}

Cela suppose qu'on ait mis au moins un bouton avec sa propriété DialogResult mise sur OK.

C# n'offre pas l'équivalent de la fonction InputBox de visual Basic, qui est bien pratique. Voici une méthode qui crée une forme modale qui offre ce service :

    class InputBox

    {

        public static DialogResult getStr(ref string strin, string titre = "")

        {

            int w = 400, h = 70;

            // On crée la forme contenante

            Form forme = new Form();

            forme.FormBorderStyle = FormBorderStyle.FixedDialog;

            forme.ClientSize = new Size(w, h);

            forme.Text = titre;

            // Le TextBox d'écriture pour l'usager

            TextBox textBox = new TextBox();

            textBox.Size = new Size(w - 10, 23);

            textBox.Location = new Point(5, 5);

            textBox.Text = strin;

            forme.Controls.Add(textBox);

            // Le Bouton Ok

            Button okButton = new Button();

            okButton.DialogResult = DialogResult.OK;

            okButton.Name = "okButton";

            okButton.Size = new Size(75, 23);

            okButton.Text = "&OK";

            okButton.Location = new Point(w - 80 - 80, 39);

            forme.Controls.Add(okButton);

            forme.AcceptButton = okButton; // Le Return produit Ok

            // Affiche le widget sous forme de boite de dialogue modale

            DialogResult result = forme.ShowDialog();

            strin = textBox.Text;

            return result; // cad  DialogResult.OK|.Yes|.No|.Cancel|...

        }

    }

On l'appellera comme ceci :

            string entree = "";

            // On lit le string entree avec l'InputBox

            DialogResult rd = InputBox.getStr(ref entree, "Titre de la question");

            if (rd != DialogResult.OK && rd != DialogResult.Yes) return;

            // On affiche le résultat dans un label

            this.label1.Text = entree;

On peut également déclarer la fonction getStr ailleurs , dans notre classe Form1 par exemple (avec un autre nom éventuellement) et l'appeler comme une méthode de notre forme.

On peut ajouter un bouton Cancel, mais la croix de fermeture joue déjà ce rôle.

Un widget approprié pour afficher des graphiques ou des images isus d'un fichier bitmap, icône, jpg, gif, png est une PictureBox.

Exemple de code affectant une image à une PictureBox à partir d'un fichier :

        private Bitmap MyImage;

        public void ShowMyImage(String fileToDisplay, int xSize, int ySize)

        {

            // Sets up an image object to be displayed.

            if (MyImage != null)

            {

                MyImage.Dispose();

            }

            // Stretches the image to fit the pictureBox.

            pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;

            MyImage = new Bitmap(fileToDisplay);

            pictureBox1.ClientSize = new Size(xSize, ySize);

            pictureBox1.Image = (Image)MyImage;

        }

Alpha (262144) : valeurs alpha non prémultipliées.

Canonical (2097152) 32 bits : couleur 24 bits et canal alpha 8 bits.

DontCare (0) non spécifié

Extended (1048576) Réservé.

Format16bppArgb1555 (397319) 16 bits (5R, 5V, 5B et 1 alpha)

Format16bppGrayScale (1052676) 16 bits

Format16bppRgb555 (135173) 16 bits ( 5R, 5V, 5B et 1 inutilisé).

Format16bppRgb565 (135174) 16 bits (5R, 6V, 5B)

Format1bppIndexed (196865) 1 bit + table des couleurs de 2 couleurs.

Format24bppRgb (137224) 24 bits (8R, 8V, 8B)

Format32bppArgb (2498570) 32 bits (8R, 8V, 8B, 8a)

Format32bppPArgb (925707) 32 bits (8R, 8V, 8B, 8a) RVB prémultipliés par a.

Format32bppRgb (139273) 32 bits (8R, 8V, 8B, 8inutilisés)

Format48bppRgb (1060876) 48 bit (16R,16V, 16B).

Format4bppIndexed (197634) 4 bits indexés.

Format64bppArgb (3424269) 64 bits (16a,16R,16V, 16B)

Format64bppPArgb (1851406) 64 bits (16a,16R,16V, 16B) RVB prémultiplié par a.

Format8bppIndexed (198659) 8 bits indexés dans table de 256 couleurs.

Gdi (131072) couleurs GDI indexées ?

Indexed (65536) ? indexées dans table ?

Max (15) Valeur maximale (?)

PAlpha (524288) alpha prémultipliées (?)

Undefined (0) non défini

On peut dessiner dans une PictureBox pBox que l'on met dans une Form. Il suffit d'appeler pbox.Invalidate() pour déclencher son dessin. Au préalable il faut écrire la callback de dessin comme une méthode de la classe de la Form, par exemple :
       private void pBox_Paint(object sender, PaintEventArgs e)

        {

            Graphics g = e.Graphics;

            int red = 100;

            int white = red + 11;

            Brush b = isRed ? Brushes.Red : Brushes.Green;

            while (white <= 200)

            {

                g.FillRectangle(b, 50, red, 200, 10);

                g.FillRectangle(Brushes.White, 50, white, 200, 10);

                red += 20;

                white += 20;

            }

        }

que l'on enregistrera dans le constructeur de la classe par l'instruction :
           this.pBox.Paint += new System.Windows.Forms.PaintEventHandler (this.pBox_Paint);

Cet enregistrement peut être fait automatiquement par un double clic sur  la propriété Paint qui figure dans la liste des propriétés de la PictureBox : Vue Design, Onglet Propitété, Liste Evènements (icône éclair). Ce double clic génère aussi ke squelette vide de la callback.

The Pen class specifies a number of settings for lines, curves, and outlines: