Methods and their Parameters

As we saw in the previous lesson, a method performs an assignment that completes the operations of a class. The methods we used in the previous lesson relied on global variables to exchange information with other sections of the program. Sometimes, a method would need one or more values in order to carry its assignment. The particularity of such a value or such values is that another method that calls this one must supply the needed values. When a method needs a value to complete its assignment, such a value is called an argument.

1. Start Microsoft Visual C# or Visual Studio .NET
2. On the main menu, click File -> New -> Project
3. If necessary, in the Project Types list of the New Project dialog box, click Visual C# Projects
4. In the Templates list, click Empty Project
5. In the Name text box, replace the name with Geometry2 and specify the desired path in the Location
6. Click OK
7. To create a source file for the project, on the main menu, click Project -> Add New Item...
8. In the Add New Item dialog box, in the Templates list, click Code File
9. In the Name text box, delete the suggested name and replace it with Exercise
10. Click Open
11. In the empty file, type the following:
     

    using System; namespace GeometricFormulas { class Cylinder { static double Radius; static double Height; static double BaseArea; static double LateralArea; static double TotalArea; static double Volume; static double GetRadius() { double rad; do { Console.Write("Radius: "); rad = double.Parse(Console.ReadLine()); if( rad < 0 ) Console.WriteLine("Please enter a positive number"); } while( rad < 0 ); return rad; } static double GetHeight() { double h; do { Console.Write("Height: "); h = double.Parse(Console.ReadLine()); if( h < 0 ) Console.WriteLine("Please enter a positive number"); } while( h < 0 ); return h; } static void ProcessCylinder() { Console.WriteLine("Enter the dimensions of the cylinder"); Radius = GetRadius(); Height = GetHeight(); BaseArea = Radius * Radius * Math.PI; LateralArea = 2 * Math.PI * Radius * Height; TotalArea = 2 * Math.PI * Radius * (Height + Radius); Volume = Math.PI * Radius * Radius * Height; } static void ShowCylinder() { Console.WriteLine("\nCylinder Characteristics"); Console.WriteLine("Radius: {0}", Radius); Console.WriteLine("Height: {0}", Height); Console.WriteLine("Base: {0:F}", BaseArea); Console.WriteLine("Lateral: {0:F}", LateralArea); Console.WriteLine("Total: {0:F}", TotalArea); Console.WriteLine("Volume: {0:F}", Volume); } static void Main() { ProcessCylinder(); ShowCylinder(); Console.WriteLine(); } } }

12. To execute the application, on the main menu, click Debug -> Start Without Debugging 
13. Return to Visual C#

Like a variable, an argument is represented by its type of value. For example, one method may need a character while another would need a string. Yet another method may require a decimal number. This means that the method or class that calls a method is responsible for supplying the right value, even though a method may have an internal mechanism of checking the validity of such a value.

The value supplied to a method is typed in the parentheses of the method and it's called an argument. In order to declare a method that takes an argument, you must specify its name and the argument between its parentheses. Because a method must specify the type of value it would need, the argument is represented by its data type and a name. If the method would not return a value, it can be declared as void.

Suppose you want to define a method that displays the side length of a square. Since you would have to supply the length, you can define such a method as follows:

using System;

public class NewProject
{
	void DisplaySide(double Length)
	{
	}
	static void Main()
	{
	}
}

In the body of the method, you may or may not use the value of the argument. Otherwise, you can manipulate the supplied value as you see fit. In this example, you can display the value of the argument as follows:

using System;

public class NewProject
{
	void DisplaySide(double Length)
	{
		Console.Write("Length: ");
		Console.WriteLine(Length);
	}
	static void Main()
	{
	}
}

In this case, remember to define the method as static if you plan to access it from Main(). In order to call a method that takes an argument, you must supply a value for the argument when calling the method; otherwise you would receive an error. Also, you should/must supply the right value; otherwise, the method may not work as expected and produce an unreliable result. Here is an example:

using System;

public class NewProject
{
	static void DisplaySide(double Length)
	{
		Console.Write("Length: ");
		Console.WriteLine(Length);
	}
	static void Main()
	{
		DisplaySide(35.55);
		
		Console.WriteLine();
	}
}

As mentioned already, a method that takes an argument can also declared its own variable. Such variables are referred to as local.

A method can take more than one argument. When defining such a method, provide each argument with its data type and a name. The arguments are separated by a comma.

Practical Learning: Passing Arguments

Techniques of Passing Arguments

Passing Arguments by Value

When calling the methods that take one or more arguments, we made sure we provided the needed argument. This is because an argument is always required and the calling function or class must provided a valid value when calling such a method.

Practical Learning: Passing Arguments By Value

