Qual é o uso de variável estática em C #? Quando usar? Por que não posso declarar a variável estática dentro do método?

Eu pesquisei sobre variáveis ​​estáticas em C #, mas ainda não estou entendendo seu uso. Além disso, se eu tentar declarar a variável dentro do método, não me dará permissão para fazer isso. Por quê?

Eu vi alguns exemplos sobre as variáveis ​​estáticas. Eu vi que não precisamos criar uma instância da classe para acessar a variável, mas isso não é suficiente para entender o que é seu uso e quando usá-lo.

Segunda coisa

class Book
{
    public static int myInt = 0;
}

public class Exercise
{
    static void Main()
    {
        Book book = new Book();

        Console.WriteLine(book.myInt); // Shows error. Why does it show me error?
                                       // Can't I access the static variable 
                                       // by making the instance of a class?

        Console.ReadKey();
    }
}

Uma staticvariável compartilha seu valor entre todas as instâncias da classe.

Exemplo sem declarar estático:

public class Variable
{
    public int i = 5;
    public void test()
    {
        i = i + 5;
        Console.WriteLine(i);
    }
}


public class Exercise
{
    static void Main()
    {
        Variable var = new Variable();
        var.test();
        Variable var1 = new Variable();
        var1.test();
        Console.ReadKey();
    }
}

Explicação: Se você olhar o exemplo acima, eu apenas declaro a intvariável. Quando eu executar este código, a saída será 10e 10. É simples.

Agora, vamos examinar a variável estática aqui; Estou declarando a variável como um static.

Exemplo com variável estática:

public class Variable
{
    public static int i = 5;
    public void test()
    {
        i = i + 5;
        Console.WriteLine(i);
    }
}


public class Exercise
{
    static void Main()
    {
        Variable var = new Variable();
        var.test();
        Variable var1 = new Variable();
        var1.test();
        Console.ReadKey();
    }
}

Agora, quando eu executar o código acima, a saída será 10e 15. Portanto, o valor da variável estática é compartilhado entre todas as instâncias dessa classe.

C # não tem variáveis estáticas . Você pode declarar o campo estático na definição de tipo particular por meio de C #. O campo estático é um estado compartilhado com todas as instâncias de um tipo específico. Portanto, o escopo do campo estático é do tipo inteiro. É por isso que você não pode declarar um campo estático dentro de um método - o método é um escopo em si, e os itens declarados em um método devem ser inacessíveis além da borda do método.

variáveis ​​estáticas são usadas quando apenas uma cópia da variável é necessária. então, se você declarar a variável dentro do método, não há uso dela, ela se torna local para funcionar apenas ..

exemplo de estática é

class myclass
{
    public static int a = 0;
}

Variáveis ​​declaradas como estáticas são comumente compartilhadas por todas as instâncias de uma classe.

Variáveis ​​declaradas como estáticas são comumente compartilhadas por todas as instâncias de uma classe. Quando você cria várias instâncias da classe VariableTest, essa variável permanente é compartilhada por todas elas. Portanto, em qualquer ponto do tempo, haverá apenas um valor de string contido na variável permanente.

Como há apenas uma cópia da variável disponível para todas as instâncias, o código this.permament resultará em erros de compilação porque pode ser lembrado que this.variablename se refere ao nome da variável de instância. Assim, as variáveis ​​estáticas devem ser acessadas diretamente, conforme indicado no código.

Alguns exemplos do "mundo real" para variáveis ​​estáticas:

construir uma classe onde você pode alcançar valores codificados para seu aplicativo. Semelhante a uma enumeração, mas com mais flexibilidade no tipo de dados.

public static class Enemies
{
    public readonly static Guid Orc = new Guid("{937C145C-D432-4DE2-A08D-6AC6E7F2732C}");
}

O singleton amplamente conhecido, permite controlar para ter exatamente uma instância de uma classe. Isso é muito útil se você quiser acessá-lo em todo o seu aplicativo, mas não passá-lo para todas as classes apenas para permitir que essa classe o use.

public sealed class TextureManager
    {
        private TextureManager() {}
        public string LoadTexture(string aPath);

        private static TextureManager sInstance = new TextureManager();

        public static TextureManager Instance
        {
            get { return sInstance; }
        }
    }

e é assim que você chamaria o gerenciador de textura

TextureManager.Instance.LoadTexture("myImage.png");

Sobre sua última pergunta: você está se referindo ao erro do compilador CS0176 . Tentei encontrar mais informações sobre isso, mas só consegui descobrir o que o msdn tinha a dizer sobre isso:

Um método, campo, propriedade ou evento estático pode ser chamado em uma classe, mesmo quando nenhuma instância da classe foi criada. Se alguma instância da classe for criada, ela não poderá ser usada para acessar o membro estático. Existe apenas uma cópia de campos e eventos estáticos, e os métodos e propriedades estáticos só podem acessar campos e eventos estáticos.

Variáveis ​​estáticas são usadas quando apenas uma cópia delas é necessária. Deixe-me explicar isso com um exemplo:

class circle
{
    public float _PI =3.14F;
    public int Radius;

    public funtionArea(int radius)
    {
        return this.radius * this._PI      
    }
}
class program
{
    public static void main()
    {
        Circle c1 = new Cirle();
        float area1 = c1.functionRaduis(5);
        Circle c2 = new Cirle();
        float area2 = c1.functionRaduis(6);
    }
}

Agora aqui nós criamos 2 instâncias para nosso classcírculo, ou seja, 2 conjuntos de cópias _PI juntamente com outras variáveis ​​são criados. Portanto, digamos que se tivermos muitas instâncias dessa classe, várias cópias de _PIserão criadas ocupando a memória. Então, nesses casos, é melhor fazer com que essas variáveis ​​se pareçam _PI statice operem com elas.

class circle
{
    static float _PI =3.14F;
    public int Radius;

    public funtionArea(int radius)
    {
        return this.radius * Circle._PI      
    }
}
class program
{
    public static void main()
    {
        Circle c1 = new Cirle();
        float area1 = c1.functionRaduis(5);
        Circle c2 = new Cirle();
        float area2 = c1.functionRaduis(6);
    }
}

Agora, não importa quantas instâncias são feitas para o classcírculo, existe apenas uma cópia da variável _PIsalvando nossa memória.

Classes estáticas não exigem que você crie um objeto dessa classe / instancie-as, você pode prefixar a palavra-chave C # estática na frente do nome da classe, para torná-la estática.

Lembre-se: não estamos instanciando a classe Console, classe String, classe Array.

class Book
{
    public static int myInt = 0;
}

public class Exercise
{
    static void Main()
    {
        Book book = new Book();
       //Use the class name directly to call the property myInt, 
      //don't use the object to access the value of property myInt

        Console.WriteLine(Book.myInt);

        Console.ReadKey();

    }
}