What is the use of static variable in C#? When to use it? Why can't I declare the static variable inside method?

Question

I have searched about static variables in C#, but I am still not getting what its use is. Also, if I try to declare the variable inside the method it will not give me the permission to do this. Why?

I have seen some examples about the static variables. I've seen that we don't need to create an instance of the class to access the variable, but that is not enough to understand what its use is and when to use it.

Second thing

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

Superphysical

May be you mean "static field"? – Apparitor

Like we declare in class static int i=5 – Superphysical

VB.NET supports local static variables. They had to implement it to stay compatible with vb. The amount of code it generates is enormous, local statics are difficult because they are not thread-safe. Fields are not thread-safe either, but everybody expects that. – Elbowroom

dont forget to mark answer as accepted if you got the info you want... – Josephson

You can access static variables/methods through the type (in this case Book) no through an instance (book), so the easier solution is Book.myInt. – Manufactory

Answer 1

A static variable shares the value of it among all instances of the class.

Example without declaring it static:

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


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

Explanation: If you look at the above example, I just declare the int variable. When I run this code the output will be 10 and 10. Its simple.

Now let's look at the static variable here; I am declaring the variable as a static.

Example with static variable:

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


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

Now when I run above code, the output will be 10 and 15. So the static variable value is shared among all instances of that class.

Superphysical

@Pranay:Yes thats better but if you show me example that i show above than it cound be better for me and others....anyway good effort.... – Superphysical

It is static to the class, i.e its value remains faithful to the class with its value stored in its... wait for it... class – Zumwalt

You say a static variable is shared among all instances of the class... but what if there are no instances? Can you still set a variable? Is it allowed to store dynamic data in a static class? – Foreman

@Kokodoko, even if there is no instance, you surely can set the variable. That defines its static nature – Spermatocyte

Answer 2

C# doesn't support static local variables (that is, variables that are declared in method scope).

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-classes-and-static-class-members#static-members

You can declare static fields (class members) though.

Reasoning: Static field is a state, shared with all instances of particular type. Hence, the scope of the static field is entire type. That's why you can't declare static instance variable (within a method) - method is a scope itself, and items declared in a method must be inaccessible over the method's border.

Apparitor

Well, in documentation it is stated as "A field declared with the static modifier is called a static variable." msdn.microsoft.com/en-us/library/aa691162(v=vs.71).aspx But you are right on rest of the explanation. – Tannen

@Teomanshipahi updated link: learn.microsoft.com/en-us/dotnet/csharp/language-reference/… : (the link has difference between static and instance variable) – Plumage

In languages in which they are supported, static local variables mean that the variables lifetime is the entire run of a program. And there are languages which support both static local variables and static fields, e.g. C++ or PHP. – Unweighed

Answer 3

static variables are used when only one copy of the variable is required. so if you declare variable inside the method there is no use of such variable it's become local to function only..

example of static is

class myclass
{
    public static int a = 0;
}

Variables declared static are commonly shared across all instances of a class.

Variables declared static are commonly shared across all instances of a class. When you create multiple instances of VariableTest class This variable permanent is shared across all of them. Thus, at any given point of time, there will be only one string value contained in the permanent variable.

Since there is only one copy of the variable available for all instances, the code this.permament will result in compilation errors because it can be recalled that this.variablename refers to the instance variable name. Thus, static variables are to be accessed directly, as indicated in the code.

Josephson

can you please explain with example? – Superphysical

but if i make the instance of a class then i am not able to access static variable.why?I can access the static variable by classname.variable only not by making the instance of a class................ – Superphysical

@Kartik Patel because you have to use the class name to access the static myInt. Why it like this, i don't know. But i would say that it is much clearer because you want to access a static part of the class, it is not static if you need an instance to access it. – Loaves

@dowhilefor:But as you mentioned above that "Variables declared static are commonly shared across all instances of a class." then what is the meaning of this? – Superphysical

@Kartik Patel you can't access the variable from the outside with an instance, but you can always use the static variable inside your class and then it is shared accross all instances. Also it was not me who gave this answer, i'm just commenting on it. – Loaves

@dorwhilefor:sorry i just see that you just commenting on it havent answered.but can you Please show me the example of it? – Superphysical

Answer 4

Some "real world" examples for static variables:

building a class where you can reach hardcoded values for your application. Similar to an enumeration, but with more flexibility on the datatype.

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

