Partager via

readonly (référence C#)

Le readonly mot clé est un modificateur qui peut être utilisé dans cinq contextes :

  • Dans une déclaration de champ, readonly indique que l’affectation au champ ne peut se produire que dans le cadre de la déclaration ou dans un constructeur dans la même classe. Un champ en lecture seule peut être affecté et réaffecté plusieurs fois dans la déclaration de champ et le constructeur.

    Un readonly champ ne peut pas être affecté après la sortie du constructeur. Cette règle a des implications différentes pour les types valeur et les types de référence :

    • Étant donné que les types valeur contiennent directement leurs données, un champ qui est un readonly type valeur est immuable.
    • Étant donné que les types de référence contiennent une référence à leurs données, un champ qui est un readonly type référence doit toujours faire référence au même objet. Cet objet peut ne pas être immuable. Le readonly modificateur empêche le remplacement de la valeur de champ par une autre instance du type de référence. Toutefois, le modificateur n’empêche pas la modification des données d’instance du champ via le champ en lecture seule.

    Avertissement

    Un type visible en externe qui contient un champ en lecture seule visible externe qui est un type de référence mutable peut être une vulnérabilité de sécurité et peut déclencher l’avertissement CA2104 : « Ne déclarez pas les types de référence mutables en lecture seule ».

  • Dans une readonly struct définition de type, readonly indique que le type de structure est immuable. Pour plus d’informations, consultez la readonly section struct de l’article Types de structure .

  • Dans une déclaration de membre d’instance dans un type de structure, readonly indique qu’un membre d’instance ne modifie pas l’état de la structure. Pour plus d’informations, consultez la section membres de l’instancereadonly de l’article Types de structure.

  • Dans ref readonly un retour de méthode, le modificateur readonly indique que la méthode retourne une référence et que les écritures vers cette référence ne sont pas autorisées.

Exemple de champ en lecture seule

Dans cet exemple, la valeur du champ year ne peut pas être modifiée dans la méthode ChangeYear, même si elle a été affectée à une valeur dans le constructeur de classe :

class Age
{
    private readonly int _year;
    Age(int year)
    {
        _year = year;
    }
    void ChangeYear()
    {
        //_year = 1967; // Compile error if uncommented.
    }
}

Vous pouvez affecter une valeur à un readonly champ uniquement dans les contextes suivants :

  • Lorsque la variable est initialisée dans la déclaration, par exemple :

    public readonly int y = 5;

  • Dans un constructeur d’instance de la classe qui contient la déclaration de champ d’instance.

  • Dans le constructeur statique de la classe qui contient la déclaration de champ statique.

Ces contextes de constructeur sont également les seuls contextes dans lesquels il est valide de passer un readonly champ en tant que paramètre out ou ref .

Remarque

Le readonly mot clé est différent du mot clé const . Un const champ ne peut être initialisé qu’à la déclaration du champ. Un readonly champ peut être attribué plusieurs fois dans la déclaration de champ et dans n’importe quel constructeur. Par conséquent, readonly les champs peuvent avoir des valeurs différentes en fonction du constructeur utilisé. En outre, alors qu’un const champ est une constante au moment de la compilation, le readonly champ peut être utilisé pour les constantes d’exécution comme dans l’exemple suivant :

public static readonly uint timeStamp = (uint)DateTime.Now.Ticks;

public class SamplePoint
{
    public int x;
    // Initialize a readonly field
    public readonly int y = 25;
    public readonly int z;

    public SamplePoint()
    {
        // Initialize a readonly instance field
        z = 24;
    }

    public SamplePoint(int p1, int p2, int p3)
    {
        x = p1;
        y = p2;
        z = p3;
    }

    public static void Main()
    {
        SamplePoint p1 = new SamplePoint(11, 21, 32);   // OK
        Console.WriteLine($"p1: x={p1.x}, y={p1.y}, z={p1.z}");
        SamplePoint p2 = new SamplePoint();
        p2.x = 55;   // OK
        Console.WriteLine($"p2: x={p2.x}, y={p2.y}, z={p2.z}");
    }
    /*
     Output:
        p1: x=11, y=21, z=32
        p2: x=55, y=25, z=24
    */
}

Dans l’exemple précédent, si vous utilisez une instruction comme l’exemple suivant :

p2.y = 66;        // Error

vous obtenez le message d’erreur du compilateur :

Un champ en lecture seule ne peut pas être affecté à (sauf dans un constructeur ou un initialiseur de variable)

Membres d'instance en lecture seule

Vous pouvez également utiliser le modificateur readonly pour déclarer qu’un membre d’instance ne modifie pas l’état d’une struct.

public readonly double Sum()
{
    return X + Y;
}

Remarque

Dans le cas d’une propriété en lecture/écriture, vous pouvez ajouter le readonly modificateur à l’accesseur get . Certains get accesseurs peuvent effectuer un calcul et mettre en cache le résultat, plutôt que simplement retourner la valeur d’un champ privé. L’ajout du readonly modificateur au get accesseur garantit que l’accesseur get ne modifie pas l’état interne de l’objet par mise en cache de tout résultat.

Vous trouverez d’autres exemples dans la section membres de l’instancereadonly de l’article Types de structure.

Exemple de retour en lecture seule ref

Le readonly modificateur sur un ref return indique que la référence retournée ne peut pas être modifiée. L’exemple suivant retourne une référence à l’origine. Il utilise le readonly modificateur pour indiquer que les appelants ne peuvent pas modifier l’origine :

private static readonly SamplePoint s_origin = new SamplePoint(0, 0, 0);
public static ref readonly SamplePoint Origin => ref s_origin;

Le type retourné n’a pas besoin d’être un readonly struct. Tout type pouvant être retourné par ref peut être retourné par ref readonly.

Exemple de retour en lecture seule ref readonly

Un ref readonly return peut également être utilisé avec des membres d’instance readonly sur des types struct :

public struct ReadonlyRefReadonlyExample
{
    private int _data;

    public readonly ref readonly int ReadonlyRefReadonly(ref int reference)
    {
        // _data = 1; // Compile error if uncommented.
        return ref reference;
    }
}

La méthode retourne essentiellement une readonly référence avec le membre de l’instance (dans ce cas, une méthode) étant readonly (impossible de modifier les champs d’instance).

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

  • Last updated on