The values you input to a method are method arguments, or parameters. Most methods require some type of arguments if they're going to do something. (In this way, methods remind me of my son: We need to have an argument before he'll do anything.) You pass arguments to a method by listing them in the parentheses that follow the method name. Consider this small addition to the earlier Example class:

public class Example
{
  public static void Output(string someString)
  {
    Console.WriteLine("Output() was passed the argument: " + someString);
  }
}

I could invoke this method from within the same class, like this:

Output("Hello");

I would then see this not-too-exciting output:

Output() was passed the argument: Hello

The program passes to the method Output() a reference to the string "Hello". The method receives the reference and assigns it the name someString. The Output() method can use someString within the method just as it would use any other string variable.

I can change the example in one minor way:

string myString = "Hello";
Output(myString);

This code snippet assigns the variable myString to reference the string "Hello". The call Output(myString) passes the object referenced by myString, which is your old friend "Hello". Figure 3-1 depicts this process. From there, the effect is the same as before.

Figure 3-1. Copying the value of myString to someString.

A similar idea is passing arguments to a program. For example, you may have noticed that Main() usually takes an array argument.

When I ask my daughter to wash the car, she usually gives me more than just a single argument. Because she has lots of time on the couch to think about it, she can keep several at the ready.

You can define a method with multiple arguments of varying types. Consider the following sample method AverageAndDisplay():

