opérateur sizeof : déterminer les besoins en mémoire d’un type donné

L’opérateur sizeof retourne le nombre d’octets occupés par une variable d’un type donné. Dans le code sécurisé, l’argument de l’opérateur doit être le nom d’un type non managé intégré dont la taille n’est pas dépendante de la sizeof plateforme ou d’un type d’énumération.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Les expressions présentées dans le tableau suivant sont évaluées au moment de la compilation avec les valeurs constantes correspondantes et ne nécessitent pas de contexte non sécurisé :

La taille des types dans le tableau précédent est une constante au moment de la compilation.

Pour un type d’énumération, le résultat de l’opérateur sizeof est la taille du type intégral sous-jacent de l’énumération. Le résultat est calculé au moment de la compilation.

Dans du code non sécurisé , vous pouvez l’utiliser sizeof sur n’importe quel typevoid , y compris les types construits à partir de paramètres de type.

• La taille d’une référence ou d’un type de pointeur est la taille d’une référence ou d’un pointeur, et non la taille de l’objet auquel il peut faire référence.
• La taille d’un type valeur, non managée ou non, est la taille d’une telle valeur.
• La taille d’un type d’énumération est la taille de son type intégral sous-jacent. Cette taille est une constante au moment de la compilation. Si le type sous-jacent d’une énumération défini dans un assembly référencé change ultérieurement, le code appliqué sizeof à cette énumération doit être recompilé pour observer la nouvelle taille.
• La taille d’un ref struct type est la taille de la valeur. La taille de chaque ref champ est la taille d’une référence ou d’un pointeur, et non la taille de la valeur à laquelle il fait référence.

L’exemple suivant illustre l’utilisation de l’opérateur sizeof :

public struct Point
{
    public Point(byte tag, double x, double y) => (Tag, X, Y) = (tag, x, y);

    public byte Tag { get; }
    public double X { get; }
    public double Y { get; }
}

public class SizeOfOperator
{
    public static void Main()
    {
        Console.WriteLine(sizeof(byte));  // output: 1
        Console.WriteLine(sizeof(double));  // output: 8

        DisplaySizeOf<Point>();  // output: Size of Point is 24
        DisplaySizeOf<decimal>();  // output: Size of System.Decimal is 16

        unsafe
        {
            Console.WriteLine(sizeof(Point*));  // output: 8
            Console.WriteLine(sizeof(nint));  // output: 8 on 64-bit, 4 on 32-bit
            Console.WriteLine(sizeof(nuint)); // output: 8 on 64-bit, 4 on 32-bit
            Console.WriteLine(sizeof(Span<int>));  // output: 16 on 64-bit, 12 on 32-bit
        }
    }

    static unsafe void DisplaySizeOf<T>() where T : unmanaged
    {
        Console.WriteLine($"Size of {typeof(T)} is {sizeof(T)}");
    }
}

L’opérateur sizeof retourne le nombre d’octets alloués par le Common Language Runtime en mémoire managée. Pour struct types, cette valeur inclut tout remplissage, comme l’illustre l’exemple précédent. Le résultat de l’opérateur sizeof peut différer du résultat de la méthode Marshal.SizeOf, qui retourne la taille d’un type dans mémoire non managée.

Spécification du langage C#

Pour plus d’informations, consultez la sizeof section opérateur de la spécification du langage C#.

Voir aussi

• Opérateurs et expressions C#
• Opérateurs liés au pointeur
• Types de pointeur
• Types liés à la mémoire et à l’étendue
• Génériques en .NET