Campi (Guida per programmatori C#)

  • Articolo

Un campo è una variabile di qualsiasi tipo che viene dichiarata direttamente in una classe o struct. I campi sono membri del rispettivo tipo contenitore.

Una classe o uno struct può avere campi di istanza, campi statici o entrambi. I campi di istanza sono specifici di un'istanza di tipo. Se si dispone di una classe T, con un campo Fdi istanza , è possibile creare due oggetti di tipo Te modificare il valore di F in ogni oggetto senza influire sul valore nell'altro oggetto. Al contrario, un campo statico appartiene al tipo stesso e viene condiviso tra tutte le istanze di tale tipo. È possibile accedere al campo statico solo usando il nome del tipo. Se si accede al campo statico con un nome di istanza, viene visualizzato l'errore cs0176 in fase di compilazione.

In genere, è consigliabile dichiarare private o protected accessibilità per i campi. I dati esposti dal tipo al codice client devono essere forniti tramite metodi, proprietà e indicizzatori. Usando questi costrutti per l'accesso indiretto ai campi interni, è possibile evitare valori di input non validi. Un campo privato che archivia i dati esposti da una proprietà pubblica è chiamato archivio di backup o campo sottostante. È possibile dichiarare public i campi, ma non è possibile impedire al codice che usa il tipo di impostare tale campo su un valore non valido o modificare in altro modo i dati di un oggetto.

I campi archivia in genere i dati che devono essere accessibili a più di un metodo di tipo e devono essere archiviati per più tempo della durata di un singolo metodo. Ad esempio, un tipo che rappresenta una data del calendario può avere tre campi integer: uno per il mese, uno per il giorno e uno per l'anno. Le variabili non usate all'esterno dell'ambito di un singolo metodo devono essere dichiarate come variabili locali all'interno del corpo del metodo stesso.

I campi vengono dichiarati nella classe o nel blocco struct specificando il livello di accesso, seguito dal tipo , seguito dal nome del campo. Ad esempio:

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");
        }
    }
}

Per accedere a un campo in un'istanza di , aggiungere un punto dopo il nome dell'istanza, seguito dal nome del campo, come in instancename._fieldName. Ad esempio:

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

È possibile assegnare a un campo un valore iniziale usando l'operatore di assegnazione quando il campo viene dichiarato. Per assegnare automaticamente il campo Day a "Monday", ad esempio, è necessario dichiarare Day come nell'esempio seguente:

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

I campi vengono inizializzati immediatamente prima della chiamata del costruttore per l'istanza dell'oggetto. Se il costruttore assegna il valore di un campo, sovrascrive qualsiasi valore specificato durante la dichiarazione di campo. Per altre informazioni, vedere Uso dei costruttori.

Nota

Un inizializzatore di campo non può fare riferimento ad altri campi di istanza.

I campi possono essere contrassegnati come public, private, protectedinternal, protected internalo private protected. Questi modificatori di accesso definiscono il modo in cui gli utenti del tipo possono accedere ai campi. Per altre informazioni, vedere Modificatori di accesso.

Facoltativamente, è possibile dichiarare staticun campo . I campi statici sono disponibili per i chiamanti in qualsiasi momento, anche se non esiste alcuna istanza del tipo. Per altre informazioni, vedere Classi statiche e membri di classi statiche.

È possibile dichiarare readonlyun campo . A un campo di sola lettura può essere assegnato un valore solo durante l'inizializzazione o in un costruttore. Un static readonly campo è simile a una costante, ad eccezione del fatto che il compilatore C# non ha accesso al valore di un campo statico di sola lettura in fase di compilazione, solo in fase di esecuzione. Per altre informazioni, vedere Costanti.

È possibile dichiarare requiredun campo . Un campo obbligatorio deve essere inizializzato dal costruttore o da un inizializzatore di oggetto quando viene creato un oggetto. Aggiungere l'attributo a qualsiasi dichiarazione del System.Diagnostics.CodeAnalysis.SetsRequiredMembersAttribute costruttore che inizializza tutti i membri necessari.

Il required modificatore non può essere combinato con il readonly modificatore nello stesso campo. Tuttavia, la proprietà può essere required e init solo.

A partire da C# 12, i parametri del costruttore primario sono un'alternativa alla dichiarazione dei campi. Quando il tipo ha dipendenze che devono essere fornite all'inizializzazione, è possibile creare un costruttore primario che fornisca tali dipendenze. Questi parametri possono essere acquisiti e usati al posto dei campi dichiarati nei tipi. Nel caso dei tipi, i parametri del record costruttore primario vengono visualizzati come proprietà pubbliche.

Specifiche del linguaggio C#

Per altre informazioni, vedere la specifica del linguaggio C#. La specifica del linguaggio costituisce il riferimento ufficiale principale per la sintassi e l'uso di C#.

Vedi anche