[Programmation C#] Classes, constructeurs, membres statiques

un type

1. Le concept de classe

• Les classes sont des abstractions de concepts du monde réel : encapsulation, héritage, polymorphisme
• Membres de données : variables d'une classe qui stockent des données
• Méthodes membres : les fonctions d'une classe qui manipulent des données membres sont appelées méthodes membres.
• Objet : instance d'une classe
• définition de classe

class X {…}      

var instance = new X(…);

2. Champ d'instance

        En C#, les données membres sont appelées champs. Les champs liés à des objets spécifiques sont appelés champs d'instance ; les champs d'instance peuvent être initialisés lorsqu'ils sont déclarés, et l'instruction d'initialisation est exécutée avant le constructeur de classe, par exemple :

class Employee
{
    public string FirstName;
    public string LastName;
    public string Salary = "Not enough";
    public Employee() 
    { 
        Salray= string.Empty;
    } 
}

        Les champs d'instance ne sont accessibles qu'à partir de l'objet, par exemple :

public static void Main()
{
    Employee employee1 = new Employee();
    Employee employee2;
    employee2 = new Employee();
    employee1.FirstName = "Inigo";
    employee1.LastName = "Montoya";
    employee1.Salary = "Too Little";
    IncreaseSalary(employee1);
    Console.WriteLine(  "{0} {1}: {2}",employee1.FirstName, employee1.LastName,employee1.Salary);
}
static void IncreaseSalary(Employee employee)
{
    employee.Salary = "Enough to survive on";
}

        En C#, les méthodes membres qui ne peuvent être appelées que via des objets sont appelées méthodes d'instance.

        Dans un membre d'instance d'une classe, vous pouvez l'utiliser pour obtenir la référence d'objet permettant d'appeler le membre d'instance, par exemple :

class Employee
{
    public string FirstName;
    public string LastName;
    public string Salary;
    public string GetName()
    {
        return $"{ FirstName }  { LastName }";
    }
    public void SetName(string newFirstName, string newLastName) 
    {
        this.FirstName = newFirstName;
        this.LastName = newLastName;
    }
}

        Le mot-clé this peut également être utilisé pour appeler explicitement des méthodes d'instance ou transmis dans des appels de méthode, par exemple :

class Employee
{
    public string FirstName;
    public string LastName;
    public string Salary;
    public string GetName() => $"{ FirstName }  { LastName }";
    public void SetName(string newFirstName, string newLastName)
    {
        this.FirstName = newFirstName;
        this.LastName = newLastName;
        Console.WriteLine( $"Name changed to '{ this.GetName() }'");
    }
    public void Save()
    {
        DataStorage.Store(this);
    }
}
class DataStorage
{
    // Save an employee object to a file named with the Employee name.
    public static void Store(Employee employee) { ...}
}

3. Modificateurs d'accès

Les modificateurs d'accès identifient le niveau d'encapsulation du membre modifié.

• public : modificateur de classe ou de membre ; indique que la classe ou le membre est accessible depuis l'extérieur de la classe
• private : modificateur de membre ; indique que le membre modifié n'est accessible qu'au sein de la classe déclarée
• protected : modificateur de membre ; indique que le membre modifié n'est accessible qu'au sein de la classe déclarée ou de la classe dérivée
• internal : modificateur de classe ou de membre ; indique que la classe ou le membre n'est accessible que dans le même assembly
• Interne protégé : modificateur de classe ou de membre ; indique que la classe ou le membre n'est accessible que dans l'assembly actuel ou les classes dérivées.

class Employee
{
    public string FirstName, LastName,Salary, Password;
    private bool IsAuthenticated;
    public bool Logon(string password) 
    {
        if (Password == password)
            IsAuthenticated = true;
        return IsAuthenticated;
    }
    public bool GetIsAuthenticated() => IsAuthenticated;
    // ...
}

4. Paramètres de la méthode

        Tapez le niveau d'accès par défaut :

Membres de	Accessibilité des membres par défaut	Accessibilité déclarée autorisée du membre
énumération	publique	Aucun
classe	privé	publique protégé interne privé interne protégé
interface	publique	Aucun
structurer	privé	publique interne privé

5. Attributs

        Les propriétés combinent les caractéristiques des champs et des méthodes membres. Pour les utilisateurs de l'objet, une propriété apparaît comme un champ et l'accès aux propriétés utilise la même syntaxe que l'accès aux champs. Pour l'implémenteur d'une classe, une propriété est un bloc de code composé d'accesseurs get et/ou d'accesseurs set. Lors de la lecture d'une propriété, le bloc de code de l'accesseur get est exécuté ; lors de l'attribution d'une valeur à la propriété, le bloc de code de l'accesseur set est exécuté.

        Les propriétés sans accesseurs définis sont appelées propriétés en lecture seule. Les propriétés sans accesseur get sont appelées propriétés en écriture seule. Une propriété qui possède les deux accesseurs ci-dessus est appelée propriété en lecture-écriture.  

        Contrairement aux champs, les propriétés ne sont pas classées comme variables. Par conséquent, les propriétés ne peuvent pas être transmises en tant que paramètres ref ou out.

6. Implémenter automatiquement les attributs

        Dans C# 3.0 et versions ultérieures, les propriétés implémentées automatiquement rendent les déclarations de propriété plus concises lorsqu’aucune autre logique n’est nécessaire dans l’accesseur de propriété. En C# 6 et versions ultérieures, les propriétés implémentées automatiquement peuvent être initialisées comme des champs.

public static void Main()
{
    Employee employee1 = new Employee();
    Employee employee2 = new Employee();
    employee1.FirstName = "Inigo";    // Call the FirstName property's setter.
    System.Console.WriteLine(employee1.FirstName);    // Call the FirstName property's getter.
    // Assign an auto-implemented property
    employee2.Title = "Computer Nerd";
    employee1.Manager = employee2;
    // Print employee1's manager's title.
    System.Console.WriteLine(employee1.Manager.Title);
}
class Employee
{
    public string FirstName { get; set; }
    private string LastName { get; set; }
    public string Title { get; set; }
    public Employee Manager { get; set; }
    public string Salary { get; set; } = "Not Enough";
}

7. Restrictions d'accès aux attributs

        Par défaut, les accesseurs get /set ont la même visibilité et le même niveau d'accès. À partir de C# 2.0, il est autorisé dans les implémentations de propriétés de spécifier des modificateurs d’accès pour la partie get ou set, remplaçant ainsi les modificateurs d’accès spécifiés pour la propriété.

        L'utilisation de modificateurs d'accès sur les propriétés présente les restrictions suivantes :

• Les modificateurs d'accès ne peuvent pas être utilisés sur les interfaces ou sur les membres d'interface explicitement implémentés.
• Les modificateurs d'accesseur ne peuvent être utilisés que si la propriété contient à la fois des accesseurs set et get. Dans ce cas, le modificateur n’est autorisé que pour l’un d’entre eux.
• Si une propriété ou un indexeur a un modificateur de remplacement, le modificateur d'accesseur doit correspondre au modificateur d'accès de l'accesseur surchargé, le cas échéant.
• Le niveau d’accessibilité de l’accesseur doit être plus restrictif que le niveau d’accessibilité du bien lui-même.

class Employee
{
    public void Initialize(int id) => Id = id.ToString();
    public string Id
    {
        get 
        { 
            return _Id;
        }
        private set 
        { 
            // Providing an access modifier is possible in C# 2.0 and higher only
            _Id = value;
        }
    }
    private string _Id;
}

2. Constructeur

1. Constructeur

1.1 Le constructeur est une méthode avec le même nom que la classe et sans valeur de retour, par exemple :

class Employee
{
    public Employee(string firstName, string lastName) // constructor
    {
        FirstName = firstName;
        LastName = lastName;
    }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string  Title {get; set}
    public string Salary { get; set; } = "Not Enough";
    public string Name
    {
        get
        {
            return FirstName + " " + LastName;
        }
        set
        {
            string[] names;
            names = value.Split(new char[] { ' ' });
            if (names.Length == 2)
            {
                FirstName = names[0];
                LastName = names[1];
            }
            else
            {
                throw new System.ArgumentException(string.Format($"Assigned value '{ value }' is invalid", nameof(value)));
            }
        }
    }
}

1.2 Appeler le constructeur

public static void Main()
{
    Employee employee;
    employee = new Employee("Inigo", "Montoya");
    employee.Salary = "Too Little";
    Console.WriteLine(  "{0} {1}: {2}", employee.FirstName, 
    employee.LastName,employee.Salary);
}

1.3 Constructeur par défaut

        Si une classe ne définit pas explicitement un constructeur, le compilateur C# ajoute automatiquement un constructeur sans aucun paramètre au moment de la compilation. Une fois qu'une classe définit explicitement un constructeur, le compilateur ne fournit pas de constructeur par défaut.

2. Initialiseur d'objet

        L'initialiseur est utilisé pour initialiser tous les champs et propriétés accessibles dans l'objet. Lors de l'appel du constructeur, vous pouvez ajouter une liste d'initialisation des membres entre les accolades suivantes, par exemple :

public static void Main()
{
    Employee employee = new Employee("Inigo", "Montoya")
    {
        Title = "Computer Nerd",
        Salary = "Not enough"
    };
    Console.WriteLine("{0} {1} ({2}): {3}", employee.FirstName, employee.LastName, employee.Title, employee.Salary);
}

3. Chaîne de constructeurs

        En C#, il est permis d'appeler un autre constructeur de la même classe à partir d'un constructeur en ajoutant le mot-clé this après deux points puis en ajoutant la liste des paramètres du constructeur appelé, par exemple :

class Employee
{
    public Employee(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
    public Employee(int id, string firstName, string lastName)
        : this(firstName, lastName)
    {
        Id = id;
    }

    public Employee(int id)
    {
        Id = id;
        // NOTE: Member constructors cannot be called explicitly inline
        // this(id, firstName, lastName);
    }
    public int Id { get; private set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Salary { get; set; } = "Not Enough";
}

4. Type anonyme

        Les types anonymes sont des types générés dynamiquement par le compilateur. Lorsque le compilateur rencontre un type anonyme, il génère automatiquement une classe CIL. Cette classe possède des propriétés correspondant aux valeurs et aux types de données qui ont été nommés dans la déclaration de type anonyme. Par exemple:

public static void Main()
{
    var patent1 =new
    {
        Title = "Bifocals",
        YearOfPublication = "1784"
    };      
    var patent2 =new
    {
        Title = "Phonograph",
        YearOfPublication = "1877"
    };  
    var patent3 =new
    {
        patent1.Title,
        Year = patent1.YearOfPublication
    };
    System.Console.WriteLine("{0} ({1})",patent1.Title, patent1.YearOfPublication);
    System.Console.WriteLine("{0} ({1})", patent2.Title, patent1.YearOfPublication);
    Console.WriteLine();
    Console.WriteLine(patent1);
    Console.WriteLine(patent2);

    Console.WriteLine();
    Console.WriteLine(patent3);
}

3. Membres statiques

1. Champs statiques

        Les champs partagés entre plusieurs instances d'une classe sont identifiés par le mot-clé static. Comme les champs d'instance, les champs statiques peuvent également être initialisés au moment de la déclaration. Par exemple:

class Employee
{
    // ...
    public static int  Id;   // default(int): 0 
    public static int NextId = 42;
    // ...
}

        Contrairement aux champs d'instance, les champs statiques non initialisés obtiendront des valeurs par défaut, qui sont les résultats de default(T)

2. Méthode statique

        Semblables aux champs statiques, les méthodes statiques sont également marquées du mot-clé static. Les méthodes statiques sont accessibles directement via le nom de la classe. Par exemple:

public static void Main()
{
    DirectoryInfo directory = new DirectoryInfo(".\\Source");
    directory.MoveTo(".\\Root");
    DirectoryInfoExtension.CopyTo(directory, ".\\Target", SearchOption.AllDirectories, "*");
}
public static class DirectoryInfoExtension
{
    public static void CopyTo(  DirectoryInfo sourceDirectory, string target, SearchOption option, string searchPattern) 
    {
        if (target[target.Length - 1] !=  Path.DirectorySeparatorChar)
            target += Path.DirectorySeparatorChar;
        if (!Directory.Exists(target))
            Directory.CreateDirectory(target);
        for (int i = 0; i < searchPattern.Length; i++)
        {
            foreach (string file in  Directory.GetFiles(sourceDirectory.FullName, searchPattern))  
            {
                File.Copy(file, target + Path.GetFileName(file), true);
             }
        }
        if (option == SearchOption.AllDirectories) //Copy subdirectories (recursively)
        {
            foreach (string element in Directory.GetDirectories(sourceDirectory.FullName))
                Copy(element,  target + Path.GetFileName(element),searchPattern);
        }
    }
    private static void Copy(string element, string fileName, string searchPattern)
    {
        Console.WriteLine("Copying " + fileName);
    }
}

3. Constructeur statique

        Le constructeur statique n'est pas appelé explicitement, mais est appelé automatiquement au moment de l'exécution lors du premier accès à la classe. Le premier accès à une classe se produit lors de l'utilisation d'un constructeur normal, ou peut se produire lors de l'accès à une méthode ou à un champ statique de la classe. Le constructeur statique n'autorise aucun paramètre

class Employee
{
    static Employee()
    {
        Random randomGenerator = new Random();
        NextId = randomGenerator.Next(101, 999);
    }

    // ...
    public static int NextId = 42;
    // ...
}

4. Attributs statiques

        Les propriétés peuvent également être statiques. Par exemple:

class Employee
{
    // ...
    public static int NextId
    {
        get
        {
            return _NextId;
        }
        private set
        {
            _NextId = value;
        }
    }
    public static int _NextId = 42;
    // ...
}

5. Classe statique

        Les classes statiques peuvent également être définies en C#. Les classes statiques ne contiennent aucun champ ou méthode d'instance. Les classes statiques ne peuvent donc pas être instanciées. Le compilateur marque automatiquement les classes statiques comme abstraites et scellées dans le code CIL. Autrement dit, spécifier une classe comme non extensible

public static class SimpleMath
{
    public static int Max(params int[] numbers)
    {
    
        if (numbers.Length == 0)  // Check that there is at least one item in numbers.
            throw new ArgumentException( "numbers cannot be empty", nameof(numbers));
        int result = numbers[0]; 
        foreach (int number in numbers)
        {
            if (number > result)
                result = number;
        }
        return result;
    }
}
public class Program
{
    public static void Main(string[] args)
    {
        int[] numbers = new int[args.Length];
        for (int count = 0; count < args.Length; count++)
            numbers[count] = args[count].Length;
        Console.WriteLine( $@"Longest argument length = { SimpleMath.Max(numbers) }");
    }
}

6. Données encapsulées

6.1 Champs const

• Un champ const a une valeur déterminée au moment de la compilation et ne sera pas modifié au moment de l'exécution. Les champs constants deviennent automatiquement des champs statiques  
• Si un assembly fait référence à une constante dans un autre assembly, la valeur constante est compilée directement dans l’assembly référencé.

class ConvertUnits
{
    public const float CentimersPerInch = 2.54F; 
    public  const int  CupsPerGallon = 16;                                                           
}

6.2 lecture seule

        Le modificateur readonly ne peut être utilisé que sur des champs (pas sur des variables locales). Il indique que les valeurs des champs ne peuvent être modifiées qu'à partir du constructeur ou via un initialiseur lorsqu'elles sont déclarées.

class Employee
{
    public Employee(int id)
    {
        _Id = id;
    }
    private readonly int _Id;
    public int Id{
        get { return _Id; }
    }
    // Error: A readonly field cannot be assigned to (excep in a constructor or a variable initializer)
    // public void SetId(int id) =>_Id = id;
}

7. Catégorie de division

        Les classes partielles sont des parties d'une classe qui peuvent être combinées en une classe complète. Les classes partielles sont principalement utilisées pour diviser la définition d'une classe en plusieurs fichiers. C# utilise le mot-clé partial pour déclarer des classes partielles

// File: Program1.cs
partial class Program
{
}
// File: Program2.cs
partial class Program
{
}

8. Méthode de division

        Les méthodes partielles existent dans des classes partielles, qui permettent à une méthode d'être déclarée dans un fichier et implémentée dans un autre fichier. Par exemple:

// File: Person.Designer.cs
public partial class Person
{
    #region Extensibility Method Definitions
    partial void OnLastNameChanging(string value);
    partial void OnFirstNameChanging(string value);
    #endregion
    // ...
}
// File: Person.cs
partial class Person
{
    partial void OnLastNameChanging(string value)
    {
        //...
    }
    partial void OnFirstNameChanging(string value)
    {
         //...
    }
}