Azroc.co.uk

Static Versus Non-Static Methods Video

A method is a member that implements a computation or action that can be performed by an object or class. Methods have a (possibly empty) list of formal parameters, a return value (unless the method's return-type is void), and are either static or non-static. Static methods are accessed through the class. Non-static methods, which are also called instance methods, are accessed through instances of the class. A generic method (§25.6) has a list of one or more type parameters. The example

using System;
public class Stack
{
  public static Stack Clone(Stack s) {.}
  public static Stack Flip(Stack s) {.}
  public object Pop() {.}
  public void Push(object o) {.}
  public void PushMultiple<T>(T[] a) {.}
  public override string ToString() {.}
  .
}
class Test
{
  static void Main()
  {
    Stack s = new Stack();
    for (int i = 1; i < 10; i++)
      s.Push(i);
    Stack flipped = Stack.Flip(s);
    Stack cloned = Stack.Clone(s);
    Console.WriteLine("Original stack: " + s.ToString());
    Console.WriteLine("Flipped stack: " + flipped.ToString());
    Console.WriteLine("Cloned stack: " + cloned.ToString());
  }
}

shows a Stack that has several static methods (Clone and Flip) and several instance methods (Pop, Push, and ToString) and a generic method (PushMultiple<T>).

Methods can be overloaded, which means that multiple methods can have the same name so long as they have unique signatures. The signature of a method consists of the name of the method and the number, modifiers, and types of its formal parameters, and the number of generic type parameters. The signature of a method does not include the return type or the names of the formal parameters or type parameters. The example

using System;
class Test
{
  static void F()
  {
  Console.WriteLine("F()");
  }
  static void F(object o)
  {
    Console.WriteLine("F(object)");
  }
  static void F(int value)
  {
    Console.WriteLine("F(int)");
  }
  static void F(ref int value)
  {
    Console.WriteLine("F(ref int)");
  }
  static void F(int a, int b)
  {
    Console.WriteLine("F(int, int)");
  }
  static void F(int[] values)
  {
    Console.WriteLine("F(int[])");
  }
  static void F<T>(T t)
  {
    Console.WriteLine("F<T>(T)");
  }
  static void Main()
  {
    F();
    F(1);
    int i = 10;
    F(ref i);
    F((object)1);
    F(1, 2);
    F(new int[] {1, 2, 3});
    F("Hello");
    F<string>("World");
  }
}

shows a class with a number of methods called F. The output produced is

F()
F(int)
F(ref int)
F(object)
F(int, int)
F(int[])
F<T>(T)
F<T>(T)