Propriétés (Guide de programmation C#)Properties (C# Programming Guide)

Une propriété est un membre qui fournit un mécanisme flexible pour la lecture, l'écriture ou le calcul de la valeur d'un champ privé.A property is a member that provides a flexible mechanism to read, write, or compute the value of a private field. Les propriétés peuvent être utilisées comme s’il s’agissait de membres de données publics, mais ce sont en fait des méthodes spéciales appelées accesseurs.Properties can be used as if they are public data members, but they are actually special methods called accessors. Elles permettent aux données d'être facilement accessibles tout en soutenant quand même la sécurité et la flexibilité des méthodes.This enables data to be accessed easily and still helps promote the safety and flexibility of methods.

Vue d’ensemble des propriétésProperties overview

  • Les propriétés permettent à une classe d'exposer un moyen public d'obtenir et de définir des valeurs, tout en masquant le code d'implémentation ou de vérification.Properties enable a class to expose a public way of getting and setting values, while hiding implementation or verification code.

  • Un accesseur de propriété get est utilisé pour retourner la valeur de la propriété et un accesseur de propriété set est utilisé pour affecter une nouvelle valeur.A get property accessor is used to return the property value, and a set property accessor is used to assign a new value. Ces accesseurs peuvent avoir différents niveaux d’accès.These accessors can have different access levels. Pour plus d’informations, consultez Restriction d’accessibilité de l’accesseur.For more information, see Restricting Accessor Accessibility.

  • Le mot clé value est utilisé pour définir la valeur assignée par l’accesseur set.The value keyword is used to define the value being assigned by the set accessor.

  • Les propriétés peuvent être en lecture-écriture (elles ont un accesseur get et un accesseur set), en lecture seule (elles ont un accesseur get, mais pas d’accesseur set) ou en écriture seule (elles ont un accesseur set, mais pas d’accesseur get).Properties can be read-write (they have both a get and a set accessor), read-only (they have a get accessor but no set accessor), or write-only (they have a set accessor, but no get accessor). Les propriétés en écriture seule sont rares et sont généralement utilisées pour restreindre l’accès aux données sensibles.Write-only properties are rare and are most commonly used to restrict access to sensitive data.

  • Les propriétés simples qui ne nécessitent pas de code d’accesseur personnalisé peuvent être implémentées en tant que définitions de corps d’expression ou en tant que propriétés implémentées automatiquement.Simple properties that require no custom accessor code can be implemented either as expression body definitions or as auto-implemented properties.

Propriétés avec des champs de stockageProperties with backing fields

Un modèle de base pour l’implémentation d’une propriété consiste à utiliser un champ de stockage privé pour définir et extraire la valeur de propriété.One basic pattern for implementing a property involves using a private backing field for setting and retrieving the property value. L’accesseur get retourne la valeur du champ privé et l’accesseur set peut effectuer une validation des données avant d’assigner une valeur au champ privé.The get accessor returns the value of the private field, and the set accessor may perform some data validation before assigning a value to the private field. Les deux accesseurs peuvent également effectuer des opérations de conversion ou de calcul sur les données avant de stocker ou retourner les données.Both accessors may also perform some conversion or computation on the data before it is stored or returned.

L’exemple suivant illustre ce modèle.The following example illustrates this pattern. Dans cet exemple, la classe TimePeriod représente un intervalle de temps.In this example, the TimePeriod class represents an interval of time. La classe stocke l’intervalle de temps en secondes, en interne, dans un champ privé nommé _seconds.Internally, the class stores the time interval in seconds in a private field named _seconds. L’utilisateur peut éventuellement spécifier l’intervalle de temps en heures à l’aide de la propriété en lecture-écriture Hours.A read-write property named Hours allows the customer to specify the time interval in hours. Les deux accesseurs de propriété get et set effectuent ensuite la conversion nécessaire des heures en secondes.Both the get and the set accessors perform the necessary conversion between hours and seconds. De plus, l’accesseur set valide les données et lève une exception ArgumentOutOfRangeException si le nombre d’heures n’est pas valide.In addition, the set accessor validates the data and throws an ArgumentOutOfRangeException if the number of hours is invalid.

using System;

class TimePeriod
{
   private double _seconds;

   public double Hours
   {
       get { return _seconds / 3600; }
       set { 
          if (value < 0 || value > 24)
             throw new ArgumentOutOfRangeException(
                   $"{nameof(value)} must be between 0 and 24.");

          _seconds = value * 3600; 
       }
   }
}

class Program
{
   static void Main()
   {
       TimePeriod t = new TimePeriod();
       // The property assignment causes the 'set' accessor to be called.
       t.Hours = 24;

       // Retrieving the property causes the 'get' accessor to be called.
       Console.WriteLine($"Time in hours: {t.Hours}");
   }
}
// The example displays the following output:
//    Time in hours: 24

Définitions de corps d’expressionExpression body definitions

Les accesseurs de propriété sont souvent des instructions sur une ligne qui ne font qu’assigner ou retourner le résultat d’une expression.Property accessors often consist of single-line statements that just assign or return the result of an expression. Vous pouvez implémenter ces propriétés en tant que membres expression-bodied.You can implement these properties as expression-bodied members. Les définitions de corps d’expression se composent du symbole => suivi de l’expression à assigner à la propriété ou à récupérer de la propriété.Expression body definitions consist of the => symbol followed by the expression to assign to or retrieve from the property.

À partir de C# 6, les propriétés en lecture seule peuvent implémenter l’accesseur get en tant que membre expression-bodied.Starting with C# 6, read-only properties can implement the get accessor as an expression-bodied member. Dans ce cas, le mot clé d’accesseur get et le mot clé return ne sont pas utilisés.In this case, neither the get accessor keyword nor the return keyword is used. L’exemple suivant implémente la propriété en lecture seule Name en tant que membre expression-bodied.The following example implements the read-only Name property as an expression-bodied member.

using System;

public class Person
{
   private string _firstName;
   private string _lastName;
   
   public Person(string first, string last)
   {
      _firstName = first;
      _lastName = last;
   }

   public string Name => $"{_firstName} {_lastName}";   
}

public class Example
{
   public static void Main()
   {
      var person = new Person("Isabelle", "Butts");
      Console.WriteLine(person.Name);
   }
}
// The example displays the following output:
//      Isabelle Butts

À compter de C# 7.0, les accesseurs get et set peuvent être implémentés comme membres expression-bodied.Starting with C# 7.0, both the get and the set accessor can be implemented as expression-bodied members. Dans ce cas, les mots clés get et set doivent être spécifiés.In this case, the get and set keywords must be present. L’exemple suivant illustre l’utilisation de définitions de corps d’expression pour les deux accesseurs.The following example illustrates the use of expression body definitions for both accessors. Notez que le mot clé return n’est pas utilisé avec l’accesseur get.Note that the return keyword is not used with the get accessor.

using System;

public class SaleItem
{
   string _name;
   decimal _cost;
   
   public SaleItem(string name, decimal cost)
   {
      _name = name;
      _cost = cost;
   }

   public string Name 
   {
      get => _name;
      set => _name = value;
   }

   public decimal Price
   {
      get => _cost;
      set => _cost = value; 
   }
}

class Program
{
   static void Main(string[] args)
   {
      var item = new SaleItem("Shoes", 19.95m);
      Console.WriteLine($"{item.Name}: sells for {item.Price:C2}");
   }
}
// The example displays output like the following:
//       Shoes: sells for $19.95



Propriétés implémentées automatiquementAuto-implemented properties

Dans certains cas, les accesseurs de propriété get et set ne font qu’assigner une valeur à un champ de stockage, ou récupérer une valeur d’un champ de stockage, sans inclure de logique supplémentaire.In some cases, property get and set accessors just assign a value to or retrieve a value from a backing field without including any additional logic. En utilisant des propriétés implémentées automatiquement, vous simplifiez votre code, tout en laissant le compilateur C# fournir le champ de stockage de manière transparente.By using auto-implemented properties, you can simplify your code while having the C# compiler transparently provide the backing field for you.

Si une propriété a les accesseurs get et set, tous deux doivent être implémentés automatiquement.If a property has both a get and a set accessor, both must be auto-implemented. Vous définissez une propriété implémentée automatiquement à l’aide des mots clés get et set sans fournir d’implémentation.You define an auto-implemented property by using the get and set keywords without providing any implementation. L’exemple suivant est identique à l’exemple précédent, sauf qu’il utilise les propriétés implémentées automatiquement Name et Price.The following example repeats the previous one, except that Name and Price are auto-implemented properties. Notez que l’exemple supprime également le constructeur paramétrable pour que les objets SaleItem soient initialisés avec un appel au constructeur sans paramètre et un initialiseur d’objet.Note that the example also removes the parameterized constructor, so that SaleItem objects are now initialized with a call to the parameterless constructor and an object initializer.

using System;

public class SaleItem
{
   public string Name 
   { get; set; }

   public decimal Price
   { get; set; }
}

class Program
{
   static void Main(string[] args)
   {
      var item = new SaleItem{ Name = "Shoes", Price = 19.95m };
      Console.WriteLine($"{item.Name}: sells for {item.Price:C2}");
   }
}
// The example displays output like the following:
//       Shoes: sells for $19.95



Spécification du langage C#C# Language Specification

Pour plus d’informations, consultez Propriétés dans la spécification du langage C#.For more information, see Properties in the C# Language Specification. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.The language specification is the definitive source for C# syntax and usage.

Voir aussiSee also