using System;

​

// Définition du type Personne (avec une classe au lieu d'une structure)

class Personne

{

    #region Attributs

    // Un attribut marqué avec "static" est lié à la classe toute entière (et non pas à une variable en particulier de type "Personne")

    public static int nombreDePersonnesCrees = 0;

    // Un attribut "const" ou "readonly" est une variable particulière liée à la classe (comme avec "static")

    // Il s'agit d'une constante (variable dont la valeur ne peut pas être modifiée, par exemple "PI" dans une classe mathématique)

    // L'attribut constant est souvent ajouté pour être utilisé dans des méthodes de la classe

    private readonly string[] prenomsDePersonnes = {"Charles", "Juliette", "Antoine", "Guillaume", "Marie"};

    private readonly string[] nomsDePersonnes = {"Martin", "De Gaulle", "Hollande", "Proust", "Foffana"};

    // Les attributs des variables de type "Personne"

    // Dans une classe (contrairement aux structures), on met souvent les attributs en "private"

    private string prenom;

    private string nom;

    private int age;

    // Il est courant (dans la plupart des langages) de créer des méthodes "public" pour récupérer ou modifier la valeur des attributs private hors de la classe (depuis "Main" par exemple)

    // On parle de "setter" (méthode pour modifier la variable) et de "getter" (pour la récupérer)

    // On peut y ajouter des tests comme pour une méthode classique (notamment pour les setters, voir le setter de "age")

    // L'une des raisons d'utiliser ces getters et setters (au lieu de simplement mettre les attributs en "public") est de permettre une évolution plus simple du code 

    //     (par exemple en émettant une erreur si on essaye de spécifier un age négatif pour la personne)

    public string GetPrenom() {return prenom;}

    public string GetNom() {return nom;}

    public int GetAge() {return age;}

    public void SetPrenom(string prenom) {this.prenom = prenom;}

    public void SetNom(string nom) {this.nom = nom;}

    public void SetAge(int age) {

        if(age >= 0)   // evite de modifier l'age si l'age fourni est négatif

        {

            this.age = age;

        }

        // Si on souhaite lever une exception quand age est négatif, on peut utiliser cette ligne de code:

        // else throw new Exception("L'âge spécifié doit être positif");

    }

    // A l'attention des curieux uniquement

    // Avec C#, il est possible d'utiliser les "propriétés" pour définir des getters et setters des variables de manière un peu plus concise

    /*

    public string Prenom {get {return prenom;} set{prenom = value;} }

    public string Nom {get {return nom;} set{nom = value;} }

    public int Age {get {return age;} set{if(value >= 0) age = value;} }

    public int MaPropriete {get; set; }  // Propriété non liée à un attribut "private", avec des "getter" et "setter" simplistes créés automatiquement par C#

    */

    #endregion

    #region Constructeur et destructeur

    // Un constructeur est appelé lorsque l'on créée une variable de type Personne avec "new"

    // Il est possible de passer des paramètres au constructeur (comme pour une fonction classique)

    // Le rôle principal du constructeur est d'affecter une valeur initiale aux attributs de l'objet

    // Constructeur avec paramètres spécifiés lors de la création avec "new"

    // Pour cet exemple, le constructeur permet de créer une personne avec les paramètres fournis

    public Personne(string prenom, string nom, int age)

    {

        nombreDePersonnesCrees += 1;  // mise à jour de l'attribut static, concernant la classe entière

        this.prenom = prenom;

        this.nom = nom;

        this.age = age;

    }   

    // Constructeur sans paramètre (souvent appelé "constructeur par défaut")

    // Pour cet exemple, le constructeur permet de créer une personne avec des attributs aléatoires

    public Personne()

