METHODS

A method is a code block that contains a series of statements. A program causes the statements to be executed by calling the method and specifying any required method arguments. In C#, every executed instruction is performed in the context of a method. The Main method is the entry point for every C# application and it is called by the common language runtime (CLR) when the program is started.

Method Signatures

Methods are declared in a class or struct by specifying the access level such as public or private, optional modifiers such as abstract or sealed, the return value, the name of the method, and any method parameters. These parts together are the signature of the method.

Method parameters are enclosed in parentheses and are separated by commas. Empty parentheses indicate that the method requires no parameters. This class contains three methods:

abstract class Motorcycle

{

    // Anyone can call this.

    public void StartEngine() {/* Method statements here */ }

    // Only derived classes can call this.

    protected void AddGas(int gallons) { /* Method statements here */ }

    // Derived classes can override the base class implementation.

    public virtual int Drive(int miles, int speed) { /* Method statements here */ return 1; }

    // Derived classes must implement this.

    public abstract double GetTopSpeed();

}

Method Access

Calling a method on an object is like accessing a field. After the object name, add a period, the name of the method, and parentheses. Arguments are listed within the parentheses, and are separated by commas. The methods of the Motorcycle class can therefore be called as in the following example:

class TestMotorcycle : Motorcycle

{

    public override double GetTopSpeed()

    {

        return 108.4;

    }

  static void Main()

    {

       TestMotorcycle moto = new TestMotorcycle();

        moto.StartEngine();

        moto.AddGas(15);

        moto.Drive(5, 20);

        double speed = moto.GetTopSpeed();

        Console.WriteLine("My top speed is {0}", speed);           

    }

}

Method Parameters vs. Arguments

The method definition specifies the names and types of any parameters that are required. When calling code calls the method, it provides concrete values called arguments for each parameter. The arguments must be compatible with the parameter type but the argument name (if any) used in the calling code does not have to be the same as the parameter named defined in the method. For example:

public void Caller()

 

{

    int numA = 4;

    // Call with an int variable.

    int productA = Square(numA);

    int numB = 32;

    // Call with another int variable.

    int productB = Square(numB);

    // Call with an integer literal.

    int productC = Square(12);

    // Call with an expression that evaulates to int.

    productC = Square(productA * 3);

}

int Square(int i)

{

    // Store input argument in a local variable.

    int input = i;

    return input * input;

}

Passing by Reference vs. Passing by Value

By default, when a value type is passed to a method, a copy is passed instead of the object itself. Therefore, changes to the argument have no effect on the original copy in the calling method. You can pass a value-type by reference by using the ref keyword.

When an object of a reference type is passed to a method, a reference to the object is passed. That is, the method receives not the object itself but an argument that indicates the location of the object. If you change a member of the object by using this reference, the change is reflected in the argument in the calling method, even if you pass the object by value.

You create a reference type by using the class keyword, as the following example shows.

public class SampleRefType

{

    public int value;

}

Now, if you pass an object that is based on this type to a method, a reference to the object is passed. The following example passes an object of type SampleRefType to method ModifyObject.

public static void TestRefType()

{

    SampleRefType rt = new SampleRefType();

    rt.value = 44;

    ModifyObject(rt);

    Console.WriteLine(rt.value);

}

static void ModifyObject(SampleRefType obj)

{

    obj.value = 33;

}

The example does essentially the same thing as the previous example in that it passes an argument by value to a method. But, because a reference type is used, the result is different. The modification that is made in ModifyObject to the value field of the parameter, obj, also changes the value field of the argument, rt, in the TestRefType method. The TestRefType method displays 33 as the output.