The widely known singleton, this allows to control to have exactly one instance of a class. This is very useful if you want access to it in your whole application, but not pass it to every class just to allow this class to use it.

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

        private static TextureManager sInstance = new TextureManager();

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

and this is how you would call the texturemanager

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

About your last question: You are refering to compiler error CS0176. I tried to find more infor about that, but could only find what the msdn had to say about it:

A static method, field, property, or event is callable on a class even when no instance of the class has been created. If any instances of the class are created, they cannot be used to access the static member. Only one copy of static fields and events exists, and static methods and properties can only access static fields and static events.

Loaves

Answer 5

Static variables are used when only one copy of it is required. Let me explain this with an example:

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

Now here we have created 2 instances for our class circle , i.e 2 sets of copies of _PI along with other variables are created. So say if we have lots of instances of this class multiple copies of _PI will be created occupying memory. So in such cases it is better to make such variables like _PI static and operate on them.

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

Now no matter how many instances are made for the class circle , only one copy exists of variable _PI saving our memory.

Thighbone

And you can add readonly to _PI variable so that no instance can change its value. – Mosa

How can we check what is the real memory amount saved? This is just for my own sake of curiosity to verify what will be the real amount saved. Float is 4 bytes, so if I have 25 objects then it will be 100 bytes without static keyword? And with the static keyword I will have only 4 bytes? – Chasechaser

Answer 6

Static classes don't require you to create an object of that class/instantiate them, you can prefix the C# keyword static in front of the class name, to make it static.

Remember: we're not instantiating the Console class, String class, Array Class.

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

    }
}

Hiltan

very good observation because if you try to use object to access the value of property myInt the you will get an error : static void Main() { Book book = new Book(); // this give you error : book.myInt =5 ; – Ganiats

Answer 7

In response to the "when to use it?" question:

I often use a static (class) variable to assign a unique instance ID to every instance of a class. I use the same code in every class, it is very simple:

//Instance ID ----------------------------------------
    // Class variable holding the last assigned IID
    private static int xID = 0;
    // Lock to make threadsafe (can omit if single-threaded)
    private static object xIDLock = new object();
    // Private class method to return the next unique IID 
    //  - accessible only to instances of the class
    private static int NextIID()                    
    {
        lock (xIDLock) { return ++xID; }
    }
    // Public class method to report the last IID used 
    // (i.e. the number of instances created)
    public static int LastIID() { return xID; }
    // Instance readonly property containing the unique instance ID
    public readonly int IID = NextIID();
//-----------------------------------------------------

This illustrates a couple of points about static variables and methods:

1. Static variables and methods are associated with the class, not any specific instance of the class.
2. A static method can be called in the constructor of an instance - in this case, the static method NextIID is used to initialize the readonly property IID, which is the unique ID for this instance.

I find this useful because I develop applications in which swarms of objects are used and it is good to be able to track how many have been created, and to track/query individual instances.

I also use class variables to track things like totals and averages of properties of the instances which can be reported in real time. I think the class is a good place to keep summary information about all the instances of the class.

Sexagesima

Answer 8

The data members and function members that operate on the instance of the type are called instance members. The int’s ToString method (for example) are examples of instance members. By default, members are instance members. Data members and function members that don’t operate on the instance of the type, but rather on the type itself, must be marked as static. The Test.Main and Console.WriteLine methods are static methods. The Console class is actually a static class, which means all its members are static. You never actually create instances of a Console—one console is shared across the whole application.

Housel

Answer 9

Try calling it directly with class name Book.myInt

Ambrosia

exactly , see @Kunal Mukherjee example from above – Ganiats

Answer 10

On comparison with session variables, static variables will have same value for all users considering i am using an application that is deployed in server. If two users accessing the same page of an application then the static variable will hold the latest value and the same value will be supplied to both the users unlike session variables that is different for each user. So, if you want something common and same for all users including the values that are supposed to be used along the application code then only use static.

Kriskrischer

Answer 11

You don't need to instantiate an object, because yau are going to use a static variable: Console.WriteLine(Book.myInt);

Freezedry

Answer 12

Static variable retains it's previous value until the program exit. Static is used by calling directly class_Name.Method() or class_Name.Property. No object reference is needed. The most popular use of static is C#'s Math class. Math.Sin(), Math.Cos(), Math.Sqrt().

Rarefaction