Voici une liste des différents codes source et syntaxes courante utilisées 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:

• openclassrooms: Apprenez à programmer en C#

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

• 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

• 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