Accesseurs

L'accesseur d'une propriété contient les instructions exécutables associées à l'obtention (lecture ou calcul) ou à la définition (écriture) de la propriété. Les déclarations d'accesseurs peuvent contenir un accesseur get, un accesseur set, ou les deux. Les déclarations peuvent prendre les formes suivantes :

set {accessor-body}
get {accessor-body}

où :

accessor-body

Bloc qui contient les instructions à exécuter lorsque l'accesseur est appelé.

Accesseur get

Le corps de l'accesseur get est similaire à celui d'une méthode. Il doit retourner une valeur de type de propriété. L'exécution de l'accesseur get équivaut à la lecture de la valeur du champ. Voici un accesseur get qui retourne la valeur d'un champ privé name :

private string name;   // the name field
public string Name   // the Name property
{
   get
   {
      return name; 
   }
}

Lorsque vous référencez la propriété, sauf comme la cible d'une assignation, l'accesseur get est appelé pour lire la valeur de la propriété. Exemple :

Employee e1 = new Employee();
...
Console.Write(e1.Name);   // The get accessor is invoked here

L'accesseur get doit se terminer dans une instruction return ou throw, et le contrôle ne peut pas sortir du corps de l'accesseur.

Accesseur set

L'accesseur set est similaire à une méthode qui retourne void. Il utilise un paramètre implicite nommé value, dont le type est le type de la propriété. Dans l'exemple suivant, un accesseur set est ajouté à la propriété Name :

public string Name 
{
   get
   { 
      return name; 
   }
   set
   {
      name = value; 
   }
}

Lorsque vous assignez une valeur à la propriété, l'accesseur set est appelé par l'intermédiaire d'un argument qui fournit la nouvelle valeur. Exemple :

e1.Name = "Joe";   // The set accessor is invoked here

C'est une erreur d'utiliser le nom du paramètre implicite (value) pour une déclaration de variable locale dans un accesseur set.

Notes

Une propriété est classée en fonction des accesseurs utilisés, comme suit :

• Une propriété avec un accesseur get seulement est appelée propriété en lecture seule. Vous ne pouvez pas assigner de valeur à une propriété en lecture seule.
• Une propriété avec un accesseur set seulement est appelée propriété en écriture seule. Vous ne pouvez pas référencer une propriété en écriture seule, sauf si cette propriété est la cible d'une assignation.
• Une propriété avec des accesseurs get et set est une propriété en lecture-écriture.

Dans une déclaration de propriété, les accesseurs get et set doivent être déclarés au sein du corps de la propriété.

La modification de l'état de l'objet à l'aide de l'accesseur get constitue un style de programmation incorrect. Par exemple, l'accesseur ci-dessous a pour effet secondaire de modifier l'état de l'objet à chaque accès au champ number.

public int Number 
{
   get
   {
      return number++;   // Don't do this
   }
}

L'accesseur get peut être utilisé pour retourner la valeur du champ ou pour la calculer et la retourner. Exemple :

public string Name 
{
   get
   {
      return name != null ? name : "NA";
   }
}

Dans le segment de code précédent, si vous n'assignez pas une valeur à la propriété Name, la valeur NA est retournée.

Exemple 1

Cet exemple illustre comment accéder à une propriété dans une classe de base masquée par une autre propriété avec le même nom dans une classe dérivée.

// property_hiding.cs
// Property hiding
using System;
public class BaseClass 
{
   private string name;
   public string Name
   {
      get
      {
         return name; 
      }
      set
      {
         name = value; 
      }
   }
}

public class DerivedClass : BaseClass 
{
   private string name;
   public new string Name   // Notice the use of the new modifier
   {
      get
      {
         return name; 
      }
      set
      {
         name = value; 
      }
   }
}

public class MainClass 
{
   public static void Main() 
   {
      DerivedClass d1 = new DerivedClass();
      d1.Name = "John";  // Derived class property
      Console.WriteLine("Name in the derived class is: {0}",d1.Name);
      ((BaseClass)d1).Name = "Mary"; // Base class property
      Console.WriteLine("Name in the base class is: {0}",
         ((BaseClass)d1).Name);   
   }
}

Sortie

Name in the derived class is: John
Name in the base class is: Mary

Points importants illustrés dans l'exemple précédent :

• La propriété Name dans la classe dérivée masque la propriété Name dans la classe de base. Dans ce cas, le modificateur new est utilisé dans la déclaration de la propriété dans la classe dérivée :
  Copier

     public new string Name 
     {
     ...
  

• Le cast (BaseClass) permet d'accéder à la propriété masquée dans la classe de base :
  Copier

     ((BaseClass)d1).Name = "Mary";
  

Pour plus d'informations sur le masquage de membres, consultez new, modificateur.

Exemple 2

Dans cet exemple, deux classes, Cube et Square, implémentent une classe abstract, Shape, et remplacent sa propriété abstract Area. Notez l'utilisation du modificateur override sur les propriétés. Le programme accepte l'arête comme entrée et calcule la surface du carré et du cube. Il accepte aussi la surface comme entrée et calcule l'arête correspondante du carré et du cube.

// overridding_properties.cs
// Overriding properties
using System;
abstract class Shape 
{
   public abstract double Area 
   {
      get;
      set;
   }
}

class Square: Shape 
{
      public double side;

      // Constructor:
      public Square(double s) 
      {
         side = s;
      }

   // The Area property
   public override double Area 
   {
      get
      {
         return side*side ; 
      }
      set
      {
         // Given the area, compute the side
         side = Math.Sqrt(value); 
      }
   }
}

class Cube: Shape 
{
      public double side;    

      // Constructor:
      public Cube(double s) 
      {
         side = s;
      }

      // The Area property
      public override double Area 
      {
         get
         {
            return 6*side*side;
         }
         set
         {
            // Given the area, compute the side
            side = Math.Sqrt(value/6);
         }
      }
}

public class MainClass 
{
   public static void Main()  
   {
      // Input the side:
      Console.Write("Enter the side: ");
      string sideString = Console.ReadLine();   
      double side = double.Parse(sideString);

      // Compute areas:
      Square s = new Square(side);
      Cube c = new Cube(side);

      // Display results:
      Console.WriteLine("Area of a square = {0:F2}",s.Area);
      Console.WriteLine("Area of a cube = {0:F2}", c.Area); 

      // Input the area:
      Console.Write("Enter the area: ");
      string areaString = Console.ReadLine();   
      double area = double.Parse(areaString);

      // Compute sides:
      s.Area = area;
      c.Area = area;

      // Display results:
      Console.WriteLine("Side of a square = {0:F2}", s.side);
      Console.WriteLine("Side of a cube = {0:F2}", c.side);
   }
}

Entrée

4
24

Résultat de l'exemple

Enter the side: 4
Area of a square = 16.00
Area of a cube = 96.00
Enter the area: 24
Side of a square = 4.90
Side of a cube = 2.00

Voir aussi

Propriétés | virtual | override | abstract | base | Indexeurs | new, modificateur | Didacticiel sur les propriétés | Didacticiel sur les indexeurs