Types valeur (référence C#)Value types (C# reference)

Les types valeur et les types référence sont les deux principales catégories de types C#.Value types and reference types are the two main categories of C# types. Une variable d’un type valeur contient une instance du type.A variable of a value type contains an instance of the type. Cela diffère d’une variable d’un type référence, qui contient une référence à une instance du type.This differs from a variable of a reference type, which contains a reference to an instance of the type. Par défaut, lors de l' assignation, en passant un argument à une méthode et en retournant un résultat de méthode, les valeurs des variables sont copiées.By default, on assignment, passing an argument to a method, and returning a method result, variable values are copied. Dans le cas des variables de type valeur, les instances de type correspondantes sont copiées.In the case of value-type variables, the corresponding type instances are copied. L’exemple suivant illustre ce comportement :The following example demonstrates that behavior:

using System;

public struct MutablePoint
{
    public int X;
    public int Y;

    public MutablePoint(int x, int y) => (X, Y) = (x, y);

    public override string ToString() => $"({X}, {Y})";
}

public class Program
{
    public static void Main()
    {
        var p1 = new MutablePoint(1, 2);
        var p2 = p1;
        p2.Y = 200;
        Console.WriteLine($"{nameof(p1)} after {nameof(p2)} is modified: {p1}");
        Console.WriteLine($"{nameof(p2)}: {p2}");

        MutateAndDisplay(p2);
        Console.WriteLine($"{nameof(p2)} after passing to a method: {p2}");
    }

    private static void MutateAndDisplay(MutablePoint p)
    {
        p.X = 100;
        Console.WriteLine($"Point mutated in a method: {p}");
    }
}
// Expected output:
// p1 after p2 is modified: (1, 2)
// p2: (1, 200)
// Point mutated in a method: (100, 200)
// p2 after passing to a method: (1, 200)

Comme le montre l’exemple précédent, les opérations sur une variable de type valeur affectent uniquement cette instance du type valeur, stockée dans la variable.As the preceding example shows, operations on a value-type variable affect only that instance of the value type, stored in the variable.

Si un type valeur contient un membre de données d’un type référence, seule la référence à l’instance du type référence est copiée lorsqu’une instance de type valeur est copiée.If a value type contains a data member of a reference type, only the reference to the instance of the reference type is copied when a value-type instance is copied. La copie et l’instance de type valeur d’origine ont accès à la même instance de type référence.Both the copy and original value-type instance have access to the same reference-type instance. L’exemple suivant illustre ce comportement :The following example demonstrates that behavior:

using System;
using System.Collections.Generic;

public struct TaggedInteger
{
    public int Number;
    private List<string> tags;

    public TaggedInteger(int n)
    {
        Number = n;
        tags = new List<string>();
    }

    public void AddTag(string tag) => tags.Add(tag);

    public override string ToString() => $"{Number} [{string.Join(", ", tags)}]";
}

public class Program
{
    public static void Main()
    {
        var n1 = new TaggedInteger(0);
        n1.AddTag("A");
        Console.WriteLine(n1);  // output: 0 [A]

        var n2 = n1;
        n2.Number = 7;
        n2.AddTag("B");

        Console.WriteLine(n1);  // output: 0 [A, B]
        Console.WriteLine(n2);  // output: 7 [A, B]
    }
}

Notes

Pour que votre code soit moins sujet aux erreurs et plus robuste, définissez et utilisez des types de valeurs immuables.To make your code less error-prone and more robust, define and use immutable value types. Cet article utilise des types de valeur mutable uniquement à des fins de démonstration.This article uses mutable value types only for demonstration purposes.

Genres de types valeurKinds of value types

Un type valeur peut être l’un des deux types suivants :A value type can be one of the two following kinds:

  • type structure, qui encapsule les données et les fonctionnalités associéesa structure type, which encapsulates data and related functionality
  • type énumération, qui est défini par un ensemble de constantes nommées et qui représente un choix ou une combinaison de choixan enumeration type, which is defined by a set of named constants and represents a choice or a combination of choices

Un type valeur Nullable T? représente toutes les valeurs de son type valeur sous-jacent T et une valeur null supplémentaire.A nullable value type T? represents all values of its underlying value type T and an additional null value. Vous ne pouvez pas assigner null à une variable d’un type valeur, sauf s’il s’agit d’un type valeur Nullable.You cannot assign null to a variable of a value type, unless it's a nullable value type.

Types valeur intégrésBuilt-in value types

C# fournit les types valeur intégrés suivants, également appelés types simples:C# provides the following built-in value types, also known as simple types:

Tous les types simples sont des types structure et diffèrent des autres types de structure en ce qu’ils autorisent certaines opérations supplémentaires :All simple types are structure types and differ from other structure types in that they permit certain additional operations:

  • Vous pouvez utiliser des littéraux pour fournir une valeur d’un type simple.You can use literals to provide a value of a simple type. Par exemple, 'A' est un littéral de type char, tandis que 2001 est un littéral de type int.For example, 'A' is a literal of the type char and 2001 is a literal of the type int.

  • Vous pouvez déclarer des constantes des types simples avec le mot clé const.You can declare constants of the simple types with the const keyword. Il n’est pas possible d’avoir des constantes d’autres types de structure.It's not possible to have constants of other structure types.

  • Les expressions constantes, dont les opérandes sont toutes des constantes des types simples, sont évaluées au moment de la compilation.Constant expressions, whose operands are all constants of the simple types, are evaluated at compile time.

À compter de C# 7,0, C# prend en charge les tuples de valeur.Beginning with C# 7.0, C# supports value tuples. Un tuple de valeur est un type valeur, mais pas un type simple.A value tuple is a value type, but not a simple type.

spécification du langage C#C# language specification

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :For more information, see the following sections of the C# language specification:

Voir aussiSee also