Partager via

Champs (Guide de programmation C#)

Un champ est une variable de tout type déclaré directement dans une classe ou un struct. Les champs sont membres de leur type contenant.

Une classe ou un struct peut avoir des champs d’instance, des champs statiques ou les deux. Les champs d’instance sont spécifiques à une instance d’un type. Si vous avez une classe T, avec un champ Fd’instance, vous pouvez créer deux objets de type Tet modifier la valeur de F chaque objet sans affecter la valeur dans l’autre objet. En revanche, un champ statique appartient au type lui-même et est partagé entre toutes les instances de ce type. Vous pouvez accéder au champ statique uniquement à l’aide du nom de type. Si vous accédez au champ statique par un nom d’instance, vous obtenez une erreur de compilation CS0176 .

En règle générale, vous devez déclarer l'accessibilité pour les champs private ou protected. Les données exposées par votre type au code client doivent être fournies par le biais de méthodes, de propriétés et d’indexeurs. En utilisant ces constructions pour l’accès indirect aux champs internes, vous pouvez vous protéger contre les valeurs d’entrée non valides. Un champ privé qui stocke les données exposées par une propriété publique est appelé stockage sous-jacent ou champ sous-jacent. Vous pouvez déclarer public des champs, mais vous ne pouvez pas empêcher le code qui utilise votre type de définir ce champ sur une valeur non valide ou modifier les données d’un objet.

Les champs stockent généralement les données qui doivent être accessibles à plusieurs méthodes de type et doivent être stockées plus longtemps que la durée de vie d’une seule méthode. Par exemple, un type qui représente une date de calendrier peut avoir trois champs entiers : un pour le mois, un pour le jour et un pour l’année. Les variables qui ne sont pas utilisées en dehors de l’étendue d’une seule méthode doivent être déclarées en tant que variables locales dans le corps de la méthode elle-même.

Les champs sont déclarés dans le bloc de classe ou de struct en spécifiant le niveau d’accès, suivi du type, suivi du nom du champ. Par exemple:

public class CalendarEntry
{

    // private field (Located near wrapping "Date" property).
    private DateTime _date;

    // Public property exposes _date field safely.
    public DateTime Date
    {
        get
        {
            return _date;
        }
        set
        {
            // Set some reasonable boundaries for likely birth dates.
            if (value.Year > 1900 && value.Year <= DateTime.Today.Year)
            {
                _date = value;
            }
            else
            {
                throw new ArgumentOutOfRangeException("Date");
            }
        }
    }

    // public field (Generally not recommended).
    public string? Day;

    // Public method also exposes _date field safely.
    // Example call: birthday.SetDate("1975, 6, 30");
    public void SetDate(string dateString)
    {
        DateTime dt = Convert.ToDateTime(dateString);

        // Set some reasonable boundaries for likely birth dates.
        if (dt.Year > 1900 && dt.Year <= DateTime.Today.Year)
        {
            _date = dt;
        }
        else
        {
            throw new ArgumentOutOfRangeException("dateString");
        }
    }

    public TimeSpan GetTimeSpan(string dateString)
    {
        DateTime dt = Convert.ToDateTime(dateString);

        if (dt.Ticks < _date.Ticks)
        {
            return _date - dt;
        }
        else
        {
            throw new ArgumentOutOfRangeException("dateString");
        }
    }
}

Pour accéder à un champ dans une instance, ajoutez un point après le nom de l’instance, suivi du nom du champ, comme dans instancename._fieldName. Par exemple:

CalendarEntry birthday = new CalendarEntry();
birthday.Day = "Saturday";

Un champ peut recevoir une valeur initiale à l’aide de l’opérateur d’affectation lorsque le champ est déclaré. Pour affecter automatiquement le Day champ à "Monday", par exemple, vous devez déclarer Day comme dans l’exemple suivant :

public class CalendarDateWithInitialization
{
    public string Day = "Monday";
    //...
}

Les champs sont initialisés immédiatement avant que le constructeur de l’instance d’objet soit appelé. Si le constructeur affecte la valeur d’un champ, il remplace toute valeur donnée lors de la déclaration de champ. Pour plus d’informations, consultez Utilisation de constructeurs.

Remarque

Un initialiseur de champ ne peut pas faire référence à d’autres champs d’instance.

Les champs peuvent être marqués comme public, , privateprotected, internal, protected internalou private protected. Ces modificateurs d’accès définissent la façon dont les utilisateurs du type peuvent accéder aux champs. Pour plus d’informations, consultez Modificateurs d’accès.

Un champ peut éventuellement être déclaré static. Les champs statiques sont disponibles pour les appelants à tout moment, même si aucune instance du type n’existe. Pour plus d’informations, consultez la page Classes statiques et membres de classes statiques.

Un champ peut être déclaré readonly. Un champ en lecture seule ne peut être affecté qu’à une valeur pendant l’initialisation ou dans un constructeur. Un static readonly champ est similaire à une constante, sauf que le compilateur C# n’a pas accès à la valeur d’un champ statique en lecture seule au moment de la compilation, uniquement au moment de l’exécution. Pour plus d’informations, consultez Constantes.

Un champ peut être déclaré required. Un champ obligatoire doit être initialisé par le constructeur ou par un initialiseur d’objet lorsqu’un objet est créé. Vous ajoutez l’attribut System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute à n’importe quelle déclaration de constructeur qui initialise tous les membres requis.

Le required modificateur ne peut pas être combiné avec le readonly modificateur sur le même champ. Toutefois, la propriété peut être required et init uniquement.

À compter de C# 12, les paramètres du constructeur principal constituent une alternative à la déclaration de champs. Lorsque votre type a des dépendances qui doivent être fournies lors de l’initialisation, vous pouvez créer un constructeur principal qui fournit ces dépendances. Ces paramètres peuvent être capturés et utilisés à la place des champs déclarés dans vos types. Dans le cas des types record, les paramètres du constructeur principal sont exposés en tant que propriétés publiques.

Spécification du langage C#

Pour plus d'informations, voir la spécification du langage C#. La spécification du langage est la source de référence pour la syntaxe C# et son utilisation.

Voir aussi