Operatore sizeof: determinare le esigenze di memoria per un determinato tipo

L'operatore sizeof restituisce il numero di byte occupati da una variabile di un determinato tipo. Nel codice sicuro, l'argomento dell'operatore sizeof deve essere il nome di un tipo non gestito predefinito la cui dimensione non è dipendente dalla piattaforma o un tipo di enumerazione.

Il riferimento al linguaggio C# documenta la versione rilasciata più di recente del linguaggio C#. Contiene anche la documentazione iniziale per le funzionalità nelle versioni di anteprima pubblica per la prossima versione del linguaggio di programmazione.

La documentazione identifica tutte le funzionalità introdotte nelle ultime tre versioni della lingua o nelle anteprime pubbliche correnti.

Le espressioni presentate nella tabella seguente vengono valutate in fase di compilazione con i valori costanti corrispondenti e non richiedono un contesto non sicuro:

La dimensione dei tipi nella tabella precedente è una costante in fase di compilazione.

Per un tipo enum, il risultato dell'operatore sizeof è la dimensione del tipo integrale sottostante dell'enumerazione. Il risultato viene calcolato in fase di compilazione.

Nel codice unsafe è possibile usare sizeof in qualsiasivoid tipo, inclusi i tipi costruiti dai parametri di tipo.

• La dimensione di un tipo riferimento o puntatore è la dimensione di un riferimento o di un puntatore, non la dimensione dell'oggetto a cui può fare riferimento.
• La dimensione di un tipo valore, non gestita o meno, è la dimensione di tale valore.
• Le dimensioni di un tipo di enumerazione sono le dimensioni del tipo integrale sottostante. Questa dimensione è una costante in fase di compilazione. Se il tipo sottostante di un'enumerazione definita in un assembly a cui viene fatto riferimento in un secondo momento cambia, il codice applicato sizeof a tale enumerazione deve essere ricompilato per osservare le nuove dimensioni.
• La dimensione di un ref struct tipo è la dimensione del valore. La dimensione di ogni ref campo è la dimensione di un riferimento o di un puntatore, non la dimensione del valore a cui fa riferimento.

Nell'esempio seguente viene illustrato l'utilizzo dell'operatore 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'operatore sizeof restituisce il numero di byte allocati da Common Language Runtime nella memoria gestita. Per tipi di struct, tale valore include qualsiasi spaziatura interna, come illustrato nell'esempio precedente. Il risultato dell'operatore sizeof può differire dal risultato del metodo Marshal.SizeOf, che restituisce le dimensioni di un tipo in memoria non gestita.

Specifica del linguaggio C#

Per altre informazioni, vedere la sezione dell'operatoresizeof della specifica del linguaggio C#.

Vedere anche

• C# operatori ed espressioni
• operatori correlati al puntatore
• tipi puntatore
• tipi correlati alla memoria e all'intervallo
• generics in .NET