Memento C#

 0
 0
Tps de lecture estimé:6 minutes 0 secondes

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.
Les exemples de code sont principalement issue du site openclassrooms

Csharp


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(); 

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

Article précédent Article suivant