
Memento CSharp
Voici une liste des différents codes source et syntaxes courantes utilisés en C#.
Ce fichier est un canevas qui s'étoffera au fur et à mesure de mes expérimentations sur ce moteur de jeu.
Références/Sources:
Syntaxe de Base
-
exemple d'utilisation de la console
using System; namespace MyFirstApp { class Program { static void Main(string[] args) { Console.WriteLine("Hello world"); // S'il n'y a pas de 1er argument, on crée une chaîne vide : string.Empty (ou encore ""). string arg1 = (args.Length <= 0) ? string.Empty : args[0]; // Idem pour le 2e string arg2 = (args.Length <= 1) ? string.Empty : args[1]; // On affiche le 1er argument Console.WriteLine("argument n°1 : {0}", arg1); // Idem pour le 2e Console.WriteLine("argument n°2 : {0}", arg2); // On lit la ligne (la console attend un retour à la ligne avant de mémoriser ce que vous écrivez). string input = Console.ReadLine(); // On affiche ce qu'on a écrit. Console.WriteLine("Vous avez écrit : \"{0}\"", input); } } }
-
les évaluations des opérateurs && et || sont dites paresseuses car elles se font de gauche à droite et elles s'arrêtent dès que le résultat de l'expression entière est connu.
-
& et | sont la version "non paresseuse" de && et ||
-
exemple d'utilisation des Random
System.Random rand = new System.Random(); //retourne un entier appartenant à [minValue; maxValue[ (maxValue est une borne exclue). var value = rand.Next(minValue, maxValue);
Les variables et les types simples
- liste exhaustive des types
Type C# | Type .NET | Signification | Taille en mémoire (en octets) | Domaine de valeurs |
---|---|---|---|---|
char | Char | character (caractère) | 2 | caractère Unicode (UTF-16) allant de U+0000 à U+ffff |
string | String | chaîne de caractères | variable | référence sur une séquence de caractères Unicode |
int | Int32 | integer (nombre entier) | 4 | [-231; 231-1] |
uint | UInt32 | unsigned integer (nombre entier non signé) | 4 | [0; 232-1] |
long | Int64 | nombre entier long | 8 | [-263; 263-1] |
ulong | UInt64 | unsigned long (nombre entier long non signé) | 8 | [0; 264-1] |
sbyte | SByte | signed byte (octet signé) | 1 | [-27; 27-1] |
byte | Byte | octet | 1 | [0; 28-1] |
short | Int16 | nombre entier court | 2 | [-215; 215-1] |
ushort | UInt16 | unsigned short (nombre entier court non signé) | 2 | [0; 216-1] |
float | Single | flottant (nombre réel) | 4 | ±1,510-45 à ±3,410+38 (7 chiffres de précision) |
double | Double | double flottant (nombre réel) | 8 | ±5,010-324 à ±1,710+308 (15 à 16 chiffres de précision) |
decimal | Decimal | nombre décimal | 16 | ±1,010-28 à ±7,91028 (28 à 29 chiffres significatifs) |
bool | Boolean | booléen | 1 | true / false |
object | Object | référence d'objet | variable | référence d'objet |
-
exemple
enum Weather {Unknown, Sunny, Cloudy, Rainy } int i = 10; string s = "Hello world!"; char c = 'a'; Console.WriteLine("i est de type " + typeof(int) + " et occupe " + sizeof(int) + " octet(s) en mémoire."); Weather todaysWeather = Weather.Sunny;
Les conditions et les boucles
-
exemples
if (age < 4) { // gratuit } else if (age < 12) { // Tarif enfant } else { // Tarif adulte } switch (level) { case 1: // niveau 1 break; case 2: // niveau 2 break; default: // autre niveau break; } while (condition) { if (needToExit) { break; } // Code à exécuter en boucle } do { // Code qui s'exécute une 1ère fois obligatoirement et ensuite en boucle tant que la condition est satisfaite. } while (condition); for (int i = 1; i <= 10; i++) { if (i < 9) { continue; } // La ligne suivante n'est pas exécutée si i est strictement inférieur à 9. Console.WriteLine(i); }
Les méthodes
- Par défaut, les paramètres des méthodes sont toujours passés par valeur.
- Pour forcer le passage par référence, utilisez le mot-clef ref.
- L'utilisation de out impose à la méthode d'assigner une valeur au paramètre avant de se terminer.
-
exemple
int myInt; bool success = int.TryParse("1234", out myInt); if(success) { Console.WriteLine("La conversion a réussi, le double du nombre est : " + myInt * 2 + "."); } else { Console.WriteLine("La conversion a échoué."); }
Les types complexes
Les tableaux
-
tableau simples
int[] myArray = new int[4]; int[] myArray = new int[] {10, 20, 30, 40}; int[] myArray = {10, 20, 30, 40}; double[,] myArray = new double[,] { {0.1, 0.5}, {1.3, 1.7} };
-
tableau de tableau
int[][] myIntArray = new int[2][]; myIntArray[0] = new int[5]; myIntArray[0][1] = 42; string[] firstnameArray = {"Matt", "Tim", "James"}; string[] surnameArray = {"Johnson", "Smith"}; string[][] myArray = {firstnameArray, surnameArray };
les chaînes de caractères
-
concaténation
string firstString = "Hello"; string secondString = "World!"; string fullString = firstString + " " + secondString; string fullString = string.Concat(firstString ,secondString);
-
exemple de chaînes de formatage
Console.WriteLine("5 + 6 = {0}", 5+6); string s = String.Format("{{0}} est remplacé par {0} et {{1}} par {1}", "paramètre2", "paramètre3");
-
champs possibles dans les chaînes de formatage
Description | Exemples | Sortie (en-US) | Sortie (fr-FR) |
---|---|---|---|
Devise | string.Format("{0:C}", 2.5); |
$2.50 | 2,50 € |
Devise | string.Format("{0:C}", -2.5); |
($2.50) | -2.50 € |
Décimal | string.Format("{0:D5}", 25); |
00025 | 00025 |
Scientifique | string.Format("{0:E}", 250000); |
2.500000E+005 | 2,500000E+005 |
Virgule fixe | string.Format("{0:F2}", 25); |
25.00 | 25,00 |
Virgule fixe | string.Format("{0:F0}", 25); |
25 | 25 |
Général | string.Format("{0:G}", 2.5); |
2.5 | 2,5 |
Nombre | string.Format("{0:N}", 2500000); |
2,500,000.00 | 2 500 000,00 |
Hexadécimal | string.Format("{0:X}", 250); |
FFFF | FA |
Hexadécimal | string.Format("{0:X}", 0xffff); |
FFFF |
-
La classe StringBuilder permet d'optimiser la mémoire, mais seulement si vous faites des concaténations dans des boucles
StringBuilder sb = new StringBuilder(); for (int i = 0; i < 1000; i++) sb.AppendLine(name); string fullString = sb.ToString();
Les Listes
-
Permet de stocker un ensemble de valeurs dont on ne connaît pas le nombre, puis d'en ajouter, d'en insérer.
// Déclarer, instancier et initialiser une liste d'entiers List<int> listeChiffres; listeChiffres = new List<int>() { 1, 3, 6, 2, 88, 34, 2 }; // Connaître le nombre d'éléments d'une liste Console.WriteLine("Nombre d'éléments : " + listeChiffres.Count); // AJouter un élément à la liste, à la fin listeChiffres.Add(22); Console.WriteLine("Nombre d'éléments : " + listeChiffres.Count); // Insérer un élément (100) à liste, à une position donnée (1) listeChiffres.Insert(1, 100); Console.WriteLine("Nombre d'éléments : " + listeChiffres.Count); // Boucle foreach pour parcourir une liste foreach (int chiffre in listeChiffres) { Console.WriteLine(chiffre); } // Tester l'existence d'une valeur dans la liste if (listeChiffres.Contains(100)) { Console.WriteLine("Contient bien 100 !"); } // Inverser une liste listeChiffres.Reverse(); foreach (int chiffre in listeChiffres) { Console.WriteLine(chiffre); } // Vider une liste listeChiffres.Clear();
La POO
Les classes
-
exemple
public class Person { // propriétés auto-implémentés (avec accesseurs sans backing field) public string Name {get;private set;} // propriétés avec accesseurs et backing field private ushort m_age; public ushort Age { get { return m_age; } set { m_age = value; } } // Constructeur public Person() { Console.WriteLine("Nouvelle personne créée."); } // Constructeur public Person(string name, ushort age) { this.m_age = age; this.m_name = name; Console.WriteLine("Nouvelle personne créée. Cette personne s'appelle " + name + " et a " + age + " an(s)."); } // Destructeur ~Person() { Console.WriteLine("Objet détruit."); } // Méthode public void SayHi() { Console.WriteLine("Bonjour ! Je m'appelle " + this.m_name + " et j'ai " + this.m_age + " ans."); } }
Les objets
-
exemple
Person toto = new Person("Toto", 10); toto.SayHi(); Person p1 = new Person("Toto", 10); Person p2 = new Person("Toto", 10); Person p3 = p1; Console.WriteLine(p1.Age); Console.WriteLine(p2.Age); Console.WriteLine(p1 == p2 ? "p1 est égal à p2." : "p1 n'est pas égal à p2."); Console.WriteLine(p1 == p3 ? "p1 est égal à p3." : "p1 n'est pas égal à p3.");
-
Equals
- Pour comparer 2 objets, plutôt que d'utiliser l'opérateur ==, vous pouvez utiliser la méthode Equals (que possède tout objet). La seule différence est que == ne compare que des objets de même type, alors que Equals permet de comparer un objet d'un certain type avec un autre objet d'un autre type.
-
Membre "static"
- Le mot-clef static sert à faire que ce qui suit ne dépende pas d'une instance, mais dépende de la classe elle-même.
- Pour accéder à des champs statiques, il faut écrire : nomDeLaClasse.nomDuChamp