/*
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;
    }
}



           
          

   

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

  }

}


           
          

   

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

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


           
          

   

/*
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 
  } 
}