Static in C# for Former VB developers

One of the biggest problems classic VB developers migrating to .NET and C# face is understanding STATIC. Static constructors, static data, static member functions, static properties.

To a  classic VB developer, "static" meant a variable inside a function (method) whose value remains "live" between function calls, but which is invisible outside the function. In C#, there is no such concept, because it's not necessary when you can define member fields instead.

Let's run through the concept of STATIC and explore its major uses.

In C#, whenever you declare a variable which is bound to an instance (object) of a class, your variable by default gets its own copy of all the fields in the class. So for example, if you write:

CreditCardAccountPremium cp1 = new CreditCardAccountPremium();
CreditCardAccountPremium cp2 = new CreditCardAccountPremium();
cp1.setFirstName("George");
cp2.setFirstName("Harry");

The instances cp1 and cp2 each contain their own string called FirstName. Changing the FirstName in cp2 has no effect on the value of the FirstName in cp1. However, there are some cases where you do not want this behavior. Maybe you would like to set a maximum value for a CashAdvance that is common to the entire CreditCardAccountPremium class. This would be universally applied to all instances of CreditCardAccountPremium.

We really want the "maxCashAdvance" to be stored in memory only once, no matter how many instances of the class we instantiate. To do this, we place the keyword static before the field declaration:
public class CreditCardAccountPremium
{
      private static uint maxCashAdvance = 300;
      private string FirstName;
      private string LastName;
      ....

Fields declared with the static keyword are referred to as static fields or static data., while the other fields like FirstName are called instance fields. So an instance field belongs to an object, and a static field belongs to the class as a whole. Static fields exist from the moment the assembly containing the class is loaded, and are initialized by the runtime, independent of whether you actually declare any instances of the class. Consequently, we can also have static constructors, which serve no other purpose than to assign initial values to static data:

public class CreditCardAccountSuper
{
     private static uint maxCashAdvance;
    staticCreditCardAccountSuper()
       {
           maxCashAdvance = 300;
       }

If you were to invoke a CreditCardAccountSuper.maxCashAdvance property, there is no need to assign an initial value within the Main() method; the static constructor does this automatically. Note that the static constructor in which the maxCashAdvance default value is set has the same name as the class, and cannot take any arguments.

Just as is the case with fields, you can declare methods as static provided they don't try to access instance data or any other instance methods. You might want to provide a method to allow users of the class to view the maxCashAdvance value:

public class CreditCardAccountPremium
{
      private static uint maxCashAdvance = 300;
      private string FirstName;
      private string LastName;
public static uint GetMaxCashAdvance()
     {
       return maxCashAdvance;
     }  

You access static methods and fields associated with a class differently that you access them as objects (instances of a class). Instead of specifying the name of the instance to access the method (cp1.GetMaxCashAdvance) you will specify the name of the class: CreditCardAccountPremium.GetMaxCashAdvance(). The static modifier can be used with fields, methods, properties, operators, and constructors, but cannot be used with indexers, destructors, or types.   C# trashes the whole concept of global functions, variables, and constants. Instead, you can create static class members, making your C# code not only easier to read, but less likely to cause naming and other conflicts.

Static Classes

A class can be marked static, indicating that it must be composed solely of static members and cannot be subclassed. The System.Console and System.Math classes are good examples of static classes.  Debug and Trace are static classes that provide basic logging and assertion capabilities.

Static constructors and field initialization order

Static field initializers run just before the static constructor is called. If a type has no static constructor, field initializers will execute just prior to the type being used— or anytime earlier at the whim of the runtime. (This means that the presence of a static constructor may cause field initializers to execute later in the program than they would otherwise.)

I hope this all didn't give you too much static.