Condividi tramite

static (Riferimenti per C#)

  • Articolo

Questa pagina illustra la parola chiave del modificatore static. La parola chiave static fa anche parte della direttiva using static.

Usare il modificatore static per dichiarare un membro statico, che appartiene allo stesso tipo invece che a un oggetto specifico. Il modificatore static può essere usato per dichiarare le classi static. Nelle classi, nelle interfacce e negli struct è possibile aggiungere il modificatore static a campi, metodi, proprietà, operatori, eventi e costruttori. Il modificatore static non può essere usato con indicizzatori o finalizzatori. Per altre informazioni, vedere Classi statiche e membri di classi statiche.

È possibile aggiungere il modificatore static a una funzione locale. Una funzione locale statica non può acquisire variabili locali o lo stato dell'istanza.

È possibile aggiungere il modificatore static a un'espressione lambda o a un metodo anonimo. Un'espressione lambda o un metodo anonimo statici non possono acquisire variabili locali o lo stato dell'istanza.

Esempio: classe static

La classe seguente viene dichiarata come static e contiene solo metodi static:

static class CompanyEmployee
{
    public static void DoSomething() { /*...*/ }
    public static void DoSomethingElse() { /*...*/  }
}

Una costante o una dichiarazione di tipo è implicitamente un membro static. Non è possibile fare riferimento a un membro static tramite un'istanza. Al contrario, è possibile farvi riferimento tramite il nome del tipo. Si consideri ad esempio la classe seguente:

public class MyBaseC
{
    public struct MyStruct
    {
        public static int x = 100;
    }
}

Per fare riferimento al membro staticx, usare il nome completo MyBaseC.MyStruct.x, a meno che il membro non sia accessibile dallo stesso ambito:

Console.WriteLine(MyBaseC.MyStruct.x);

Quando un'istanza di una classe contiene una copia separata di tutti i campi istanza della classe, è disponibile solo una copia di ogni campo static.

Non è possibile usare this per fare riferimento a metodi static o a funzioni di accesso di proprietà.

Se la parola chiave static viene applicata a una classe, tutti i membri della classe devono essere static.

Le classi, le interfacce e le classi static possono avere costruttori static. Un costruttore static viene chiamato in un determinato momento tra l'avvio del programma e la creazione di un'istanza della classe.

Nota

La parola chiave static ha un uso più limitato rispetto a C++. Per un confronto con la parola chiave di C++, vedere Classi di archiviazione (C++).

Per illustrare i membri static, si consideri una classe che rappresenta un dipendente di una società. Si supponga che la classe contenga un metodo di conteggio dei dipendenti e un campo per memorizzare il numero dei dipendenti. Il metodo e il campo non appartengono ad alcuna istanza del dipendente. Appartengono invece alla classe di dipendenti nel suo complesso. Devono essere dichiarati come membri static della classe.

Esempio: campo e metodo static

Questo esempio legge il nome e l'ID di un nuovo dipendente, il contatore dipendente viene incrementato di uno e vengono visualizzate le informazioni per il nuovo dipendente e il nuovo numero di dipendenti. Questo programma legge il numero corrente di dipendenti dalla tastiera.

public class Employee4
{
    public string id;
    public string name;

    public Employee4()
    {
    }

    public Employee4(string name, string id)
    {
        this.name = name;
        this.id = id;
    }

    public static int employeeCounter;

    public static int AddEmployee()
    {
        return ++employeeCounter;
    }
}

class MainClass : Employee4
{
    static void Main()
    {
        Console.Write("Enter the employee's name: ");
        string name = Console.ReadLine();
        Console.Write("Enter the employee's ID: ");
        string id = Console.ReadLine();

        // Create and configure the employee object.
        Employee4 e = new Employee4(name, id);
        Console.Write("Enter the current number of employees: ");
        string n = Console.ReadLine();
        Employee4.employeeCounter = Int32.Parse(n);
        Employee4.AddEmployee();

        // Display the new information.
        Console.WriteLine($"Name: {e.name}");
        Console.WriteLine($"ID:   {e.id}");
        Console.WriteLine($"New Number of Employees: {Employee4.employeeCounter}");
    }
}
/*
Input:
Matthias Berndt
AF643G
15
 *
Sample Output:
Enter the employee's name: Matthias Berndt
Enter the employee's ID: AF643G
Enter the current number of employees: 15
Name: Matthias Berndt
ID:   AF643G
New Number of Employees: 16
*/

Esempio: inizializzazione static

Questo esempio mostra che è possibile inizializzare un campo static usando un altro campo static non ancora dichiarato. I risultati non verranno definiti fino a quando non si assegna in modo esplicito un valore al campo static.

class Test
{
    static int x = y;
    static int y = 5;

    static void Main()
    {
        Console.WriteLine(Test.x);
        Console.WriteLine(Test.y);

        Test.x = 99;
        Console.WriteLine(Test.x);
    }
}
/*
Output:
    0
    5
    99
*/

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