Classes estáticas e membros de classe estáticos (guia de programação C#)

Artigo
08/25/2010

A estático clsistema autônomos é o mesmo bsistema autônomoically sistema autônomo clsistema autônomos um não-estáticos, mas há uma diferença: um estático classe não pode ser instanciada.Em outras palavras, você não pode usar o novo palavra-chave para criar uma variável do tipo de classe.Porque não há nenhuma variável de instância, você acesso os membros de uma classe estática, usando a classe de nome próprio.Por exemplo, se você tiver um clsistema autônomos estático chamado UtilityClass Essa h sistema autônomo um método público chamado MethodA, você chama o método sistema autônomo mostrado no exemplo a seguir:

UtilityClass.MethodA();

Assim sistema autônomo acontece com classe de todos sistema autônomo tipos de informações de tipo para um estático classe é carregada pelo .NET Framework Common linguagem tempo de execução (CLR) quando o programa que faz referência à classe é carregado. O programa não é possível especificar exatamente quando a classe é carregada. No entanto, é garantido para ser carregado e ter seus campos inicializados e seu construtor estático chamado antes que a classe é referenciada pela primeira vez no seu programa.Um construtor estático é chamado somente uma vez e uma classe estática permanece na memória durante o time de vida do domínio do aplicativo no qual o programa reside.

A estático classe pode ser usada sistema autônomo um contêiner conveniente para conjuntos de métodos que operam em parâmetros de entrada e não precisará obter ou conjunto sistema autônomo campos de instância interno apenas.Por exemplo, na biblioteca de classes do .NET estrutura, a estáticoSystem.Math classe contém vários métodos que executam operações matemáticas, sem qualquer necessidade de armazenar ou recuperar dados que seja único para uma instância específica da Math classe.

Observação:
T o crie uma classe não-estático que permite que apenas uma instância de si mesmo para ser criado, consulte Implementando singleton em translation from VPE for Csharp.

A lista a seguir fornece os principais recursos de um estático classe:

Contém apenas membros estático.
Não é possível criar uma instância.
É sealed.
Não pode conter Construtores de instância.

Criando uma classe estática é, portanto, basicamente o mesmo que criar uma classe que contém apenas membros estático e um construtor particular.Um construtor particular impede que a classe seja instanciado.A vantagem de usar um estático classe é que o compilador pode verificar para certificar-se de que nenhum membro de instância acidentalmente sejam adicionado.O compilador garante que as instâncias dessa classe não podem ser criadas.

estático classes são seladas e, portanto, não podem ser herdadas.Eles não podem herdar de qualquer classe, exceto Object. Classes static não podem conter um construtor de instância; no entanto, elas podem conter um construtor estático.Classes não-estático também devem definir um construtor estático se a classe contém membros estáticos requerem inicialização não-comum.Para obter mais informações, consulte Construtores estático (guia de programação translation from VPE for Csharp).

Exemplo

Eis um exemplo de uma classe estática que contém dois métodos converter a temperatura de Celsius em Fahrenheit e de Fahrenheit para Celsius:

public static class TemperatureConverter
{
    public static double CelsiusToFahrenheit(string temperatureCelsius)
    {
        // Convert argument to double for calculations.
        double celsius = Double.Parse(temperatureCelsius);

        // Convert Celsius to Fahrenheit.
        double fahrenheit = (celsius * 9 / 5) + 32;

        return fahrenheit;
    }

    public static double FahrenheitToCelsius(string temperatureFahrenheit)
    {
        // Convert argument to double for calculations.
        double fahrenheit = Double.Parse(temperatureFahrenheit);

        // Convert Fahrenheit to Celsius.
        double celsius = (fahrenheit - 32) * 5 / 9;

        return celsius;
    }
}

class TestTemperatureConverter
{
    static void Main()
    {
        Console.WriteLine("Please select the convertor direction");
        Console.WriteLine("1. From Celsius to Fahrenheit.");
        Console.WriteLine("2. From Fahrenheit to Celsius.");
        Console.Write(":");

        string selection = Console.ReadLine();
        double F, C = 0;

        switch (selection)
        {
            case "1":
                Console.Write("Please enter the Celsius temperature: ");
                F = TemperatureConverter.CelsiusToFahrenheit(Console.ReadLine());
                Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
                break;

            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine());
                Console.WriteLine("Temperature in Celsius: {0:F2}", C);
                break;

            default:
                Console.WriteLine("Please select a convertor.");
                break;
        }

        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
/* Example Output:
    Please select the convertor direction
    1. From Celsius to Fahrenheit.
    2. From Fahrenheit to Celsius.
    :2
    Please enter the Fahrenheit temperature: 20
    Temperature in Celsius: -6.67
    Press any key to exit.
 */

Membros estático

Uma classe não-estático pode conter métodos estático, campos, propriedades ou eventos.O membro estático é que pode ser chamado em uma classe, mesmo quando nenhuma instância da classe foi criada.O membro estático sempre é acessado pelo nome de classe, não o nome da instância.Existe apenas uma cópia de um membro estático, independentemente de quantas ocorrências da classe são criadas.Propriedades e métodos estático não é possível acessar non-estático campos e eventos em seu tipo recipiente e eles não podem acessar uma variável da ocorrência de qualquer objeto, a menos que explicitamente é passado um parâmetro do método.

É mais comum declarar uma classe non-static com alguns membros estáticos que para declarar uma classe inteira sistema autônomo estático.Dois usos comuns dos campos estático são para manter uma contagem do número de objetos que tenham sido instanciado ou armazenar um valor que deve ser compartilhado entre todas as instâncias.

Métodos estático podem ser sobrecarregados, mas não substituídos, porque eles pertencem à classe e não para qualquer instância da classe.

Embora um campo não pode ser declarado sistema autônomo static const, um Const campo é essencialmente estático em seu comportamento.Ele pertence ao tipo, não às instâncias do tipo.Portanto, const campos podem ser acessados por usando o mesmo ClassName.MemberName notação usada para campos estático. Nenhuma instância do objeto é necessária.

Não oferece suporte a translation from VPE for Csharp estático variáveis locais (variáveis são declaradas no escopo do método).

Você declara estático membros de classe usando o static palavra-chave antes do tipo de retorno do membro, sistema autônomo mostrado no exemplo a seguir:

public class Automobile
{
    public static int NumberOfWheels = 4;
    public static int SizeOfGasTank
    {
        get
        {
            return 15;
        }
    }
    public static void Drive() { }
    public static event EventType RunOutOfGas;

    // Other non-static fields and properties...
}

Membros estáticos são inicializados antes que o membro estático é acessado pela primeira time e antes do construtor estático, se houver um, é chamado.Para acessar um estático membro da classe, usar o nome da classe em vez de um nome de variável para especificar o local do membro, sistema autônomo mostrado no exemplo a seguir:

Automobile.Drive();
int i = Automobile.NumberOfWheels;

Se sua classe contiver campos estáticos, fornece um construtor estático que inicializa-as quando a classe é carregada.

Uma telefonar para um método estático gera uma instrução de telefonar na Microsoft intermediate linguagem (MSIL), enquanto uma telefonar para um método de instância gera um callvirt instrução também verifica para faz referência a um objeto nulo. No entanto, na maioria das vezes a diferença de desempenho entre os dois não é significativa.