estático (Referência C#)

  • Artigo

Esta página abrange a static palavra-chave modificadora. A static palavra-chave também faz parte da using static diretiva.

Use o static modificador para declarar um membro estático, que pertence ao próprio tipo em vez de a um objeto específico. O static modificador pode ser usado para declarar static classes. Em classes, interfaces e structs, você 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 de classes estáticas.

Você pode adicionar o static modificador a uma função local. Uma função local estática não pode capturar variáveis locais ou o estado da instância.

Você pode adicionar o static modificador a uma expressão lambda ou método anônimo. Um lambda estático ou um método anônimo não pode capturar variáveis locais ou o estado da instância.

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 de tipo é implicitamente um static membro. Um static membro não pode ser referenciado através de uma instância. Em vez disso, ele é referenciado através do nome do 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, use o nome totalmente qualificado, MyBaseC.MyStruct.xa menos que o membro seja acessível a partir do mesmo escopo:

Console.WriteLine(MyBaseC.MyStruct.x);

Embora uma instância de uma classe contenha 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 para referenciar static métodos ou acessadores de propriedade.

Se a static palavra-chave for aplicada a uma classe, todos os membros da classe deverão ser static.

Classes, interfaces e static classes podem ter static construtores. Um static construtor é chamado em algum ponto entre quando o programa é iniciado e a classe é instanciada.

Nota

A static palavra-chave tem usos mais limitados do que em C++. Para comparar com a palavra-chave C++, consulte Classes de armazenamento (C++).

Para demonstrar static membros, considere uma classe que represente um funcionário da empresa. Suponha 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 quanto o campo não pertencem a nenhuma instância de funcionário. Em vez disso, pertencem à classe dos empregados como um todo. Eles devem ser declarados como static membros da classe.

Exemplo - campo estático e método

Este exemplo lê o nome e a ID de um novo funcionário, incrementa o contador de funcionários em um e exibe as informações do novo funcionário e o novo número de funcionários. Este programa lê o número atual de funcionários a partir 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 você pode inicializar um static campo usando outro static campo que ainda não está declarado. Os resultados serão indefinidos até que você atribua 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 da linguagem C#

Para obter mais informações, consulte a Especificação da linguagem C#. A especificação da linguagem é a fonte definitiva para a sintaxe e o uso do C#.

Consulte também