Condividi tramite

static (Riferimenti per C#)

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

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

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

class Calc1
{
    public void CalculateSum()
    {
        int a = 3;
        int b = 7;

        // Static local function - cannot access 'a' or 'b' directly
        static int Add(int x, int y)
        {
            return x + y;
        }

        int result = Add(a, b); 
        Console.WriteLine($"Sum: {result}");
    }
}
  /*
 Output:
 Sum: 10
 */

È possibile aggiungere il modificatore a un'espressione staticlambda o a un metodo anonimo. Un metodo lambda statico o anonimo non può acquisire variabili locali o stato dell'istanza.

class Calc2
{
    static void Main()
    {
        Func<int, int, int> add = static (a, b) => a + b;

        int result = add(5, 10);
        Console.WriteLine($"Sum: {result}");
    }
}
/*
Output:
Sum: 15
*/

Esempio : classe statica

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

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

Una dichiarazione costante o di tipo è implicitamente un static membro. Non è possibile fare riferimento a un membro static tramite un'istanza. Viene invece fatto 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 static membro x, usare il nome completo, , MyBaseC.MyStruct.xa meno che il membro non sia accessibile dallo stesso ambito:

Console.WriteLine(MyBaseC.MyStruct.x);

Mentre un'istanza di una classe contiene una copia separata di tutti i campi dell'istanza della classe, è presente una sola copia di ogni static campo. Per i tipi generici, ogni tipo generico chiuso ha una propria copia di campi statici. I campi statici contrassegnati con ThreadStaticAttribute hanno una copia per ogni thread.

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

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

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

Annotazioni

La static parola chiave ha usi più limitati rispetto a C++. Per confrontare con la parola chiave C++, vedere Classi di archiviazione (C++).

Per illustrare static i membri, prendere in considerazione una classe che rappresenta un dipendente aziendale. Si supponga che la classe contenga un metodo per contare i dipendenti e un campo per archiviare il numero di dipendenti. Sia il metodo che il campo non appartengono a un'istanza di un dipendente. Al contrario, appartengono alla classe di dipendenti nel suo complesso. Devono essere dichiarati come static membri della classe .

Esempio : campo statico e metodo

Questo esempio legge il nome e l'ID di un nuovo dipendente, incrementa il contatore dei dipendenti di uno e visualizza 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 statica

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

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
*/

Specificazione 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#.

Vedere anche

  • Last updated on