estática (referência C#)

Esta página cobre a static palavra-chave do modificador. A static palavra-chave também faz parte da using static diretiva.

Utilize o static modificador para declarar um membro estático, que pertence ao tipo em si e não a um objeto específico. O static modificador pode ser usado para declarar static aulas. Nas classes, interfaces e estruturas, pode adicionar o static modificador a campos, métodos, propriedades, operadores, eventos e construtores. O static modificador não pode ser usado com indexadores ou finalizadores. Para obter mais informações, consulte Classes Estáticas e Membros da Classe Estática.

Começando por C# 8.0, pode adicionar o static modificador a uma função local. Uma função local estática não pode capturar variáveis locais ou estado de instância.

Começando por C# 9.0, pode adicionar o static modificador a uma expressão lambda ou a um método anónimo. Um lambda estático ou um método anónimo não consegue capturar variáveis locais ou estado de exemplo.

Exemplo - classe estática

A seguinte classe é declarada como static e contém apenas static métodos:

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

Uma declaração constante ou tipo é implicitamente um static membro. Um static membro não pode ser referenciado através de um caso. Em vez disso, é referenciado através do nome tipo. Por exemplo, considere a seguinte classe:

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

Para se referir ao static membro x, utilize o nome totalmente qualificado, MyBaseC.MyStruct.xa menos que o membro esteja acessível a partir do mesmo âmbito:

Console.WriteLine(MyBaseC.MyStruct.x);

Enquanto um exemplo de uma classe contém uma cópia separada de todos os campos de instância da classe, há apenas uma cópia de cada static campo.

Não é possível usar this métodos de referência static ou acessórios de propriedade.

Se a static palavra-chave for aplicada a uma classe, todos os membros da classe devem estar static.

Classes, interfaces e static aulas podem ter static construtores. Um static construtor é chamado em algum momento entre quando o programa começa e a classe é instantânea.

Nota

A static palavra-chave tem utilizações mais limitadas do que em C++. Para comparar com a palavra-chave C++, consulte Armazenamento classes (C++).

Para demonstrar os static membros, considere uma classe que represente um funcionário da empresa. Assuma que a classe contém um método para contar funcionários e um campo para armazenar o número de funcionários. Tanto o método como o campo não pertencem a nenhum dos empregados. Em vez disso, pertencem à classe de empregados como um todo. Devem ser declarados como static membros da classe.

Exemplo - campo estático e método

Este exemplo lê o nome e identificação de um novo funcionário, incrementa o balcão de um dos colaboradores e exibe a informação para o novo colaborador e o novo número de colaboradores. Este programa lê o número atual de funcionários do teclado.

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

Exemplo - inicialização estática

Este exemplo mostra que é possível inicializar um static campo utilizando outro static campo que ainda não foi declarado. Os resultados ficarão indefinidos até atribuir explicitamente um valor ao 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
*/

Especificação linguística C#

Para mais informações, consulte a Especificação de Idioma C. A especificação linguística é a fonte definitiva para a sintaxe e utilização C#.

Ver também