    {

        nombreDePersonnesCrees += 1;  // mise à jour de l'attribut static, concernant la classe entière

        // L'objet "Random" permet de récupérer des nombres aléatoires, qui vont nous permettre de sélectionner

        //    des noms et prenoms aléatoires dans les listes constantes définies plus haut

        Random random = new Random();

        int randomPrenomIndex = random.Next(prenomsDePersonnes.Length);

        int randomNomIndex = random.Next(nomsDePersonnes.Length);

        this.prenom = prenomsDePersonnes[randomPrenomIndex];

        this.nom = nomsDePersonnes[randomNomIndex];

        this.age = random.Next(100);   // age aléatoire entre 0 et 99 ans

    }

    // A l'attention des curieux uniquement

    // Les langages évolués comme C# ou Java utilisent un "Garbage collector", qui peut supprimer automatiquement de la mémoire de l'ordinateur les variables qui ne sont plus utilisées

    // Le "destructeur" est appelé juste avant la suppression de la variable en question

    // Les destructeurs sont peu utilisés en C# et en Java, mais sont essentiels dans des langages comme C++ (où la gestion de la mémoire n'est pas automatique)

    ~Personne()

    {

        Console.WriteLine("La personne suivante a été supprimée de la mémoire:");

        FonctionAffichage();

    }

    #endregion

    #region Methodes

    // Les méthodes static sont liées à la classe toute entière, et non pas à une seule variable de type Personne

    public static void FonctionAffichagePersonnesCrees(){

        Console.WriteLine("Nombre de personnes ayant été créées: " + nombreDePersonnesCrees);

    }

    // Pas de différence majeure entre les méthodes de structure et de classe

    public void FonctionAffichage(){      // les fonctions contenues dans un type sont appelées "méthodes"

        Console.WriteLine(prenom + " " + nom + " " + age);   // Une méthode peut accéder aux attributs de l'objet

    }

    public void FonctionMajorite(){

        bool majeur = age > 18;

        if(majeur) Console.WriteLine("Personne majeure");

        else Console.WriteLine("Personne mineure");

    }

    private void FonctionPrivee(){

        Console.WriteLine("Je suis private, seules les méthodes FonctionAffichage et FonctionMajorite pourraient m'appeler");

        Console.WriteLine("je ne suis accessible que dans les fonctions contenues dans le type Personne");

    }

    #endregion

}

​

​

// En C# et en Java, tout le code doit être situé dans une classe ou une structure

// Ici, "Program" est la classe principale du programme

public class Program

{

    // La méthode static "Main" est appelée au lancement du programme

    // Elle est static, car liée à aucune variable en particulier

    public static void Main()

    {

        // Creation de personnes: deux utilisant le constructeur avec paramètres, et une utilisant le constructeur par défaut (aléatoire dans le cas présent)

        Personne[] personnes = {

            new Personne("Sylvie", "Bouchard", 14),     // Création d'une variable du type "Personne" dans le tableau (on le voit à l'utilisation du mot-clé "new")

            new Personne("Jean", "Martin", 25),

            new Personne()

        };

        // On appelle les méthodes de la même manière qu'avec les structures

        int indexPersonne = int.Parse(Console.ReadLine());     // Vous devez entrer dans la console l'index de la personne à afficher (0, 1 ou 2)

        personnes[indexPersonne].FonctionAffichage();          // La syntaxe "objet.fonction(paramètres)" permet d'appeler une fonction associée à un type sur un objet de ce type

        personnes[indexPersonne].FonctionMajorite();

        // "FonctionPrivee" ne peut pas être appelée ici, car elle est définie avec "private"

        // Appel d'attribut ou de méthode "static" (on les utilise avec le nom de la classe, ici "Personne")

        Console.WriteLine(Personne.nombreDePersonnesCrees);

        Personne.FonctionAffichagePersonnesCrees();

        // On utilise le getter et le setter comme une méthode classique

        personnes[indexPersonne].SetPrenom("Jean-Claude");

        personnes[indexPersonne].SetAge(-2);   // Modification non effectuées à cause du "if" dans le setter de age

        Console.WriteLine(personnes[indexPersonne].GetPrenom());

        Console.WriteLine(personnes[indexPersonne].GetAge());

    }

}