What is the meaning of static in differents parts of the code?

Question

I have been learning C# for two weeks now, though it is not my first either second language. I have been wondering about the static word. I know I should have researched about this word long before...but this is the first time I realized how much confusing this word is for me. For what I have read:

A static class is a class which does not need to be instanciated to be used ( Class with single method -- best approach? ). This may have some advantages and some disadvanatges regarding testing, polymorphism etc.

But the static word can be applied also to classes, fields, methods, properties, operators, events and constructors !!! ( https://msdn.microsoft.com/en-us/library/98f28cdx%28v=vs.80%29.aspx ). Example:

Property:

private static string s  = "";

Method:

public static void helperMethod() {
        Console.WriteLine("Whatever");
    }

Does the word static have a global meaning or employed in differents parts of the code the meaning can change?

Answer 1

class modifier

When static is applied to a class it indicates four attributes.

• Contains only static members.
• Cannot be instantiated.
• Is sealed.
• Cannot contain Instance Constructors.

---

property or function modifier (and events and methods)

When applied to properties and functions, e.g.

public Thing
{
    static int SharedCount { get; set; }

    static string GenerateName()
    {
        // ...
    }
}

it means that the properties and functions will be accessible via the type name, without instantiating the class. This properties and functions will not be accessible via an instance of the class. So, both

var i = Thing.SharedCount;
var s = Thing.GenerateName();

Are valid and correct statements, Where as

var i = new Thing().SharedCount;
var s = this.GenerateName();

are both incorrect.

Code in functions and properties declared with the static modifier cannot access non-static members of the class.

---

member variables

Member variables declared with a static modifier, e.g.

class Thing
{
    private static int sharedCount = 0;
    private static readonly IDictionary<string, int> ThingLookup =
            new Dictionary<string, int>
                    {
                        { "a", 1 },
                        { "b", 2 }
                    };
}

are shared by all static functions and properties and by all instances of the class.

---

static constructors

When applied to constructors, e.g.

class Thing
{
    static Thing()
    {
        \\ Do this once and first.
    }
}

static means the constructor will run once per AppDomain, when the type is first accessed. There are special edge cases around this.

---

operators

When an operator is overloaded for a type, this is always declared as static, e.g.

public static Thing operator +(Thing left, Thing right)
{
    // Something special to do with things.
}

It is not logical for this to be declared at an instance level since operators must apply to types.

These distinctions are explained here, here, here and here.

Answer 2

There are many concepts related to Static keyword. This answer will resolve your confusion about static.

Answer 3

In simple words , static property is not being changed across the classes , if your static member is affecting multiple classes once you change the value of it, it will be changed in every single class that is being affected by it.

Static method has to be static if you tend to use it in a static context (static class or so..)

Static class is the one which cannot be instantiated, e.g. static class Car{} this car will always have the same properties ( colour, size...)

Answer 4

Word static speaks for itself. If you have something that may change for every new object of some type - it's instance member and if it stays the same for all instances - it's static member.

From MSDN :

It is useful to think of static members as belonging to classes and instance members as belonging to objects (instances of classes).

Source : static and instance members

Static members can be accessed via class object, something like MyClass.MyMember when instance members are only accessible on instance of a class (new MyClass()).MyMember

It's obvious that compiler takes some time to create instance and only then you can access its properties. So instance members works slower than static members.

Answer 5

The static keyword means generally the same everywhere. When it is a modifier to a class, the class's members must also be marked static. When it is a modifier to a member, (fields, properties, methods, events etc.) the member can be accessed using the following syntax:

ClassName.memberName

Note that operators must be declared static and extension methods must be in a static class which means it also has to be static.

Answer 6

In C#, data members, member functions, properties and events can be declared either as static or non-static.

Only one copy of static fields and events exists, and static methods and properties can only access static fields and static events.

Static members are often used to represent data or calculations that do not change in response to object state.

Static can be used in following ways:

1. Static data members
2. Static constructor
3. Static Properties
4. Static methods

More references : MSDN

Static

Static in c#

What is static ?

Answer 7

Quick answer: No static remains the same contextually everywhere :

From dotnetperls:

These are called with the type name. No instance is required—this makes them slightly faster. Static methods can be public or private.

Info: Static methods use the static keyword, usually as the first keyword or the second keyword after public.

Warning: A static method cannot access non-static class level members. It has no this pointer.

Instance: An instance method can access those members, but must be called through an instantiated object. This adds indirection. C# program that uses instance and static methods

using System;

class Program
{
  static void MethodA()
  {
    Console.WriteLine("Static method");
  }

  void MethodB()
  {
    Console.WriteLine("Instance method");
  }

  static char MethodC()
  {
    Console.WriteLine("Static method");
    return 'C';
  }

  char MethodD()
  {
    Console.WriteLine("Instance method");
    return 'D';
  }

  static void Main()
  {
      //
      // Call the two static methods on the Program type.
      //
      Program.MethodA();
      Console.WriteLine(Program.MethodC());
      //
      // Create a new Program instance and call the two instance methods.
      //
      Program programInstance = new Program();    
      programInstance.MethodB();
      Console.WriteLine(programInstance.MethodD());
    }
 }

Output

Static method
Static method
C
Instance method
Instance method
D

Answer 8

Static members are items that are deemed to be so commonplace that there is no need to create an instance of the type when invoking the member. While any class can define static members, they are most commonly found within utility classes such as System.Console, System.Math, System.Environment, or System.GC, and so on.

Also the static keyword in C# is refering to something in the class, or the class itself, that is shared amongst all instances of the class. For example, a field that is marked as static can be accessed from all instances of that class through the class name.