Quelques raccourcis :
Comme la plupart des langages OO, C# offre une multitude de mécanismes pour initialiser des objets ou des collections. Voici un bref survol de ce sujet toujours en mouvement.
Notez que les règles de C# en ce qui a trait à l'initialisation ne sont pas homogènes; il est utile de comprendre les différences et les nuances entre les diverses facettes de cette important aspect de la programmation pour tirer profit de ce langage.
Un volet de C# pour lequel l'initialisation implique des opérations un peu « magiques » est l'initialisation des « types valeurs » (les struct dans ce langage).
Bien que les « primitifs » de C# comme int, float ou bool soient des « types valeurs », et soient en fait des alias pour des noms du système de types commun de la plateforme .NET (p.ex. : System.Int32 pour int, System.Single pour float, etc.), ces types n'ont pas droit au même traitement que les struct que vous pourriez écrire vous-mêmes.
Par exemple :
int n0 = 3; // Ok, magique
Int32 n1 = 3; // Ok, magique
// int n3 = new int(3); // illégal
// Int32 n3 = new Int32(3); // illégal
Entier e0 = new (3); // Ok
struct Entier
{
public int Valeur { get; set; }
public Entier(int valeur)
{
Valeur = valeur;
}
}On ne peut pas, à ma connaissance, écrire nous-mêmes un type pour lequel l'initialisation des instances est aussi simple que pour les « primitifs » de C# dans ce langage.
C# ne permet pas d'exprimer une initialisation automatique des propriétés autogénérées pour un struct, celles-ci étant toujours initialisées au zéro du type (default). Par exemple :
using System;
Entier e = new (); // serait Ok si on enlève le "=0" de l'initialisation de Entier.Valeur
struct Entier
{
public int Valeur { get; set; } = 0; // illégal pour un struct
}Notez qu'en C#, le fait d'écrire new X(...) pour un type X donné, class ou struct, initialise la zone mémoire où ce X est placé avec des zéros avant de construire l'objet.
Les opérations d'initialisation faites avant (p.ex. : initialisation directe des propriétés et des attributs) et pendant la construction se font en plus de cette initialisation à zéro, ce qui rend chaque construction relativement coûteuse dans ce langage.
C# ne permet pas d'écrire un constructeur par défaut pour un struct. Ce constructeur existe implicitement et initialise les attributs et les propriétés d'instance à zéro (default).
Il est possible d'écrire un constructeur paramétrique pour un struct en C#. Par exemple :
Entier e0 = new Entier(3); // Ok
struct Entier
{
public int Valeur { get; set; }
public Entier(int valeur) // Ok
{
Valeur = valeur;
}
}Si un struct a des états mutables (attributs publics ou propriétés dont le mutateur est public), il est possible d'initialiser ces états par leur nom même en l'absence d'un constructeur explicite. Par exemple :
using System;
Point p0 = new Point { }; // 0,0
Point p1 = new Point(); // 0,0
Point p2 = new Point(2, 3); // 2,3 et passe par le constructeur paramétrique
Point p3 = new Point { X = 2, Y = 3 }; // 2,3 et n'appelle pas le constructeur paramétrique
Point p4 = new Point { Y = 3 }; // 0,3 et n'appelle pas le constructeur paramétrique
Console.WriteLine($"{p0} {p1} {p2} {p3} {p4}");
struct Point
{
public int X { get; set; }
public int Y { get; set; }
public Point(int x, int y)
{
X = x;
Y = y;
}
public override string ToString() => $"({X},{Y})";
}Ici, du fait que le type Point est un struct, il possède un constructeur par défaut implicite.
Il est possible de combiner divers mécanismes d'initialisation, par exemple :
using System;
Point p0 = new Point { }; // 0,0,0
Point p1 = new Point(); // 0,0,0
Point p2 = new Point(2, 3); // 2,3,0 et passe par le constructeur paramétrique
Point p3 = new Point { X = 2, Y = 3 }; // 2,3,0 et n'appelle pas le constructeur paramétrique
Point p4 = new Point { Y = 3 }; // 0,3,0 et n'appelle pas le constructeur paramétrique
Point p5 = new Point(2, 3){ Z = 1 }; // 2,3,1 et passe par le constructeur paramétrique
Console.WriteLine($"{p0} {p1} {p2} {p3} {p4} {p5}");
struct Point
{
public int X { get; set; }
public int Y { get; set; }
public int Z { get; set; }
public Point(int x, int y)
{
X = x;
Y = y;
Z = 0; // requis pour compiler
}
public override string ToString() => $"({X},{Y},{Z})";
}| Ceci... | ... équivaut à cela | |
|---|---|---|
Cette forme est en fait un raccourci syntaxique : |
|
|
Le code généré est le même si vous le regardez avec le décompilateur ILDASM : |
|
|
L'initialisation des « types références » (des class en C#) ressemble à celle des types valeurs, à ceci-près qu'elle permet aussi d'écrire un constructeur par défaut et d'initialiser automatiquement les propriétés autogénérées.
C# permet d'exprimer une initialisation automatique des propriétés autogénérées pour un class. Par exemple :
using System;
EntierNaturel e0 = new ();
EntierNaturel e1 = new (3);
Console.WriteLine($"{e0} {e1}"); // 1 3
class EntierNaturel
{
static int Valider(int valeur) => valeur > 0? valeur : throw new ArgumentException();
public int Valeur { get; private set; } = 1;
public EntierNaturel()
{
}
public EntierNaturel(int valeur)
{
Valeur = Valider(valeur);
}
public override string ToString() => $"{Valeur}";
}Notez que si vous souhaitez utiliser une propriété qui ne soit pas autogénérée, par exemple pour loger la validation dans son mutateur, vous pourrez initialiser l'attribut sous-jacent mais pas la propriété elle-meme :
using System;
EntierNaturel e0 = new ();
EntierNaturel e1 = new (3);
Console.WriteLine($"{e0} {e1}"); // 1 3
class EntierNaturel
{
static int Valider(int valeur) => valeur > 0? valeur : throw new ArgumentException();
private int valeur = 1; // Ok
public int Valeur { get => valeur; private set { valeur = Valider(value); } /* = 1; */ // initialisation illégale ici
public EntierNaturel()
{
}
public EntierNaturel(int valeur)
{
Valeur = valeur;
}
public override string ToString() => $"{Valeur}";
}Comme le montre l'exemple de la classe EntierNaturel ci-dessus, il est possible d'écrire un constructeur par défaut pour un class.
Comme le montre l'exemple de la classe EntierNaturel ci-dessus, il est possible d'écrire un constructeur paramétrique pour un class.
Si un class a des états mutables (attributs publics ou propriétés dont le mutateur est public), il est possible d'initialiser ces états par leur nom même en l'absence d'un constructeur explicite. Notez toutefois que la construction par défaut demeure nécessaire si au moins un constructeur autre que celui-ci existe. Par exemple :
using System;
Point p0 = new Point { }; // 0,0
Point p1 = new Point(); // 0,0
Point p2 = new Point(2, 3); // 2,3 et passe par le constructeur paramétrique
Point p3 = new Point { X = 2, Y = 3 }; // 2,3 et n'appelle pas le constructeur paramétrique
Point p4 = new Point { Y = 3 }; // 0,3 et n'appelle pas le constructeur paramétrique
Console.WriteLine($"{p0} {p1} {p2} {p3} {p4}");
class Point
{
public int X { get; set; } = 0;
public int Y { get; set; } = 0;
public Point() // nécessaire ici car pour un class, n'existe pas si on
{ // écrit explicitement un autre constructeur
}
public Point(int x, int y)
{
X = x;
Y = y;
}
public override string ToString() => $"({X},{Y})";
}Il est possible de combiner divers mécanismes d'initialisation, par exemple :
using System;
Point p0 = new Point { }; // 0,0,0
Point p1 = new Point(); // 0,0,0
Point p2 = new Point(2, 3); // 2,3,0 et passe par le constructeur paramétrique
Point p3 = new Point { X = 2, Y = 3 }; // 2,3,0 et n'appelle pas le constructeur paramétrique
Point p4 = new Point { Y = 3 }; // 0,3,0 et n'appelle pas le constructeur paramétrique
Point p5 = new Point(2, 3){ Z = 1 }; // 2,3,1 et passe par le constructeur paramétrique
Console.WriteLine($"{p0} {p1} {p2} {p3} {p4} {p5}");
class Point
{
public int X { get; set; } = 0;
public int Y { get; set; } = 0;
public int Z { get; set; } = 0;
public Point() // nécessaire pour l'exemple
{
}
public Point(int x, int y)
{
X = x;
Y = y;
} // Z implicitement zéro
public override string ToString() => $"({X},{Y},{Z})";
}
| Ceci... | ... équivaut à cela | |
|---|---|---|
Cette forme est en fait un raccourci syntaxique : |
|
|
Le code généré est presque le même si vous le regardez avec le décompilateur ILDASM : |
|
|
C# permet de synthétiser des instances de types anonymes avec des propriétés nommées, ce qui est particulièrement utile pour des mécanismes comme LiNQ (il s'agit d'ailleurs bien de propriétés et non pas d'attributs; le code généré contient des set et des get). Par exemple
using System;
var x = new { X = 3, Y = 4 };
Console.WriteLine($"{x.X} {x.Y}"); // 3 4C# offre un support syntaxique spécial à l'initialisation pour les types munis d'indexeurs. Par exemple :
using System;
var ttt = new TicTacToe()
{
[0, 0] = TicTacToe.État.O,
[0, 1] = TicTacToe.État.X,
[1, 0] = TicTacToe.État.O,
[1, 2] = TicTacToe.État.X,
[2, 0] = TicTacToe.État.X,
[2, 1] = TicTacToe.État.X,
[2, 2] = TicTacToe.État.O
};
Console.WriteLine(ttt);
class TicTacToe
{
const int TAILLE = 3;
public enum État { Vide, X, O }
private État[,] Grille { get; } = new État[TAILLE, TAILLE]
{
{ État.Vide, État.Vide, État.Vide },
{ État.Vide, État.Vide, État.Vide },
{ État.Vide, État.Vide, État.Vide }
};
public État this[int ligne, int colonne]
{
get => Grille[ligne, colonne];
set
{
Grille[ligne, colonne] = value; // ajouter de la validation au goût
}
}
public TicTacToe()
{
}
// ...
public override string ToString()
{
string res = "";
for (int ligne = 0; ligne != TAILLE; ++ligne)
{
for (int colonne = 0; colonne != TAILLE; ++colonne)
switch (Grille[ligne, colonne])
{
case État.O: res += " O "; break;
case État.X: res += " X "; break;
case État.Vide: res += " "; break;
default: throw new Exception();
}
res += '\n';
}
return res;
}
}| Ceci... | ... équivaut à cela | |
|---|---|---|
Encore une fois, il s'agit d'un raccourci syntaxique : |
|
|
Le code généré est presque le même si vous le regardez avec le décompilateur ILDASM : |
|
|
Notez que nous pourrions utiliser des valeurs de types variés pour les indices comme pour les valeurs à utiliser pour fins d'initialisation si les indexeurs appropriés étaient définis :
var e = new Étrange
{
[3] = "bizarre",
["3",'3'] = 3.14159
};
class Étrange
{
public string this[int n] { get => ""; set { } }
public double this[string s,char c] { get => 0.0; set { } }
}En C#, si vous exprimez une collection comme étant IEnumerable et comme exposant une méthode Add (par voie de méthode d'extension ou en tant que méthode d'instance) de signature appropriée, il sera aussi possible d'exprimer l'initialisation de votre collection de manière raccourcie.
Notez que dans le code ci-dessous, IEnumerable est implémentée... de manière absolument non-pertinente, mais l'initialisation fonctionne, ce qui nous apprend que la contrainte de C# est incohérente. Cela dit, faut faire avec, c'est C#... :
using System;
using System.Collections;
using System.Collections.Generic;
var tapon = new Tapon<int>() { 2, 3, 5, 7, 11 };
Console.WriteLine(tapon);
// note : terriblement inefficace
class Tapon<T> : IEnumerable<T>
{
T[] Données { get; set; } = new T[0];
public Tapon()
{
}
public void Add(T elem)
{
var temp = new T[Données.Length + 1];
Array.Copy(Données, temp, Données.Length);
temp[Données.Length] = elem;
Données = temp;
}
public override string ToString()
{
string res = "";
if (Données.Length == 0) return res;
res += Données[0];
for (int i = 1; i < Données.Length; ++i)
res += $" {Données[i]}";
return res;
}
IEnumerator<T> IEnumerable<T>.GetEnumerator()
{
throw new NotImplementedException();
}
IEnumerator IEnumerable.GetEnumerator()
{
throw new NotImplementedException();
}
}Quelques liens pour enrichir le propos.
