Classe estática, método, construtor, campo em C#

Estático em C#, não pode ser instanciado. Você não pode criar objetos de classes estáticas, nem usar objetos para acessar membros estáticos.

Classe, variável, método, propriedade, operador, evento e construtor podem ser definidos como estáticos usando a palavra-chave de modificador estático.

Classe estática

public static class Calculator
{
　　　　private static int _resultStorage = 0;
　　　　
　　　　public static string Type = "Arithmetic";
　　　　public static int Sum(int num1, int num2)
　　　　{
　　　　　　　　return num1　+　num2;
　　　　}
　　　　public static void Store(int result)
　　　　{
　　　　　　　　_resultStorage = result;
　　　　}
}

A classe Calculator acima é estática. Todos seus membros também são estáticos.

Você não pode criar objetos de classes estáticas. Portanto, você pode acessar os membros da classe estática diretamente usando o nome da classe ClassName.MemberName, conforme mostrado a seguir.

class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　var result = Calculator.Sum(10,　25);　//Chamar método estático
　　　　　　　　Calculator.Store(result);　
　　　　　　　　var calcType = Calculator.Type;　//　Acessar variável estática
　　　　　　　　Calculator.Type = "Scientific";　//　Atribuir valores a variáveis estáticas
　　　　}
}

Regras de classes estáticas

1. Classes estáticas não podem ser instanciadas.

2. Todos os membros de uma classe estática devem ser estáticos. Caso contrário, o compilador emitirá um erro.

3. Classes estáticas podem conter variáveis estáticas, métodos estáticos, propriedades estáticas, operadores estáticos, eventos estáticos e construtores estáticos.

4. Classes estáticas não podem conter membros de instância e construtores.

5. Indexadores e destrutores não podem ser estáticos

6. var não pode ser usado para definir membros estáticos. Você deve especificar explicitamente o tipo do membro após a palavra-chave static.

7. Classes estáticas são classes seladas, portanto, não podem ser herdadas.

8. Classes estáticas não podem herdar de outras classes.

9. Você pode acessar membros da classe estática usando ClassName.MemberName (ou seja: nomeDaClasse.nomeDoMembro).

10. Classes estáticas ficam na memória durante toda a vida útil do domínio de aplicativo onde o programa está executando.

Membros estáticos em classes não estáticas

Classe comum (classe não estática) pode conter um ou mais métodos estáticos, campos, propriedades, eventos e outros membros não estáticos.

Usar alguns membros estáticos para definir uma classe não estática, em vez de declarar toda a classe como estática, é mais prático.

Campos estáticos

Você pode usar a palavra-chave static para definir campos estáticos em uma classe não estática.

Os campos estáticos de uma classe não estática são compartilhados entre todas as instâncias. Portanto, as alterações feitas por uma instância refletirão em outras instâncias.

public class StopWatch
{
　　　　public static int InstanceCounter = 0;
　　　　//　Construtor de instância
　　　　public StopWatch()
　　　　{
　　　　}
}
class Program
{
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　StopWatch sw1　= new StopWatch();
　　　　　　　　StopWatch sw2　= new StopWatch();
　　　　　　　　Console.WriteLine(StopWatch.NoOfInstances);　//2　
　　　　　　　　StopWatch sw3　= new StopWatch();
　　　　　　　　StopWatch sw4　= new StopWatch();
　　　　　　　　Console.WriteLine(StopWatch.NoOfInstances);//4
　　　　}
}

Método estático

Você pode definir um ou mais métodos estáticos em uma classe não estática. Você pode chamar métodos estáticos sem criar um objeto. Você não pode usar um objeto de classe não estática para chamar métodos estáticos.

Métodos estáticos podem chamar outros métodos estáticos e acessar membros estáticos. Você não pode acessar membros não estáticos da classe em métodos estáticos.

class Program
{
　　　　static int counter = 0;
　　　　string name = "Demo Program";
　　　　static void Main(string[] args)
　　　　{
　　　　　　　　counter++;　//　Membros estáticos podem ser acessados
　　　　　　　　Display("Hello World!");　//　Métodos estáticos podem ser chamados
　　　　　　　　name = "New Demo Program";　//Erro: Não é possível acessar membros não estáticos
　　　　　　　　SetRootFolder("C:\MyProgram");　//Erro: Não é possível chamar métodos não estáticos
　　　　}
　　　　static void Display(string text)
　　　　{
　　　　　　　　Console.WriteLine(text);
　　　　}
　　　　public void SetRootFolder(string path) { }
}

Regras do método estático

1. Métodos estáticos podem ser definidos usando a palavra-chave static antes do tipo de retorno, seguido dos modificadores de acesso.

2. Métodos estáticos podem ser sobrecarregados, mas não podem ser sobrescritos.

3. Métodos estáticos podem conter variáveis locais estáticas.

4. Métodos estáticos não podem acessar ou chamar variáveis não estáticas, a menos que sejam explicitamente passadas como parâmetros.

Construtor estático

Classe não estática pode conter construtor estático sem parâmetros. Pode ser definido usando a palavra-chave static, sem modificadores de acesso, como public, private e protected.

O exemplo a seguir demonstra a diferença entre o construtor estático e o construtor de instância.

public class StopWatch
{
　　　　//　Construtor estático
　　　　static StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("Chamou o construtor estático");
　　　　}
　　　　//　Construtor de instância
　　　　public StopWatch()
　　　　{
　　　　　　　　Console.WriteLine("Chamou o construtor de instância");
　　　　}
　　　　//　Método estático
　　　　public static void DisplayInfo()
　　　　{
　　　　　　　　Console.WriteLine("Chamou DisplayInfo");
　　　　}
　　　　//　Método de instância
　　　　public void Start() { }
　　　　//　Método de instância
　　　　public void Stop() { }
}

O classe não estática StopWatch contém um construtor estático, bem como um construtor não estático.

Cada vez que usar um método estático ou criar a instância pela primeira vez, o construtor estático é chamado apenas uma vez. O exemplo a seguir mostra que ao chamar o método static pela primeira vez, o construtor static será chamado. Ao chamar o método static novamente, o construtor estático não será chamado.

StopWatch.DisplayInfo();　//　Aqui é chamado o construtor estático
StopWatch.DisplayInfo();　//　Aqui não foi chamado o construtor

O construtor estático foi chamado
Chamou DisplayInfo
Chamou DisplayInfo

O exemplo a seguir mostra que ao criar a instância pela primeira vez, o construtor estático será chamado.

StopWatch sw1　= new StopWatch();　//　Primeiro é o construtor estático, então o construtor de instância　
StopWatch sw2　= new StopWatch();//　Apenas o construtor de instância foi chamado　
StopWatch.DisplayInfo();

Chamou o construtor estático
Chamou o construtor de instância
Chamou o construtor de instância
Chamou DisplayInfo

Regras do construtor estático

1. O construtor estático é definido usando a palavra-chave static, sem usar modificadores de acesso public, private ou protected.

2. Classe não estática pode conter um construtor estático sem parâmetros. Não é permitido usar construtores estáticos parametrizados.

3. O construtor estático será executado apenas uma vez durante a vida útil. Portanto, se um classe for usada em vários lugares, não é possível determinar quando será chamado no aplicativo.

4. O construtor estático pode acessar apenas membros estáticos. Ele não pode conter ou acessar membros de instância.

Membros estáticos são armazenados em uma área especial da memória chamada 'heap de alta frequência'. Os membros estáticos de classes não estáticas são compartilhados entre todas as instâncias da classe. Portanto, as alterações feitas em uma instância refletirão em todas as outras instâncias.