Chapter 47: Methods

Section 47.1: Calling a Method

Calling a static method:

// Single argument

System.Console.WriteLine("Hello World");

// Multiple arguments string name = "User";

System.Console.WriteLine("Hello, {0}!", name);

Calling a static method and storing its return value:

string input = System.Console.ReadLine();

Calling an instance method:

int x = 42;

// The instance method called here is Int32.ToString() string xAsString = x.ToString();

Calling a generic method

// Assuming a method 'T[] CreateArray<T>(int size)'

DateTime[] dates = CreateArray<DateTime>(8);

Section 47.2: Anonymous method

Anonymous methods provide a technique to pass a code block as a delegate parameter. They are methods with a body, but no name.

delegate int IntOp(int lhs, int rhs);

class Program

{

static void Main(string[] args)

{

// C# 2.0 definition

IntOp add = delegate(int lhs, int rhs)

{

return lhs + rhs;

};

//C# 3.0 definition

IntOp mul = (lhs, rhs) =>

{

return lhs * rhs;

};

//C# 3.0 definition - shorthand

IntOp sub = (lhs, rhs) => lhs - rhs;

//Calling each method

Console.WriteLine("2 + 3 = " + add(2, 3));

Console.WriteLine("2 * 3 = " + mul(2, 3));

//If you don't want to return a value, use void as return type. static void ReturnsNothing() {

Console.WriteLine("Returns nothing");

}

//If you want to return a value, you need to specify its type. static string ReturnsHelloWorld() {

return "Hello World";

}

If your method specifies a return value, the method must return a value. You do this using the return statement. Once a return statement has been reached, it returns the specified value and any code after it will not be run anymore (exceptions are finally blocks, which will still be executed before the method returns).

If your method returns nothing (void), you can still use the return statement without a value if you want to return from the method immediately. At the end of such a method, a return statement would be unnecessary though.

Examples of valid return statements:

return; return 0; return x * 2;

return Console.ReadLine();

Throwing an exception can end method execution without returning a value. Also, there are iterator blocks, where return values are generated by using the yield keyword, but those are special cases that will not be explained at this point.

Section 47.6: Default Parameters

You can use default parameters if you want to provide the option to leave out parameters:

static void SaySomething(string what = "ehh") { Console.WriteLine(what);

}

static void Main() {

//prints "hello"

SaySomething("hello");

//prints "ehh"

SaySomething(); // The compiler compiles this as if we had typed SaySomething("ehh")

}

When you call such a method and omit a parameter for which a default value is provided, the compiler inserts that default value for you.

Keep in mind that parameters with default values need to be written after parameters without default values.

static void SaySomething(string say, string what = "ehh") {

//Correct

Console.WriteLine(say + what);

}

static void SaySomethingElse(string what = "ehh", string say) {

//Incorrect

Console.WriteLine(say + what);

}

WARNING: Because it works that way, default values can be problematic in some cases. If you change the default value of a method parameter and don't recompile all callers of that method, those callers will still use the default value that was present when they were compiled, possibly causing inconsistencies.

Section 47.7: Method overloading

Definition : When multiple methods with the same name are declared with di erent parameters, it is referred to as method overloading. Method overloading typically represents functions that are identical in their purpose but are written to accept di erent data types as their parameters.

Factors a ecting

Number of Arguments

Type of arguments

Return Type**

Consider a method named Area that will perform calculation functions, which will accepts various arguments and return the result.

Example

public string Area(int value1)

{

return String.Format("Area of Square is {0}", value1 * value1);

}

This method will accepts one argument and return a string, if we call the method with an integer(say 5) the output will be "Area of Square is 25".

public double Area(double value1, double value2)

{

return value1 * value2;

}

Similarly if we pass two double values to this method the output will be the product of the two values and are of type double. This can be used of multiplication as well as finding the Area of rectangles

public double Area(double value1)

{

return 3.14 * Math.Pow(value1,2);

}

This can be used specially for finding the area of circle, which will accepts a double value(radius) and return another double value as its Area.

Each of these methods can be called normally without conflict - the compiler will examine the parameters of each method call to determine which version of Area needs to be used.

string squareArea = Area(2);

double rectangleArea = Area(32.0, 17.5);

double circleArea = Area(5.0); // all of these are valid and will compile.

**Note that return type alone cannot di erentiate between two methods. For instance, if we had two definitions for Area that had the same parameters, like so: