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. Par exemple, lorsque vous retournez la variable privée de l'accesseur get et que les optimisations sont activées, le compilateur fait en sorte que l'appel à la méthode d'accesseur get soit inline pour qu'il n'y ait pas surcharge d'appels à la méthode. Toutefois, une méthode d'accesseur get virtuelle ne peut pas être inline car le compilateur ne sait pas au moment de la compilation quelle méthode sera réellement appelée au moment de l'exécution. Voici un accesseur get qui retourne la valeur d'un champ privé name :

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

Lorsque vous référencez la propriété, sauf dans le cas où il s'agit de la cible d'une assignation, l'accesseur get est appelé pour lire la valeur de la propriété. Par exemple :

Person p1 = new Person();
//...

System.Console.Write(p1.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 s'écouler du corps de l'accesseur.

Modifier l'état de l'objet à l'aide de l'accesseur get n'est pas une bonne habitude de programmation. Par exemple, l'accesseur ci-dessous a pour effet secondaire de modifier l'état de l'objet à chaque accès au champ number.

private int 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. Par exemple :

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

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

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

class Person
{
    private string name;  // the name field
    public string Name    // the Name property
    {
        get
        {
            return name;
        }
        set
        {
            name = value;
        }
    }
}

Lorsque vous assignez une valeur à la propriété, l'accesseur set est appelé avec un argument qui fournit la nouvelle valeur. Par exemple :

Person p1 = new Person();
p1.Name = "Joe";  // the set accessor is invoked here                

System.Console.Write(p1.Name);  // the get 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.

Les propriétés peuvent être marquées comme public, private, protected, internal ou protected internal. Ces modificateurs d'accès définissent la façon dont les utilisateurs de la classe ont accès à la propriété. Les accesseurs get et set d'une même propriété peuvent avoir des modificateurs d'accès différents. Par exemple, get peut être public pour autoriser l'accès en lecture seule depuis l'extérieur du type et set peut être private ou protected. Pour plus d'informations, consultez Modificateurs d'accès (guide de programmation C#).

Une propriété peut être déclarée comme étant statique à l'aide du mot clé static. Elle devient ainsi disponible aux appelants à tout moment, même s'il n'existe aucune instance de la classe. Pour plus d'informations, consultez Classes statiques et membres de classe statique (guide de programmation C#).

Une propriété peut être marquée comme étant virtuelle à l'aide du mot clé virtual. Cela permet aux classes dérivées de se substituer au comportement de la propriété à l'aide du mot clé override. Pour plus d'informations sur ces options, consultez Héritage (guide de programmation C#).

Une propriété qui se substitue à une propriété virtuelle peut également être sealed, ce qui spécifie que pour les classes dérivées elle n'est plus virtuelle. Enfin, une propriété peut être déclarée abstract, ce qui signifie qu'il n'y a aucune implémentation dans la classe, et que les classes dérivées doivent écrire leur propre implémentation. Pour plus d'informations sur ces options, consultez Classes abstract et sealed et membres de classe (guide de programmation C#).

Remarque
Utiliser un modificateur virtual (référence C#), abstract (référence C#) ou override (référence C#) sur un accesseur d'une propriété statique est une erreur.

Employee number: 101

Employee name: Claude Vige

Name in the derived class is: John, Manager

Name in the base class is: Mary

Points importants de 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 :

  
  
  
  C#

  public new string Name
  

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

  
  
  
  C#

  ((Employee)m1).Name = "Mary";
  

  Pour plus d'informations sur le masquage de membres, consultez new, modificateur (référence C#).

abstract class Shape
{
    public abstract double Area
    {
        get;
        set;
    }
}

class Square : Shape
{
    public double side;

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

    public override double Area
    {
        get
        {
            return side * side;
        }
        set
        {
            side = System.Math.Sqrt(value);
        }
    }
}

class Cube : Shape
{
    public double side;

    public Cube(double s)
    {
        side = s;
    }

    public override double Area
    {
        get
        {
            return 6 * side * side;
        }
        set
        {
            side = System.Math.Sqrt(value / 6);
        }
    }
}

class TestShapes
{
    static void Main()
    {
        // Input the side:
        System.Console.Write("Enter the side: ");
        double side = double.Parse(System.Console.ReadLine());

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

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

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

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

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

Entrée

4
24

Enter the side: 4

Area of the square = 16.00

Area of the cube = 96.00

Enter the area: 24

Side of the square = 4.90

Side of the cube = 2.00

Tâches

Référence

Concepts