Csharp/C Sharp/Class Interface/Static

Can call a non-static method through an object reference from within a static method

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

• /

using System; public class MyClass {

 // non-static method. 
 void nonStaticMeth() { 
    Console.WriteLine("Inside nonStaticMeth()."); 
 } 

 /* Can call a non-static method through an 
    object reference from within a static method. */ 
 public static void staticMeth(MyClass ob) { 
   ob.nonStaticMeth(); // this is OK 
 } 

}

      </source>

Demonstrates access to static and non-static members

<source lang="csharp"> /* C# Programming Tips & Techniques by Charles Wright, Kris Jamsa Publisher: Osborne/McGraw-Hill (December 28, 2001) ISBN: 0072193794

• /

// // Members.cs -- Demonstrates access to static and non-static members // // Compile this program using the following command line: // C:>csc Members.cs // namespace nsMembers {

   using System;
   
   public class StaticMembers
   {
       static public void Main ()
       {
           // Access a static member using the class name. 
           // You may access a static
           // member without creating an instance of the class
           Console.WriteLine ("The static member is pi: " + clsClass.pi);
       
           // To access a non-static member, you must create an instance 
           // of the class
           clsClass instance = new clsClass();
           // Access a static member using the name of the variable 
           // containing the
           // instance reference
           Console.WriteLine ("The instance member is e: " + instance.e);
       }
   }
   class clsClass
   {
       // Declare a static field. You also could use the const 
       // keyword instead of static
       static public double pi = 3.14159;
       // Declare a normal member, which will be created when you 
       // declare an instance
       // of the class
       public double e = 2.71828;
   }

}

      </source>

Demonstrates how a static field is shared by multiple instances of a class

<source lang="csharp"> /* C# Programming Tips & Techniques by Charles Wright, Kris Jamsa Publisher: Osborne/McGraw-Hill (December 28, 2001) ISBN: 0072193794

• /

// // Static.cs -- Demonstrates how a static field is shared by // multiple instances of a class. // // Compile this program with the following command line: // C:>csc Static.cs // namespace nsStatic {

   using System;
   
   public class clsMainStatic
   {
       static public void Main ()
       {
           for (int i = 0; i < 20; ++i)
           {
               clsStatic inst = new clsStatic();
           }
           Console.WriteLine ("Created {0} instance of clsStatic",
                              clsStatic.Count);
       }
   }
   class clsStatic
   {
       static public int Count
       {
           get {return (m_Count);}
       }
       static private int m_Count = 0;
       public clsStatic ()
       {
           ++m_Count;
       }
   }

}

      </source>

Demonstrates use of static constructor

<source lang="csharp"> /* C# Programming Tips & Techniques by Charles Wright, Kris Jamsa Publisher: Osborne/McGraw-Hill (December 28, 2001) ISBN: 0072193794

• /

// SysInfo.cs -- Demonstrates use of static constructor // // Compile this program with the following command line: // C:>csc SysInfo.cs // namespace nsSysInfo {

   using System;
   using System.Runtime.InteropServices;
   using System.Windows.Forms;
   
   public class SysInfo
   {
       static public void Main()
       {
           Console.WriteLine ("Current user is " +
                              clsSystemInfo.User);
           Console.WriteLine ("Current Time Zone is " +
                              clsSystemInfo.TZ);
           Console.WriteLine ("Current domain is " +
                              clsSystemInfo.Domain);
           Console.WriteLine ("Current Host is " +
                              clsSystemInfo.Host);
           Console.WriteLine ("Command interpreter is " + 
                              clsSystemInfo.ruSpec);
       }
   }
   class clsSystemInfo
   {
       private clsSystemInfo () {}
       [DllImport ("kernel32.dll")]
       static extern public long GetEnvironmentVariable (string name,
                                           byte [] value, long size);
       static clsSystemInfo ()
       {
           m_User = SystemInformation.UserName;
           m_Host = SystemInformation.ruputerName;
           DateTime now = DateTime.Now;
           TimeZone tz = TimeZone.CurrentTimeZone;
           m_TimeZone = tz.IsDaylightSavingTime(now)
                        ? tz.DaylightName : tz.StandardName;
           m_Domain = SystemInformation.UserDomainName;
           byte [] comspec = new byte [256];
           if (GetEnvironmentVariable ("COMSPEC", comspec, 256) > 0)
           {
               foreach (byte ch in comspec)
               {
                   if (ch == 0)
                       break;
                   m_ComSpec += (char) ch;
               }
           }
       }
       static public string User
       {
           get
           {
               return (m_User);
           }
       }
       static public string TZ
       {
           get
           {
               return (m_TimeZone);
           }
       }
       static public string Domain
       {
           get
           {
               return (m_Domain);
           }
       }
       static public string Host
       {
           get
           {
               return (m_Host);
           }
       }
       static public string ComSpec
       {
           get
           {
               return (m_ComSpec);
           }
       }
       private static string m_User;
       private static string m_TimeZone;
       private static string m_Domain;
       private static string m_Host;
       private static string m_ComSpec;
   }

}

      </source>

Error using static

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

• /

using System;

public class AnotherStaticError {

 // non-static method. 
 void nonStaticMeth() { 
    Console.WriteLine("Inside nonStaticMeth()."); 
 } 

 /* Error! Can"t directly call a non-static method 
    from within a static method. */ 
 static void staticMeth() { 
   nonStaticMeth(); // won"t compile 
 } 

}

      </source>