// AverageAndDisplay -- Demonstrate argument passing.
using System;
namespace Example
{
  public class Program
  {
    public static void Main(string[] args)
    {
      // Access the member method.
      AverageAndDisplay("grade 1", 3.5, "grade 2", 4.0);
      // Wait for user to acknowledge.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }

// AverageAndDisplay -- Average two numbers with their
    //    labels and display the results.
    public static void AverageAndDisplay(string s1, double d1,                                                                string s2, double d2)
    {
      double average = (d1 + d2) / 2;
      Console.WriteLine("The average of "  + s1
                      + " whose value is " + d1
                      + " and "            + s2
                      + " whose value is " + d2
                      + " is " + average);
    }
  }
}

Executing this simple program generates this output:

The average of grade 1 whose value is 3.5 and grade 2 whose value is 4 is 3.75
Press Enter to terminate...

The method AverageAndDisplay() is declared with several parameters in the order in which arguments are to be passed to them.

As usual, execution of the sample program begins with the first statement after Main(). The first noncomment line in Main() invokes the method AverageAndDisplay(), passing the two strings "grade 1" and "grade 2" and the two double values 3.5 and 4.0.

The method AverageAndDisplay() calculates the average of the two double values, d1 and d2, passed to it along with their names contained in s1 and s2, and the calculated average is stored in average.

Each argument in a method call must match the method definition in both type and order if you call them without naming them. The following (illegal) example generates a build-time error:

// AverageWithCompilerError -- This version does not compile!
using System;
namespace Example
{
  public class Program
  {
    public static void Main(string[] args)
    {
      // Access the member method.
      AverageAndDisplay("grade 1", "grade 2", 3.5, 4.0);

// Wait for user to acknowledge.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
    // AverageAndDisplay -- Average two numbers with their
    //    labels and display the results.
    public static void AverageAndDisplay(string s1, double d1,
                                         string s2, double d2)
    {
      // var okay here, but it's really double.
      var average = (d1 + d2) / 2;
      Console.WriteLine("The average of "  + s1
                      + " whose value is " + d1
                      + " and "            + s2
                      + " whose value is " + d2
                      + " is " + average);
    }
  }
}

C# can't match the type of each argument in the call to AverageAnd Display() with the corresponding argument in the method definition. The string "grade 1" matches the first string in the method definition; however, the method definition calls for a double as its second argument rather than the string that's passed.

You can easily see that I simply transposed the second and third arguments. (That's what I hate about computers — they take me too literally. I know what I said, but it's obvious what I meant!)

To fix the problem, swap the second and third arguments.

This example demonstrates overloading:

// AverageAndDisplayOverloaded -- This version demonstrates that
//    the AverageAndDisplay method can be overloaded.
using System;
namespace AverageAndDisplayOverloaded
{
  public class Program
  {
    public static void Main(string[] args)
    {
      // Access the first version of the method.
      AverageAndDisplay("my GPA", 3.5, "your GPA", 4.0);
      Console.WriteLine();
      // Access the second version of the method.

AverageAndDisplay(3.5, 4.0);
      // Wait for user to acknowledge.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
    // AverageAndDisplay -- Average two numbers with their
    //    labels and display the results.
    public static void AverageAndDisplay(string s1, double d1,
                                         string s2, double d2)
    {
      double average = (d1 + d2) / 2;
      Console.WriteLine("The average of "  + s1
                      + " whose value is " + d1);
      Console.WriteLine("and "            + s2
                      + " whose value is " + d2
                      + " is " + average);
    }
    public static void AverageAndDisplay(double d1, double d2)
    {
      double average = (d1 + d2) / 2;
      Console.WriteLine("The average of " + d1
                      + " and "           + d2
                      + " is " + average);
    }
  }
}

This program defines two versions of AverageAndDisplay(). The program invokes one and then the other by passing the proper arguments. C# can tell which method the program wants by comparing the call with the definition. The program compiles properly and generates this output when executed:

The average of my GPA whose value is 3.5
and your GPA whose value is 4 is 3.75

The average of 3.5 and 4 is 3.75
Press Enter to terminate...

C# generally doesn't allow two methods in the same class to have the same name unless the number or type of the methods' arguments differs (or if both differ). Thus C# differentiates between these two methods:

When you say it that way, it's clear that the two methods are different.

Often, you want to supply two (or more) versions of a method:

You can easily implement default arguments using method overloading. Consider this pair of DisplayRoundedDecimal() methods:

// MethodsWithDefaultArguments -- Provide variations of the same methods,
//    some with default arguments, by overloading the method name.
using System;
namespace MethodsWithDefaultArguments
{
  public class Program
  {
    public static void Main(string[] args)
    {
      // Access the member method.
      Console.WriteLine(DisplayRoundedDecimal(12.345678M, 3));
      // Wait for user to acknowledge.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
    // DisplayRoundedDecimal -- Convert a decimal value into a string
    //    with the specified number of signficant digits.
    public static string DisplayRoundedDecimal(decimal value,
                                                   int numberOfSignificantDigits)
    {
      // First round off the number to the specified number
      // of significant digits.
      decimal roundedValue =
                     decimal.Round(value,
                                   numberOfSignificantDigits);
      // Convert that to a string.
      string s = Convert.ToString(roundedValue);
      return s;
    }
    public static string DisplayRoundedDecimal(decimal value)
    {
      // Invoke DisplayRoundedDecimal(decimal, int) specifying
      // the default number of digits.
      string s = DisplayRoundedDecimal(value, 2);
      return s;
    }
  }
}

The DisplayRoundedDecimal(decimal, int) method converts the decimal value that's provided into a string with the specified number of digits after the decimal point. Because decimals are often used to display monetary values, the most common choice is to place two digits after the decimal point. Therefore, the DisplayRoundedDecimal(decimal) method provides the same conversion service — but defaults the number of significant digits to two, thereby removing any worry about the meaning of the second argument.

Providing default arguments does more than just save lazy programmers from exerting a tiny bit of effort (programming requires lots of concentration). The author of the method understands the relationship between the arguments — and therefore bears the onus of providing friendlier, overloaded versions of methods.

Visual Basic, C, and C++ programmers should be accustomed to supplying a default value for a parameter directly in the method signature. Until C# 4.0 was released, you couldn't do that in C#. Now you can.

For instance, although overloading the method in the preceding example is a perfectly acceptable way to implement a default parameter, you can also give default parameters by using the equal sign (=), just as in Visual Basic:

// MethodsWithDefaultArguments2-– Provide optional parameters to a method
// to avoid overloading. It's another way to do the same thing.
using System;
namespace MethodsWithDefaultArguments2
{
  public class Program
  {
    public static void Main(string[] args)
    {
      // Access the member method.
      Console.WriteLine(DisplayRoundedDecimal(12.345678M, 3));
      // Wait for user to acknowledge.
      Console.WriteLine("Press Enter to terminate...");
      Console.Read();
    }
    // DisplayRoundedDecimal -- Convert a decimal value into a string
    //    that has the specified number of signficant digits. That argument
    //    is optional and has a default value. If you call the method
    //    without the second argument, it uses the default value.
    public static string DisplayRoundedDecimal(decimal value,
                                      int numberOfSignificantDigits = 2)
    {
      // First round off the number to the specified number
      // of significant digits.

decimal roundedValue =
                     decimal.Round(value,
                                   numberOfSignificantDigits);
      // Convert that to a string.
      string s = Convert.ToString(roundedValue);
      return s;
    }
  }
}

I cover named and optional parameters ad nauseam in Book III.

The following code snippet demonstrates a small method that returns the average of its input arguments:

public class Example
{
  public static double Average(double d1, double d2)
  {
    double average = (d1 + d2) / 2;
    return average;
  }
  public static void Main(string[] args)
  {
    double v1 = 1.0;
    double v2 = 3.0;
    double averageValue = Average(v1, v2);
    Console.WriteLine("The average of " + v1
                    + " and " + v2 + " is "
                    + averageValue);

// This also works.
    Console.WriteLine("The average of " + v1
                    + " and " + v2 + " is "
                    + Average(v1, v2));
  }
}

Notice first that I declare the method as public static double Average() — the double in front of its name indicates that the Average() method returns a double-precision value to the caller.

The Average() method applies the names d1 and d2 to the double values passed to it. This method creates a variable average to which it assigns the average of d1 and d2 and returns to the caller the value contained in average.

The call to Average() from the Test() method appears the same as any other method call; however, the double value returned by Average() via the return keyword is stored in the variable averageValue.

The declaration public static double Average(double, double) declares a method Average() that returns the average of its arguments as a double. (The number returned had better be the average of the input values or else someone has some serious explaining to do.)

Some methods don't need to return a value to the caller. An earlier method AverageAndDisplay() example displays the average of its input arguments but doesn't return that average to the caller. (That idea may not be a good one, but mine is not to question.) Rather than leave the return type blank, you declare a method such as AverageAndDisplay() this way:

public void AverageAndDisplay(double, double)

The keyword void, where the return type is normally used, means nontype. That is, the declaration void indicates that the AverageAndDisplay() method returns no value to the caller. (Regardless, every method declaration specifies a return type, even if it's void.)

A nonvoid method must pass control back to the caller by executing a return followed by the value to return to the caller. A void method has no value to return. A void method returns when it encounters a return with no value attached. Or, by default (if no return exists), a void method exits automatically when control reaches the closing brace of the method.

Consider this DisplayRatio() method:

public class Example
{
  public static void DisplayRatio(double numerator,
                                  double denominator)
  {
    // If the denominator is zero . . .
    if (denominator == 0.0)
    {
      //  . . .output an error message and . . .
      Console.WriteLine("The denominator of a ratio cannot be 0");
      //  . . .return to the caller.
      return;  // An early return due to the error
    }
    // This code is executed only if denominator is nonzero.
    double ratio = numerator / denominator;
    Console.WriteLine("The ratio of " + numerator
                    + " over " + denominator
                    + " is " + ratio);
  }  // If the denominator isn't zero, the method exits here.
}

The DisplayRatio() method checks whether the denominator value is zero:

If that were the only difference, it wouldn't be much to write home about. However, the second form of WriteLine() also provides a number of controls on the output format. I describe these format controls in Book I, Chapter 3.

Console.WriteLine("this is a method call");

string s = "Sarah"
Console.WriteLine("My name is " + s + " and my age is " + 3);

Console.WriteLine("My name is {0} and my age is {1}.", "Sarah", 3);