Techniques of Passing Arguments
|
|
Passing an Argument by Value
|
|
When calling a method that took one or more arguments,
we made sure we provided the necessary value(s) for the argument(s). This is
because an argument is always required and the calling method must provide a
valid value when calling such a method. This technique of providing a value
for the argument is referred to as passing an argument by value.
|
- Start Microsoft Visual Studio
- To create a new application, on the main menu, click File -> New Project...
- In the middle list, click Empty Project
- Change the Name to NationalBank1 and press Enter
- To create a new file, in the Solution Explorer, right-click NationalBank1 -> Add -> New Item...
- In the middle list, click Code File
- Change the Name of the file to Management
- Click Add
- In the empty Management.cs file, type the following:
public class Management { private void ShowAccountInformation(string acntNbr, string name, short PIN, double balance) { System.Console.WriteLine("=============================="); System.Console.WriteLine("Account Information"); System.Console.WriteLine("------------------------------"); System.Console.Write("Account #: "); System.Console.WriteLine(acntNbr); System.Console.Write("Customer Name: "); System.Console.WriteLine(name); System.Console.Write("PIN: "); System.Console.WriteLine(PIN); System.Console.Write("Balanace: "); System.Console.WriteLine(balance); System.Console.WriteLine("=============================="); } public static int Main() { Management man = new Management(); string accountNumber = "248-050842-749"; string customerName = "Ann Kelley"; short pin = 8648; double currentBalance = 350.00D; man.ShowAccountInformation(accountNumber, customerName, pin, currentBalance); System.Console.ReadKey(); return 0; } } - To execute, press F5
============================== Account Information ------------------------------ Account #: 248-050842-749 Customer Name: Ann Kelley PIN: 8648 Balanace: 350 ==============================
- After seeing the result, press Enter to close the DOS window
Consider the following program:
public class Exercise
{
void GetDeposit(decimal amount)
{
amount = 450;
System.Console.WriteLine("In GetDeposit()");
System.Console.Write("Amouont: $");
System.Console.WriteLine(amount);
}
static int Main()
{
decimal amt = 0;
var exo = new Exercise();
System.Console.WriteLine("In Main()");
System.Console.Write("Amouont: $");
System.Console.WriteLine(amt);
System.Console.WriteLine("-------------------------");
exo.GetDeposit(amt);
System.Console.WriteLine("-------------------------");
System.Console.WriteLine("Bank in Main()");
System.Console.Write("Amouont: $");
System.Console.WriteLine(amt);
return 0;
}
}
This would produce:
In Main() Amouont: $0 ------------------------- In GetDeposit() Amouont: $450 ------------------------- Bank in Main() Amouont: $0 Press any key to continue . . .
Notice that the value of the argument is the same before
and after calling the GetDeposit() 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 can simply access 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 it in any way, it cannot (permanently) alter it. An alternative is to
call a method to modify the value of an 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 can pass the argument using its
reference.
To pass an argument as a reference, when defining the
method, precede the argument's data type with the ref keyword. Here
is an example:
public class Exercise
{
void GetDeposit(ref decimal amount)
{
}
}
In the method, you can use or ignore the argument. When
calling the method, precede the argument's name with the ref keyword.
here is an example:
public class Exercise
{
void GetDeposit(ref decimal amount)
{
}
static int Main()
{
decimal amt = 0;
var exo = new Exercise();
System.Console.WriteLine("In Main()");
System.Console.Write("Amount: $");
System.Console.WriteLine(amt);
exo.GetDeposit(ref amt);
System.Console.WriteLine("Bank in Main()");
System.Console.Write("Amount: $");
System.Console.WriteLine(amt);
return 0;
}
}
This would produce:
In Main() Amount: $0 Bank in Main() Amount: $0 Press any key to continue . . .
The true purpose of passing an argument by reference is
to allow the method to change the value of the argument. To make this
possible, in the method, make sure you change the value of the argument.
Here is an example:
public class Exercise
{
void GetDeposit(ref decimal amount)
{
amount = 450;
System.Console.WriteLine("In GetDeposit()");
System.Console.Write("Amount: $");
System.Console.WriteLine(amount);
}
static int Main()
{
decimal amt = 0;
var exo = new Exercise();
System.Console.WriteLine("In Main()");
System.Console.Write("Amount: $");
System.Console.WriteLine(amt);
System.Console.WriteLine("-------------------------");
exo.GetDeposit(ref amt);
System.Console.WriteLine("-------------------------");
System.Console.WriteLine("Bank in Main()");
System.Console.Write("Amount: $");
System.Console.WriteLine(amt);
return 0;
}
}
This would produce:
In Main() Amount: $0 ------------------------- In GetDeposit() Amount: $450 ------------------------- Bank in Main() Amount: $450 Press any key to continue . . .
Notice that this time, the value of the variable is
changed after the function has been called.
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.
When we studied the fact that a method
can return a value, we saw that a function can return only one value
because there is only one return keyword. Fortunately, the
ability to pass many arguments by reference makes it possible for a method
to return many values.
- Change the Management.cs file as follows:
public class Management { private void ShowAccountInformation(string acntNbr, string name, short PIN, double balance) { System.Console.WriteLine("=============================="); System.Console.WriteLine("Account Information"); System.Console.WriteLine("------------------------------"); System.Console.Write("Account #: "); System.Console.WriteLine(acntNbr); System.Console.Write("Customer Name: "); System.Console.WriteLine(name); System.Console.Write("PIN: "); System.Console.WriteLine(PIN); System.Console.Write("Balanace: "); System.Console.WriteLine(balance); System.Console.WriteLine("=============================="); } private double GetDeposit(ref double amount) { double deposit = 225.55; amount = amount + deposit; return deposit; } private double GetWithdrawal(ref double amount) { double withdrawal = 265.25d; amount = amount - withdrawal; return withdrawal; } public static int Main() { Management man = new Management(); string accountNumber = "248-050842-749"; string customerName = "Ann Kelley"; short pin = 8648; double currentBalance = 350.00D; double? depositAmount = null; double? withdrawalAmount = null; man.ShowAccountInformation(accountNumber, customerName, pin, currentBalance); depositAmount = man.GetDeposit(ref currentBalance); System.Console.WriteLine("After a new deposit"); man.ShowAccountInformation(accountNumber, customerName, pin, currentBalance); withdrawalAmount = man.GetWithdrawal(ref currentBalance); System.Console.WriteLine("After a withdrwal"); man.ShowAccountInformation(accountNumber, customerName, pin, currentBalance); System.Console.ReadKey(); return 0; } } - Press F5 to execute
============================== Account Information ------------------------------ Account #: 248-050842-749 Customer Name: Ann Kelley PIN: 8648 Balanace: 350 ============================== After a new deposit ============================== Account Information ------------------------------ Account #: 248-050842-749 Customer Name: Ann Kelley PIN: 8648 Balanace: 575.55 ============================== After a withdrwal ============================== Account Information ------------------------------ Account #: 248-050842-749 Customer Name: Ann Kelley PIN: 8648 Balanace: 310.3 ==============================
- Press Enter to close the DOS window
Another option consists of passing an argument using the
out keyword. As done for passing by reference, to pass an argument
out, in the parentheses of the method, precede the data type of the argument
with the out keyword. Here is an example:
public class Exercise
{
void GetWithdrawal(out decimal amount)
{
}
}
The main difference between the ref and
the out keywords is that, if you pass an argument with
out, you must initialize it (give it a value) in the
method, whether you will use the argument in the method or not. Here is an
example:
public class Exercise
{
void GetWithdrawal(out decimal amount)
{
amount = 265.00m;
}
}
When calling a method that takes an out argument,
precede the argument with the out keyword. Here is an example:
public class Exercise
{
void GetDeposit(ref decimal amount)
{
amount = 450.00M;
System.Console.WriteLine("In GetDeposit()");
System.Console.Write("Amount: $");
System.Console.WriteLine(amount);
}
void GetWithdrawal(out decimal amount)
{
amount = 265.00m;
System.Console.WriteLine("In GetWithdrawal()");
System.Console.Write("Amount: $");
System.Console.WriteLine(amount);
}
static int Main()
{
decimal depositAmount = 0M;
decimal withdrawalAmount = 0M;
var exo = new Exercise();
System.Console.WriteLine("In Main()");
System.Console.Write("Amount: $");
System.Console.WriteLine(depositAmount);
System.Console.WriteLine("-------------------------");
exo.GetDeposit(ref depositAmount);
System.Console.WriteLine("-------------------------");
System.Console.WriteLine("Bank in Main()");
System.Console.Write("Amount: $");
System.Console.WriteLine(depositAmount);
System.Console.WriteLine("-------------------------");
exo.GetWithdrawal(out withdrawalAmount);
System.Console.WriteLine("-------------------------");
System.Console.WriteLine("Bank in Main()");
System.Console.Write("Amount: $");
System.Console.WriteLine(withdrawalAmount);
return 0;
}
}
As done for the ref keyword, if you
pass an argument with out, any modification made on the argument
would be kept when the method ends. This would produce:
In Main() Amount: $0 ------------------------- In GetDeposit() Amount: $450.00 ------------------------- Bank in Main() Amount: $450.00 ------------------------- In GetWithdrawal() Amount: $265.00 ------------------------- Bank in Main() Amount: $265.00 Press any key to continue . . .
As mentioned for a ref argument, a
method that receives arguments passed with out can be used
to return many values, as opposed to returning only one by using the
return keyword.
Consider the following function named CalculateArea:
public class Geometry
{
double CalculateArea()
{
return 0D;
}
}
When you create a method in a class and when you build
the project, the compiler creates a list of those methods. This list is
called a virtual table. In the table, a method is encoded using its name:
| Method Name | Encoding |
| CalculateArea | Calculate@None |
If the method has an argument, the table contains the
data type of that argument. Neither the return type of the method nor the
name(s) of the argument(s) is important. If the class contains methods that
have different names, they are easily distinguishable (because they have
different names). Sometimes, for one reason or another, you may want to have
different methods that do a similar job with slight differences (it will be
your job to define what the differences are and why). One way you can
indicate that the methods accomplish the same purpose is to have them use
the same name. The ability to have two or more methods with the same name in
the same class is referred to as method overloading.
To perform method overloading, that we will refer to in
our lessons as overloading a method, when creating the virtual table, each
entry in the list must be unique. As mentioned already, the return type of a
method is not entered. So you cannot base the differences on it. If you try
creating two methods and none takes an argument, obviously you cannot
distinguish them in the table. The solution is that one of them should take
an argument. Here is an example:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
}
| Method Name | Argument(s) | Encoding |
| CalculateArea | Calculate@None | |
| CalculateArea | double | Calculate@Double |
Obviously this time, each method has a different
encoding. Here is an example of using the above code:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
}
public class Exercise
{
static int Main()
{
Geometry geo = new Geometry();
System.Console.WriteLine("Geometric Shapes");
System.Console.WriteLine("Calculation of Areas");
System.Console.Write("Square: ");
System.Console.WriteLine(geo.CalculateArea(26.38));
return 0;
}
}
This would produce:
Geometric Shapes Calculation of Areas Square: 695.9044 Press any key to continue . . .
Remember that the name of an argument is not part of its
encoding in the virtual table. Therefore, you cannot use two methods that
each takes the same type of argument. Consider the following code:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
// Circle
public double CalculateArea(double radius)
{
return radius * radius * 3.14159;
}
}
This would result in:
| Method Name | Argument(s) | Encoding |
| CalculateArea | Calculate@None | |
| CalculateArea | double | Calculate@Double |
| CalculateArea | double | Calculate@Double |
As a result, when you build the project, the compiler
would produce the following error:
Error 1 Type 'Geometry' already defines a member called 'CalculateArea' with the same parameter types C:\Exercise1\Exercise.cs 16 19 Overloading
One of the rules of method overloading is that the
method can have different types of arguments. Here is an example:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
// Circle
public float CalculateArea(float radius)
{
return radius * radius * 3.14159f;
}
}
In many cases, you will not want to simply pass a
different type of argument. We mentioned that, in the virtual table, the
data type of the argument is entered. What if each method takes a different
number of argument? Consider the following example:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
// Rectangle
public double CalculateArea(double length, double height)
{
return length * height;
}
}
This would result in:
| Method Name | Argument(s) | Encoding |
| CalculateArea | Calculate@None | |
| CalculateArea | double | Calculate@Double |
| CalculateArea | double, double | Calculate@Double@Double |
Notice that the encoding of the second and the third
methods is different. Here is an example of calling the methods:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
// Rectangle
public double CalculateArea(double length, double height)
{
return length * height;
}
}
public class Exercise
{
static int Main()
{
var geo = new Geometry();
System.Console.WriteLine("Geometric Shapes");
System.Console.WriteLine("Calculation of Areas");
System.Console.Write("Square: ");
System.Console.WriteLine(geo.CalculateArea(26.38));
System.Console.Write("Rectangle: ");
System.Console.WriteLine(geo.CalculateArea(39.17, 26.38));
return 0;
}
}
This would produce:
eometric Shapes alculation of Areas quare: 695.9044 ectangle: 1033.3046 ress any key to continue . . .
Although we are using two double arguments for the third
methd, the arguments can be of any type. It will be your decision what
creating the method. Therefore, another rule of method overloading states
that each method must use a different number of argument.
One of the characteristics of most computer languages,
including C-based languages (C++, Java, C#, etc) and others (Pascal, Visual
Basic, etc) is that you don't have to use an argument in its method. You can
use this feature to create two versions of a method that should have the
same behavior: you can pass an argument that you will not use but that
results in a distinguished entry in the virtual table. Consider the
following code:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
// Rectangle
public double CalculateArea(double length, double height)
{
return length * height;
}
// Circle
public double CalculateArea(double radius, int unused)
{
return radius * radius * 3.14159;
}
}
This would result in:
| Method Name | Argument(s) | Encoding |
| CalculateArea | Calculate@None | |
| CalculateArea | double | Calculate@Double |
| CalculateArea | double, double | Calculate@Double@Double |
| CalculateArea | double, double | Calculate@Double@Integer |
Notice that the encodings are distinct.
Remember that, normally, you need only one value to
calculate the areas of a square or a circle. To distinguish their
calculations in our code, we passed a second argument to the area of the
circle. We named the argument "unused" but you can use any name (one of the
differences between C++ and C# is that in the former, you can omit a name;
therefore, if this code were written in C++, we would not have to name the
argument).
When calling the method that takes two argument, you
must pass a value for the second argument. Since the method will not use the
argument, you can pass any value, as long as it is conform to the type. Here
is an example of using the above code:
public class Geometry
{
// Unknown Shape
public double CalculateArea()
{
return 0D;
}
// Square
public double CalculateArea(double side)
{
return side * side;
}
// Rectangle
public double CalculateArea(double length, double height)
{
return length * height;
}
// Circle
public double CalculateArea(double radius, int unused)
{
return radius * radius * 3.14159;
}
}
public class Exercise
{
static int Main()
{
var geo = new Geometry();
System.Console.WriteLine("Geometric Shapes");
System.Console.WriteLine("Calculation of Areas");
System.Console.Write("Square: ");
System.Console.WriteLine(geo.CalculateArea(26.38));
System.Console.Write("Rectangle: ");
System.Console.WriteLine(geo.CalculateArea(39.17, 26.38));
System.Console.Write("Circle: ");
System.Console.WriteLine(geo.CalculateArea(26.38, 0));
return 0;
}
}
This would produce:
Geometric Shapes Calculation of Areas Square: 695.9044 Rectangle: 1033.3046 Circle: 2186.246303996 Press any key to continue . . .
Method overloading is heavily used in the .NET
Framework. Therefore, remember its (two, either-or) rules. Fortunately, they
are (very) easy: The methods must use either different numbers of arguments
or different types of arguments.
When a method is overloaded, when you access it in the
Code Editor, the IntelliSense would show a label with 1 of X. The X
indicates the number of versions that the method has. Here is an example of
a function that has three versions, thus the IntelliSense indicates 1 of 3:
To select one of the versions, you can press the down
arrow key or you can start typing the value of the argument until the right
version is shown.
|
Optional Arguments
|
We have learned that if a method takes an argument, when
you call that method, you must provide a value for the argument. There is an
exception to this rule. If you have a method whose argument is usually given
the same value, you can give a default value to that argument.
Consider the following code:
public class Exercise
{
double? CalculateNetPrice(double? discountRate)
{
double? origPrice = 125.55;
return origPrice - (origPrice * discountRate / 100);
}
static int Main()
{
var exo = new Exercise();
double? finalPrice = null;
double? discount = 15; // That is 25% = 25
finalPrice = exo.CalculateNetPrice(discount);
System.Console.WriteLine("After applying the discount");
System.Console.Write("Final Price = ");
System.Console.WriteLine(finalPrice);
return 0;
}
}
This would produce:
After applying the discount Final Price = 106.7175 Press any key to continue . . .
To specify that an argument has a default value, in the
parentheses of the method, after the name of the argument, assign the
default value to it. Here is an example:
public class Exercise
{
double? CalculateNetPrice(double? discountRate = 25)
{
double? origPrice = 125.55;
return origPrice - (origPrice * discountRate / 100);
}
}
When calling the method, you can pass a value for the
argument. If you want to use the default value, omit passing the argument.
Here is an example:
public class Exercise
{
double? CalculateNetPrice(double? discountRate = 25)
{
double? origPrice = 125.55;
return origPrice - (origPrice * discountRate / 100);
}
static int Main()
{
var exo = new Exercise();
double? finalPrice = null;
finalPrice = exo.CalculateNetPrice();
System.Console.WriteLine("After applying the discount");
System.Console.Write("Final Price = ");
System.Console.WriteLine(finalPrice);
return 0;
}
}
Notice that the parentheses of the method are empty,
which means that the argument was not passed. This would produce:
After applying the discount Final Price = 94.1625 Press any key to continue . . .
In the same way, you can create a method that takes many
arguments and some or all of those arguments can have default values.
If a method takes more than one argument, you can
provide a default argument for each and select which ones would have default
values. If you want all arguments to have default values, when defining the
method, type each name followed by = and followed by the desired value. Here
is an example:
public class Exercise
{
double? CalculateNetPrice(double? tax = 5.75,
double? discount = 25,
double? origPrice = 245.55)
{
double? discountValue = origPrice * discount / 100;
double? taxValue = tax / 100;
double? netPrice = origPrice - discountValue + taxValue;
System.Console.Write("Original Price: $");
System.Console.WriteLine(origPrice);
System.Console.Write("Discount Rate: ");
System.Console.Write(discount);
System.Console.WriteLine("%");
System.Console.Write("Tax Amount: $");
System.Console.WriteLine(tax);
return netPrice;
}
static int Main()
{
var exo = new Exercise();
double? finalPrice = null;
finalPrice = exo.CalculateNetPrice();
System.Console.WriteLine("After applying the discount");
System.Console.Write("Final Price = ");
System.Console.WriteLine(finalPrice);
return 0;
}
}
This would produce:
Original Price: $245.55 Discount Rate: 25% Tax Amount: $5.75 After applying the discount Final Price = 184.22 Press any key to continue . . .
If a method takes more than one argument and you would
like to provide default values for those parameters, the order of appearance
of the arguments is very important.
- If a method takes two arguments, you can declare it with default
values. We already know how to do that. If you want to provide a default
value for only one of the arguments, the argument that would have a
default value must be the second. When calling such a function, if you
supply only one argument, the compiler would assign its value to the
first parameter in the list and ignore assigning a value to the second:
public class Exercise { double? CalculateNetPrice(double? taxRate, double? discountRate = 25) { double? origPrice = 185.95; double? discountValue = origPrice * discountRate / 100; double? taxValue = taxRate / 100; double? netPrice = origPrice - discountValue + taxValue; return netPrice; } static int Main() { double? finalPrice; double? taxRate = 5.50; // = 5.50% Exercise exo = new Exercise(); finalPrice = exo.CalculateNetPrice(taxRate); System.Console.WriteLine("After applying a 25% discount and a 5.50% tax rate"); System.Console.Write("Final Price = "); System.Console.WriteLine(finalPrice); return 0; } }Here is an example of running the program:
After applying a 25% discount and a 5.50% tax rate Final Price = 139.5175 Press any key to continue . . .
If you define the function and assign a default value to the first argument, if you provide only one argument when calling the function, you would receive an error. Consider the following code:
public class Exercise { double? CalculateNetPrice(double? discountRate = 25, double? taxRate) { double? origPrice = 185.95; double? discountValue = origPrice * discountRate / 100; double? taxValue = taxRate / 100; double? netPrice = origPrice - discountValue + taxValue; return netPrice; } static int Main() { double? finalPrice; double? taxRate = 5.50; // = 5.50% Exercise exo = new Exercise(); finalPrice = exo.CalculateNetPrice(taxRate); System.Console.WriteLine("After applying a 25% discount and a 5.50% tax rate"); System.Console.Write("Final Price = "); System.Console.WriteLine(finalPrice); return 0; } }This would produce two errors as:Error 1 Optional parameters must appear after all required parameters C:\Exercises\Bank\Exercise.cs 3 70 Bank
- If the method receives more than two arguments and you would like
only some of those arguments to have default values, the arguments that
have default values must be at the end of the list. Regardless of how
many arguments would or would not have default values, start the list of
arguments with those that would not use default values. Here is an
example:
public class Exercise { double? CalculateNetPrice(double? origPrice, double? taxRate = 5.75, double? discountRate = 25) { double? discountValue = origPrice * discountRate / 100; double? taxValue = taxRate / 100; double? netPrice = origPrice - discountValue + taxValue; return netPrice; } }When calling the method, you can provide a value for only the argument(s) that do(es) not have a default value:public class Exercise { double? CalculateNetPrice(double? origPrice, double? taxRate = 5.75, double? discountRate = 25) { double? discountValue = origPrice * discountRate / 100; double? taxValue = taxRate / 100; double? netPrice = origPrice - discountValue + taxValue; return netPrice; } static int Main() { double? originalPrice = 375.95; double? finalPrice; Exercise exo = new Exercise(); finalPrice = exo.CalculateNetPrice(originalPrice); System.Console.WriteLine("After applying a 25% discount and a 5.75% tax rate"); System.Console.Write("Final Price = "); System.Console.WriteLine(finalPrice); return 0; } }Here is an example of running the program:After applying a 25% discount and a 5.75% tax rate Final Price = 282.02 Press any key to continue . . .
As you can see, the argument(s) that has(have) default value(s) must be last in the list of arguments
We saw that if you create a method that takes more than
one argument and not all arguments have default values, when calling the
method, if you don't want to provide (a) value(s) for the argument(s) with
(an) optional value(s), you can just pass the value(s) of the non-optional
argument. Imagine you have a method that takes two or more optional
arguments. In C++, if you want to provide a value for the second optional
argument, you must first pass a value for the first optional argument. Even
if you want to use the default value of the first argument, you must pass
it. Here is an example:
public class Exercise
{
double? CalculateNetPrice(double? origPrice,
double? taxRate = 5.75,
double? discountRate = 25)
{
double? discountValue = origPrice * discountRate / 100;
double? taxValue = taxRate / 100;
double? netPrice = origPrice - discountValue + taxValue;
return netPrice;
}
static int Main()
{
double? finalPrice;
Exercise exo = new Exercise();
finalPrice = exo.CalculateNetPrice(375.95, 5.75, 40);
System.Console.WriteLine("Original Price: 375.95");
System.Console.WriteLine("Tax Rate: 5.75%");
System.Console.WriteLine("Discount Rate: 40%");
System.Console.Write("Final Price: ");
System.Console.WriteLine(finalPrice);
return 0;
}
}
This would produce:
Original Price: 375.95 Tax Rate: 5.75% Discount Rate: 40% Final Price: 225.6275 Press any key to continue . . .
Imagine you want to skip one optional argument to use
its default value but you want to pass a value for the second, third, etc
argument. To do this, in the parentheses of the method of you are calling,
type the name of the argument, followed by a colon and the desired value,
which is the same as calling an argument by name. Here is an example:
public class Exercise
{
double? CalculateNetPrice(double? origPrice,
double? taxRate = 5.75,
double? discountRate = 25)
{
double? discountValue = origPrice * discountRate / 100;
double? taxValue = taxRate / 100;
double? netPrice = origPrice - discountValue + taxValue;
return netPrice;
}
static int Main()
{
double? finalPrice;
Exercise exo = new Exercise();
finalPrice = exo.CalculateNetPrice(discountRate : 40, origPrice : 375.95);
System.Console.WriteLine("Original Price: 375.95");
System.Console.WriteLine("Tax Rate: 5.75%");
System.Console.WriteLine("Discount Rate: 40%");
System.Console.Write("Final Price: ");
System.Console.WriteLine(finalPrice);
return 0;
}
}
With this technique, you can ignore the optional
arguments whose values you don't want to provide.
 Application:
Ending the Lesson |
- Close your programming environment
- When asked whether you want to save, click No
No comments:
Post a Comment