1. All the arguments we have used so far were passed by value. For one more example, change the program as follows:
    

   using System; class Cylinder { static double GetTheRadius() { double rad; do { Console.Write("Radius: "); rad = double.Parse(Console.ReadLine()); if( rad < 0 ) Console.WriteLine("Please enter a positive number"); } while( rad < 0 ); return rad; } static double GetTheHeight() { double h; do { Console.Write("Height: "); h = double.Parse(Console.ReadLine()); if( h < 0 ) Console.WriteLine("Please enter a positive number"); } while( h < 0 ); return h; } static double CalculateBaseArea(double rad) { return rad * rad * Math.PI; } static double CalculateLateralArea(double rad, double hgt) { return 2 * Math.PI * rad * hgt; } static double CalculateTotalArea(double rad, double hgt) { return 2 * Math.PI * rad * (hgt + rad); } static double CalculateVolume(double rad, double hgt) { return Math.PI * rad * rad * hgt; } static void ProcessCylinder() { double Radius; double Height; double BaseArea; double LateralArea; double TotalArea; double Volume; Console.WriteLine("Enter the dimensions of the cylinder"); Radius = GetTheRadius(); Height = GetTheHeight(); BaseArea = CalculateBaseArea(Radius); LateralArea = CalculateLateralArea(Radius, Height); TotalArea = CalculateTotalArea(Radius, Height); Volume = CalculateVolume(Radius, Height); ShowCylinder(Radius, Height, BaseArea, LateralArea, TotalArea, Volume); } static void ShowCylinder(double rad, double hgt, double BArea, double Lateral, double Total, double vol) { Console.WriteLine("\nCylinder Characteristics"); Console.WriteLine("Radius: {0}", rad); Console.WriteLine("Height: {0}", hgt); Console.WriteLine("Base: {0:F}", BArea); Console.WriteLine("Lateral: {0:F}", Lateral); Console.WriteLine("Total: {0:F}", Total); Console.WriteLine("Volume: {0:F}", vol); } static void Main() { ProcessCylinder(); Console.WriteLine(); } }

2. Execute the application and test it. Here is an example:
    

   Enter the dimensions of the cylinder Radius: 38.26 Height: 28.48 Cylinder Characteristics Radius: 38.26 Height: 28.48 Base: 4598.75 Lateral: 6846.44 Total: 16043.94 Volume: 130972.40

3. Return to Visual C#

Passing an Argument by Reference

Notice that the weekly hours and salary values are the same before and after calling the Earnings() method. 

When you declare a variable in a program, the compiler reserves an amount of space for that variable. If you need to use that variable somewhere in your program, you call it and make use of its value. There are two major issues related to a variable: its value and its location in the memory.

The location of a variable in memory is referred to as its address.

If you supply the argument using its name, the compiler only makes a copy of the argument’s value and gives it to the calling method. Although the calling method receives the argument’s value and can use in any way, it cannot (permanently) alter it. C# allows a calling method to modify the value of a passed argument if you find it necessary. If you want the calling method to modify the value of a supplied argument and return the modified value, you should pass the argument using its reference.

To pass an argument as a reference, when defining and when calling the method, precede the argument's data type with the ref keyword. You can pass 0, one, or more arguments as reference in the program or pass all arguments as reference. The decision as to which argument(s) should be passed by value or by reference is based on whether or not you want the called method to modify the argument and permanently change its value.

Here are examples of passing some arguments by reference:

void Area(ref double Side); // The argument is passed by reference
bool Decision(ref char Answer, int Age); // One argument is passed by reference
// All arguments are passed by reference
float Purchase(ref float DiscountPrice, ref float NewDiscount, ref char Commission);

You add the ampersand when defining when calling the method. The above would be called with:

Area(ref Side);
Decision(ref Answer, Age);
Purchase(ref DiscountPrice, ref NewDiscount, ref Commission);

If you want a calling function to modify the value of an argument, you should supply its reference and not its value, using the ref keyword.

Another option consists of passing an argument using the out keyword. Here is an example:

using System;

class Exercise
{
	static void Initializer(out double n)
	{
		n = 128.44;
	}

	public static void Main()
	{
		double Number = 15.25;

		Console.WriteLine("Number = {0}", Number);
	}
}

If you pass an argument with out, any modification made on the argument would be kept when the method ends. When calling a method that takes an out argument, precede the argument with the out keyword. Here is an example:

Practical Learning: Passing Arguments By Reference

Method Overloading

A typical program involves a great deal of names that represent variables and methods of various kinds. The compiler does not allow two variables to have the same name in the same function. Although two methods should have unique names in the same program, C# allows you to use the same name for different functions of the same program following certain rules. The ability to have various methods with the same name in the same program is referred to as overloading. The most important rule about function overloading is to make sure that each one of these methods has a different number or different type(s) of arguments.

The moment of inertia is the ability of of a beam to resist bending. It is calculated with regard to the cross section of the beam. Because it depends on the type of section of the beam, its calculation also depends on the type of section of the beam. In this exercise, we will review different formulas used to calculate the moment of inertia. Since this exercise is for demonstration purposes, you do not need to be a Science Engineering major to understand it.

We will illustrate method overloading through an exercise.

Practical Learning: Overloading a Method