Какая польза от статической переменной в C #? Когда это использовать? Почему я не могу объявить статическую переменную внутри метода?

Я искал статические переменные в C #, но до сих пор не понимаю, в чем их смысл. Кроме того, если я попытаюсь объявить переменную внутри метода, это не даст мне на это разрешения. Зачем?

Я видел несколько примеров статических переменных. Я видел, что нам не нужно создавать экземпляр класса для доступа к переменной, но этого недостаточно, чтобы понять, как он используется и когда его использовать.

Вторая вещь

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();
    }
}

staticПеременная разделяет значение его среди всех экземпляров класса.

Пример без объявления статическим:

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();
    }
}

Объяснение: Если вы посмотрите на приведенный выше пример, я просто объявляю intпеременную. Когда я запускаю этот код, на выходе будет 10и 10. Это просто.

Теперь давайте посмотрим на статическую переменную здесь; Я объявляю переменную как static.

Пример со статической переменной:

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();
    }
}

Теперь, когда я запускаю приведенный выше код, на выходе будет 10и 15. Таким образом, значение статической переменной распределяется между всеми экземплярами этого класса.

В C # вообще нет статических переменных . Вы можете объявить статическое поле в определении конкретного типа через C #. Статическое поле - это состояние, общее для всех экземпляров определенного типа. Следовательно, область статического поля - весь тип. Вот почему вы не можете объявить статическое поле внутри метода - метод сам по себе является областью действия, а элементы, объявленные в методе, должны быть недоступны за границей метода.

статические переменные используются, когда требуется только одна копия переменной. поэтому, если вы объявляете переменную внутри метода, такая переменная не используется, она становится локальной только для работы.

пример статики

class myclass
{
    public static int a = 0;
}

Переменные, объявленные статическими, обычно используются всеми экземплярами класса.

Переменные, объявленные статическими, обычно используются всеми экземплярами класса. Когда вы создаете несколько экземпляров класса VariableTest, эта постоянная переменная является общей для всех. Таким образом, в любой момент времени в постоянной переменной будет содержаться только одно строковое значение.

Поскольку для всех экземпляров доступна только одна копия переменной, код this.permament приведет к ошибкам компиляции, потому что можно вспомнить, что this.variablename относится к имени переменной экземпляра. Таким образом, статические переменные должны быть доступны напрямую, как указано в коде.

Некоторые примеры "реального мира" для статических переменных:

создание класса, в котором вы можете достичь жестко запрограммированных значений для своего приложения. Подобно перечислению, но с большей гибкостью в отношении типа данных.

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

Широко известный синглтон, это позволяет контролировать наличие только одного экземпляра класса. Это очень полезно, если вы хотите получить к нему доступ во всем приложении, но не передавать его каждому классу, чтобы этот класс мог его использовать.

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

        private static TextureManager sInstance = new TextureManager();

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

и вот как вы бы назвали менеджер текстур

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

По поводу вашего последнего вопроса: вы имеете в виду ошибку компилятора CS0176 . Я попытался найти больше информации об этом, но смог найти только то, что говорилось об этом в msdn:

Статический метод, поле, свойство или событие могут быть вызваны в классе, даже если экземпляр этого класса не был создан. Если какие-либо экземпляры класса созданы, их нельзя использовать для доступа к статическому члену. Существует только одна копия статических полей и событий, а статические методы и свойства могут обращаться только к статическим полям и статическим событиям.

Статические переменные используются, когда требуется только одна их копия. Позвольте мне объяснить это на примере:

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);
    }
}

Теперь мы создали 2 экземпляра для нашего classкруга, то есть созданы 2 набора копий _PI вместе с другими переменными. Скажем, если у нас будет много экземпляров этого класса, _PIбудет создано несколько копий , занимающих память. Поэтому в таких случаях лучше сделать такие переменные похожими _PI staticи оперировать ими.

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);
    }
}

Теперь независимо от того, сколько экземпляров сделано для classкруга, существует только одна копия переменной, _PIсохраняющая нашу память.

Статические классы не требуют, чтобы вы создавали объект этого класса / инстанциировали их, вы можете префикс ключевого слова C # static перед именем класса, чтобы сделать его статическим.

Помните: мы не создаем экземпляры класса Console, класса String, класса 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();

    }
}