Illustrates the use of static members

<source lang="csharp"> /* Mastering Visual C# .NET by Jason Price, Mike Gunderloy Publisher: Sybex; ISBN: 0782129110

• /

/*

 Example6_1.cs illustrates the use of static members

• /

// declare the Car class class Car {

 // declare a static field,
 // numberOfCars stores the number of Car objects
 private static int numberOfCars = 0;
 // define the constructor
 public Car()
 {
   System.Console.WriteLine("Creating a Car object");
   numberOfCars++;  // increment numberOfCars
 }
 // define the destructor
 ~Car()
 {
   System.Console.WriteLine("Destroying a Car object");
   numberOfCars--;  // decrement numberOfCars
 }
 // define a static method that returns numberOfCars
 public static int GetNumberOfCars()
 {
   return numberOfCars;
 }

}

public class Example6_1 {

 public static void Main()
 {
   // display numberOfCars
   System.Console.WriteLine("Car.GetNumberOfCars() = " +
     Car.GetNumberOfCars());
   // create a Car object
   Car myCar = new Car();
   System.Console.WriteLine("Car.GetNumberOfCars() = " +
     Car.GetNumberOfCars());
   // create another Car object
   Car myCar2 = new Car();
   System.Console.WriteLine("Car.GetNumberOfCars() = " +
     Car.GetNumberOfCars());
 }

}

      </source>

Static members are frequently used as counters.

<source lang="csharp"> using System; public class Starter {

   public static void Main() {
       MyClass<int> obj1 = new MyClass<int>();
       MyClass<double> obj2 = new MyClass<double>();
       MyClass<double> obj3 = new MyClass<double>();
       MyClass<int>.Count(obj1);
       MyClass<double>.Count(obj2);
   }

} public class MyClass<T> {

   public MyClass() {
       ++counter;
   }
   public static void Count(MyClass<T> _this) {
       Console.WriteLine("{0} : {1}",
           _this.GetType().ToString(),
           counter.ToString());
   }
   private static int counter = 0;

}

</source>

Use a static class factory

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

• /

// Use a static class factory.

using System;

class MyClass {

 int a, b; 

 // Create a class factory for MyClass. 
 static public MyClass factory(int i, int j) { 
   MyClass t = new MyClass(); 
   
   t.a = i; 
   t.b = j; 

   return t; // return an object 
 } 

 public void show() { 
   Console.WriteLine("a and b: " + a + " " + b); 
 } 

}

public class MakeObjects1 {

 public static void Main() {   
   int i, j; 

   // generate objects using the factory 
   for(i=0, j=10; i < 10; i++, j--) { 
     MyClass ob = MyClass.factory(i, j); // get an object 
     ob.show(); 
   } 
      
   Console.WriteLine();    
 } 

}

      </source>

Use a static constructor

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

• /

// Use a static constructor.

using System;

class Cons {

 public static int alpha; 
 public int beta; 

 // static constructor 
 static Cons() { 
   alpha = 99; 
   Console.WriteLine("Inside static constructor."); 
 } 

 // instance constructor 
 public Cons() { 
   beta = 100; 
   Console.WriteLine("Inside instance constructor."); 
 } 

}

public class ConsDemo {

 public static void Main() {   
   Cons ob = new Cons(); 

   Console.WriteLine("Cons.alpha: " + Cons.alpha); 
   Console.WriteLine("ob.beta: " + ob.beta); 
                 
 } 

}

      </source>

Use a static field to count instances

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

• /

// Use a static field to count instances.

using System;

class CountInst {

 static int count = 0; 
 
 // increment count when object is created 
 public CountInst() {  
   count++; 
 }  

 // decrement count when object is destroyed 
 ~CountInst() { 
   count--; 
 } 
 
 public static int getcount() { 
   return count; 
 } 

}

public class CountDemo {

 public static void Main() { 
   CountInst ob; 


   for(int i=0; i < 10; i++) { 
     ob = new CountInst(); 
     Console.WriteLine("Current count: " +  
                       CountInst.getcount()); 
   } 

 }  

}

      </source>

Use static

<source lang="csharp"> /* C#: The Complete Reference by Herbert Schildt Publisher: Osborne/McGraw-Hill (March 8, 2002) ISBN: 0072134852

• /

// Use static.

using System;

class StaticDemo {

 // a static variable 
 public static int val = 100;  

 // a static method 
 public static int valDiv2() { 
   return val/2; 
 } 

}

public class SDemo {

 public static void Main() { 

   Console.WriteLine("Initial value of StaticDemo.val is " 
                     + StaticDemo.val); 

   StaticDemo.val = 8; 
   Console.WriteLine("StaticDemo.val is " + StaticDemo.val); 
   Console.WriteLine("StaticDemo.valDiv2(): " + 
                      StaticDemo.valDiv2()); 
 } 

}

      </source>

Use static method to initialize field

<source lang="csharp"> using System; internal class MyClass {

   public int iField1 = FuncA();
   public int iField2 = FuncC();
   public int iField3 = FuncB();
   public static int FuncA() {
       Console.WriteLine("MyClass.FuncA");
       return 0;
   }
   public static int FuncB() {
       Console.WriteLine("MyClass.FuncB");
       return 1;
   }
   public static int FuncC() {
       Console.WriteLine("MyClass.FuncC");
       return 2;
   }

} public class Starter {

   public static void Main() {
       MyClass obj = new MyClass();
   }

}

</source>