Methods Fundamentals

Introduction

When you create a class, the fields are meant to describe the objects created from that class. For a class named House, such aspects as the number of bedrooms, the property type, or its value, are used to describe it. Consider this class:

public class House
{
    public string propertyType;
    public int bedrooms;
}

Besides the characteristics used to describe it, an object can also perform actions or assignments. An action performed by a class is called a function or a method.

Practical LearningPractical Learning: Introducing Methods

  1. Start Microsoft Visual Studio
  2. To create a new application, on the main menu, click File -> New -> Project
  3. In the middle list, click Empty Project (.NET Framework)
  4. Change the Name to DepartmentStore2 and click OK
  5. On the main menu, click Project -> Add New Item...
  6. In the middle list of the Add New Item dialog box, click Code File
  7. Change the name to StoreItem and click Add
  8. In the file, type the following:
    public class StoreItem
    {
        public int itemNumber;
        public string itemName;
        public string size;
        public double unitPrice;
    }
  9. To create a code file, in the Solution Explorer, right-click DepartmentStore2 -> Add -> New Item...
  10. In the middle list of the Add New Item dialog box, click Code File
  11. Change the name to DepartmentStore and click Add
  12. In the empty document, type the following:
    public class DepartmentStore
    {
        static void Main()
        {
            StoreItem si = new StoreItem();
    
            si.itemNumber = 720823;
            si.itemName = "Cotton Seam Sheath Dress";
            si.size = "6";
            si.unitPrice = 158;
    
            System.Console.WriteLine("Department Store");
            System.Console.Write("Item #:     ");
            System.Console.WriteLine(si.itemNumber);
            System.Console.Write("Item Name:  ");
            System.Console.WriteLine(si.itemName);
            System.Console.Write("Item Size:  ");
            System.Console.WriteLine(si.size);
            System.Console.Write("Unit Price: ");
            System.Console.WriteLine(si.unitPrice);
            
            System.Console.ReadKey();
        }
    }
  13. Execute the application to see the result
  14. Close the DOS window and return to your programming environment

Introduction to Creating a Method

As seen for variables, the first piece of information you must provide about a method is a data type.

A Void Method

A method's job is to carry a specific assignment within a program. As such, it could provide a value once the assignment has been carried. In some cases, a method must produce a result. If it doesn't, then it is considered void. To create such a method, start with the void keyword.

A Name for a Method

To create a method, specify its name. The name of a method primarily follows the rules we defined for names of variables. Besides those rules, you can add yours. In our lessons, we will follow the same suggestions we reviewed for names of classes:

The name of a method is followed by parentheses.

The Body of a Method

The assignment that a method carries is included between an opening curly bracket "{" and a closing curly bracket "}". The section is referred to as the body of the method. Here is an example:

public class House
{
    public string propertyType;
    public int bedrooms;

    void Display()
    {
    }
}
Author Note

New Convention:

From now on, in our lessons, to refer to a method that belongs to a class, we may use the convention

class-name.method-name

This means that we are referring to the method method-name that is a member of the class class-name.

The Access Modifier of a Method

Like a member variable:

After creating a method, in its body delimited by its curly brackets, you can define the desired behavior. For example, you can write the member variables in the parentheses of System.Console.Write() or System.Console.WriteLine(). Here are examples:

public class House
{
    public string propertyType;
    public int bedrooms;

    internal void Display()
    {
        System.Console.WriteLine("=//= Altair Realtors =//=");
        System.Console.WriteLine("Properties Inventory"); ;
        System.Console.Write("Property Type:  ");
        System.Console.WriteLine(PropertyType);
        System.Console.Write("Bedrooms:       ");
        System.Console.WriteLine(Bedrooms);
    }
}

In the same way, you can create as many methods as you want in a class.

Calling a Method

After creating a method, you can access it, either inside or outside of its class. Accessing a method is referred to as calling it. You do this by following the same rules used to access a field, using the period operator. Unlike a field, the name of a class must be followed by parentheses. Here is an example:

public class House
{
    public string propertyType;
    public int bedrooms;

    internal void Display()
    {
        System.Console.WriteLine("=//= Altair Realtors =//=");
        System.Console.WriteLine("Properties Inventory"); ;
        System.Console.Write("Property Type:  ");
        System.Console.WriteLine(propertyType);
        System.Console.Write("Bedrooms:       ");
        System.Console.WriteLine(bedrooms);
    }
}

public class Program
{
    static void Main()
    {
        var property = new House();

        property.propertyType = 'S';
        property.bedrooms = 4;

        property.Display();
    }
}

This would produce:

=//= Altair Realtors =//=
Properties Inventory
Property Type:  S
Bedrooms:       4
Press any key to continue . . .

Practical LearningPractical Learning: Creating the Methods of a Class

  1. On the main menu, click Window -> StoreItem.cs to open that file
  2. To add some methods to the class, change the document as follows:
    public class StoreItem
    {
        public int itemNumber;
        public string itemName;
        public string size;
        public double unitPrice;
    
        public void CreateItem()
        {
            itemNumber = 792475;
            itemName = "Aramis Gentlemen Collection 3.4oz JHL Custom Blended Cologne Spray";
            size = "3.4oz";
            unitPrice = 48.00;
        }
    
        public void Describe()
        {
            System.Console.WriteLine("Department Store");
    
            System.Console.Write("Item #:     ");
            System.Console.WriteLine(itemNumber);
            System.Console.Write("Item Name:  ");
            System.Console.WriteLine(itemName);
            System.Console.Write("Item Size:  ");
            System.Console.WriteLine(size);
            System.Console.Write("Unit Price: ");
            System.Console.WriteLine(unitPrice);
        }
    }
  3. On the main menu, click Window -> DepartmentStore.cs
  4. Change the document as follows:
    public class DepartmentStore
    {
        static void Main()
        {
            StoreItem si = new StoreItem();
    
            si.CreateItem();
            si.Describe();
            
            System.Console.ReadKey();
        }
    }
  5. Execute the application. This would produce:
    Department Store
    Item #:     792475
    Item Name:  Aramis Gentlemen Collection 3.4oz JHL Custom Blended Cologne Spray
    Item Size:  3.4oz
    Unit Price: 48.00
  6. Close the DOS window and return to your programming environment

Introduction to Methods' Arguments

Overview

A method performs an assignment that completes the operations of a class. The methods we used in the previous sections relied on local 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 value(s). When a method needs a value to complete its assignment, such a value is called an argument.

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. Because a method must specify the type of value it would need, the argument is represented by its data type and a name.

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:

class Exercise
{
    void ShowCharacter(string c)
    {
     
    }
}

If the data type of an argument is a primitive type, to indicate that it can hold a null value, add a question mark to it. Here is an example:

class Exercise
{
    void ShowCharacter(string? c)
    {
     
    }
}

In the body of the method, you may or may not use the value of the argument. Here is an example that displays the value of the argument:

class Exercise
{
    void ShowCharacter(string c)
    {
        System.Console.WriteLine(c);
    }
}

The following is also valid:

class Exercise
{
    void ShowCharacter(string? c)
    {
        System.Console.WriteLine(c);
    }
}

In the same way, you can manipulate the supplied value as you see fit.

Calling a Method That Takes an Argument

As done for methods that don't take arguments, to use a method, you must call it. When calling a method that takes an argument, you must supply a value for the argument; otherwise you would receive an error. Also, you should/must supply the right value; otherwise, the method may not work as expected and it may produce an unreliable result.

If the method is taking an argument, when calling it, you can type a value in its parentheses. Here is an example:

class Exercise
{
    void ShowCharacter(string c)
    {
        System.Console.WriteLine(c);
       
    }

    static void Main()
    {
        Exercise exo = new Exercise();

        System.Console.Write("Character: ");

        exo.ShowCharacter('W');

        return 0;
    }
}

A method that takes an argument can also declare its own local variable(s).

Practical LearningPractical Learning: Passing Arguments

  1. Click the StoreItem.cs button to open its file and change it as follows:
    public class StoreItem
    {
        public int itemNumber;
        public string itemName;
        public string size;
        public double unitPrice;
    
        public void CreateItem()
        {
            itemNumber = 911_792;
            itemName = "Girls Tillie Poplin Dress";
            size = "12";
            unitPrice = 110.00;
        }
    
        public double CalculateTotalValue(int qty)
        {
            return unitPrice * qty;
        }
    
        public void Describe()
        {
            int quantity = 6;
    
            System.Console.WriteLine("Department Store");
            System.Console.Write("Item #:      ");
            System.Console.WriteLine(itemNumber);
            System.Console.Write("Item Name:   ");
            System.Console.WriteLine(itemName);
            System.Console.Write("Item Size:   ");
            System.Console.WriteLine(size);
            System.Console.Write("Unit Price:  ");
            System.Console.WriteLine(unitPrice);
            System.Console.Write("Quantity:    ");
            System.Console.WriteLine(quantity);
            System.Console.Write("Total Value: ");
            System.Console.WriteLine(CalculateTotalValue(quantity));
        }
    }
  2. Execute the application to see the result:
    Department Store
    Item #:      911792
    Item Name:   Petite Tropical Wool Pencil Skirt
    Item Size:   12
    Unit Price:  110.00
    Quantity:    6
    Total Value: 660.00
  3. Close the DOS window and return to your programming environment
Skirt

Passing Many Arguments to a Method

A method can take more than one argument, provide each argument with its data type and a name. The arguments are separated by a comma. In the parentheses Here is an example:

class Exercise
{
    void ShowEmployee(int employeeNumber, string fullName, string gender, double hourlySalary)
    {
    }
}

If necessary, you apply the question mark to one, some, or all arguments that are (is) of primitive type(s).

Author Note

New Convention:

From now on, in our lessons, to refer to a method that belongs to a class, we may use the convention

class-name.method-name(Arguments)

This means that we are referring to the method method-name that is a member of the class class-name. The item in the parentheses will refer to the argument(s) that the method takes.


Author Note

New Convention:

From now on, in our lessons, we may write "The syntax of this method is" (or something to that effect):

ReturnValue class-name.method-name(Arguments);

This means that we are providing (reviewing) the return type, the name, and the number of arguments (if any) of a method.

In our new convention, we terminate the syntax with a semi-colon.

When defining the method, you can use 0, 1, or all arguments any way you like. For example, you can display their values using to the console. Here are examples:

class Exercise
{
    void ShowEmployee(int employeeNumber, string fullName, string gender, double hourlySalary)
    {
        System.Console.Write("Employee #:    ");
        System.Console.WriteLine(employeeNumber);
        System.Console.Write("Full Name:     ");
        System.Console.WriteLine(fullName);
        System.Console.Write("Gender:        ");
        System.Console.WriteLine(gender);
        System.Console.Write("Hourly Salary: ");
        System.Console.WriteLine(hourlySalary);
    }
}

Although we saw already how to call a method that takes an argument, there are actually various ways this can be done. We saw that, when calling a method that takes an argument, you can type a value in the parentheses of the method. In the same way, when calling a method that takes more than one argument, type the appropriate value in the placeholder of each argument. Here are examples:

class Exercise
{
    void ShowEmployee(int employeeNumber, string fullName, string gender, double hourlySalary)
    {
        System.Console.WriteLine("Employee Record");
        System.Console.WriteLine("-----------------------------");
        System.Console.Write("Employee #:    ");
        System.Console.WriteLine(employeeNumber);
        System.Console.Write("Full Name:     ");
        System.Console.WriteLine(fullName);
        System.Console.Write("Gender:        ");
        System.Console.WriteLine(gender);
        System.Console.Write("Hourly Salary: ");
        System.Console.WriteLine(hourlySalary);
    }

    static void Main()
    {
        Exercise exo = new Exercise();

        exo.ShowEmployee(572948, "Andrew Bridges", 'M', 22.85D);

        return 0;
    }
}

This would produce:

Employee Record
-----------------------------
Employee #:    572948
Full Name:     Andrew Bridges
Gender:        M
Hourly Salary: 22.85
Press any key to continue . . .

Calling an Argument by Name

lf you call a method that takes many arguments, you don't have to use the exact placeholder of each argument. Instead, you can refer to each argument by its name. To do this, in the parentheses of the method, type the name of an argument, followed by a colon, and followed by the appropriate value.

If you are using Microsoft Visual Studio, after typing the name of the method and the opening parentheses, you should see the list of names of the arguments:

Arguments

You can then type the name of the argument. If you don't want to type, press Ctrl + Space. A menu would come. In its list would be the names of arguments:

Arguments

You can either start typing until the name of an argument is selected or you can double-click from the list. As mentioned already, after the name of the argument, add a colon and a value for the argument. In the same way, you can access any argument by its name and give it a value, separate them with commas. Here is an example:

class Exercise
{
    void ShowEmployee(int employeeNumber, string fullName, string gender, double hourlySalary)
    {
        System.Console.WriteLine("Employee Record");
        System.Console.WriteLine("-----------------------------");
        System.Console.Write("Employee #:    ");
        System.Console.WriteLine(employeeNumber);
        System.Console.Write("Full Name:     ");
        System.Console.WriteLine(fullName);
        System.Console.Write("Gender:        ");
        System.Console.WriteLine(gender);
        System.Console.Write("Hourly Salary: ");
        System.Console.WriteLine(hourlySalary);
    }

    static int Main()
    {
        Exercise exo = new Exercise();

        exo.ShowEmployee(fullName: "Annette Greens", hourlySalary: 16.85, employeeNumber: 519427, gender: 'F');

        return 0;
    }
}

This would produce:

Employee Record
-----------------------------
Employee #:    519427
Full Name:     Annette Greens
Gender:        F
Hourly Salary: 16.85
Press any key to continue . . .

The Scope and Lifetime of a Variable

Introduction

The scope of a variable is the extent to which it is available to other members of a class. To manage this, a variable is said to have local or global scope.

Local Variables

A variable is said to be local if it is declared in the body of a method. Here is an example:

class MemberRegistration
{
    private void Create()
    {
        string middleName;
    }
}

When a variable is declared as local, it can be accessed only by code inside the same curly brackets. If you try accessing such a variable outside its curly brackets, you would receive an error.

A Global Variable

A variable is said to be global if it is declared inside in the body of a class and outside the curly brackets of any method. Here is an example:

class MemberRegistration
{
    string strDateOfBirth;

    private void Initialize()
    {

    }

    private void Present()
    {

    }
}

A variable that has been declared globally can be accessed by any code of the same class.

The Scope and Lifetime of an Object

You can declare a variable of a class in the body of a class and initialize it there. Here is an example:

class Student
{
}

class StudentRegistration
{
    Student pupil = new Student();
    
    private void Show()
    {
    }
}

Once this has been done, the object is ready to be used by any method of the same class. As an alternative, you can declare the variable in the body of the class but initialize it in a method of the class. Here is an example:

class Student
{
}

class StudentRegistration
{
    Student pupil;
    
    private void Create()
    {
        pupil = new Student();
    }
    
    private void Show()
    {
    }
}

If you decide to use this technique, before the object can be actually used, you must call the method that initializes the variable, otherwize you may receive an error.

A Method that Returns a Value

Introduction

A method can be made to return a value. In fact, a method can also be made to return an object. To indicate that a method is returning a value, when creating that method, the first requirement is that, on the left side of its name, instead of the void keyword, specify a data type. Here is an example:

class Rectangle
{
    public double Width;
    public double Height;

    public double Area()
    {
        
    }
}

The second requirement is that, in the body of the function or a method, you must indicate the value it returns. There are many ways you can do this but the primary technique is that, before the closing curly bracket, type the return keyword followed by the value and a semicolon. Here is an example:

class Rectangle
{
    public double Width;
    public double Height;

    public double Area()
    {
        double result = 0.00;

        return result;
    }
}

Otherwise, you can perform any operation in the body of the method and return the desired value. Here is an example:

class Rectangle
{
    public double Width;
    public double Height;

    public double Area()
    {
        double result = 0.00;

        result = Width * Height;

        return result;
    }
}

Practical LearningPractical Learning: Creating a Method that Returns a Value

  1. Access the TimeSheet.cs file and change the CalculateBiweeklySalary() method as follows:
    public class TimeSheet
    {
        public double Week1TimeWorked;
        public double Week2TimeWorked;
        public double HourlySalary;
    
        public void Initialize(double hSalary, double week1, double week2)
        {
            Week1TimeWorked = week1;
            Week2TimeWorked = week2;
            HourlySalary    = hSalary;
        }
    
        public double CalculateBiweeklySalary()
        {
            double result = 0;
            double totalTimeWorked = Week1TimeWorked + Week2TimeWorked;
    
            result = HourlySalary * totalTimeWorked;
    
            return result;
        }
    }

Introduction to Calling a Method that Returns a Value

To use the value that a method returns, you must call that method. If you want, you can assign its value to a local variable.

Practical LearningPractical Learning: Calling a Method that Returns a Value

  1. Access the Index.cshtml file and change its document as follows:
    <!DOCTYPE html>
    <html>
    <head>
    <link rel="stylesheet" type="text/css" href="~/Content/Site.css" />
    <title>Fun Department Store - Payroll Preparation</title>
    </head>
    <body>
    @{
        double netPay = 0;
        double hourlySalary = 0;
        TimeSheet ts = new TimeSheet();
    
        if (IsPost)
        {
            hourlySalary = Request["txtHourlySalary"].Asdouble();
            double week1TimeWorked = Request["txtWeek1TimeWorked"].AsDecimal();
            double week2TimeWorked = Request["txtWeek2TimeWorked"].AsDecimal();
    
            ts.Initialize(hourlySalary, week1TimeWorked, week2TimeWorked);
            netPay = ts.CalculateBiweeklySalary();
        }
    }
    
    <div class="container">
        <h1>Fun Department Store</h1>
        <h2>Payroll Preparation</h2>
    
        <form name="frmPayrollPreparation" method="post">
            <table>
                <tr>
                    <td class="left-col emphasize">Hourly Salary:</td>
                    <td><input type="text" name="txtHourlySalary" value="@hourlySalary" /></td>
                </tr>
                <tr>
                    <td colspan="2" class="emphasize">Time Worked</td>
                </tr>
                <tr>
                    <td class="left-col emphasize">Week 1:</td>
                    <td><input type="text" name="txtWeek1TimeWorked" value="@ts.Week1TimeWorked" /></td>
                </tr>
                <tr>
                    <td class="emphasize">Week 2:</td>
                    <td><input type="text" name="txtWeek2TimeWorked" value="@ts.Week2TimeWorked" /></td>
                </tr>
                <tr>
                    <td>&nbsp;</td>
                    <td><input type="submit" name="btnCalculate" value="Calculate" /></td>
                </tr>
                <tr>
                    <td class="emphasize">Biweekly Salary:</td>
                    <td><input type="text" name="txtBiweeklySalary" value="@netPay.ToString("F")" /></td>
                </tr>
            </table>
        </form>
    </div>
    </body>
    </html>
  2. To execute the application, on the main menu, click Debug -> Start Without Debugging

    Calling a Method of many Parameters

  3. In the Hourly Salary text box, type a number such as 18.82
  4. In the Week 1 text box, type a number such as 40.00
  5. In the Week 2 text box, type a number such as 42.50
  6. Click the Calculate button:

    Calling a Method that Returns a Value

  7. Close the browser and return to your programming environment
  8. Access the TimeSheet.cs file and change the CalculateBiweeklySalary() method as follows:
    public class TimeSheet
    {
        public double Week1TimeWorked;
        public double Week2TimeWorked;
        public double HourlySalary;
    
        public void Initialize(double hSalary, double week1, double week2)
        {
            Week1TimeWorked = week1;
            Week2TimeWorked = week2;
            HourlySalary    = hSalary;
        }
    
        public double CalculateBiweeklySalary()
        {
            double result = 0;
    
            result = HourlySalary * (Week1TimeWorked + Week2TimeWorked);
    
            return result;
        }
    }
  9. Access the Index.cs file and click inside its document to give it focus
  10. To execute the application, on the main menu, click Debug -> Start Without Debugging
  11. Close the browser and return to your programming environment
  12. Access the TimeSheet.cs file and change the CalculateBiweeklySalary() method as follows:
    public class TimeSheet
    {
        public double Week1TimeWorked;
        public double Week2TimeWorked;
        public double HourlySalary;
    
        public void Initialize(double hSalary, double week1, double week2)
        {
            Week1TimeWorked = week1;
            Week2TimeWorked = week2;
            HourlySalary    = hSalary;
        }
    
        public double CalculateBiweeklySalary()
        {
            double result = HourlySalary * (Week1TimeWorked + Week2TimeWorked);
    
            return result;
        }
    }
  13. Access the Index.cs file and click inside its document to give it focus
  14. To execute the application, on the main menu, click Debug -> Start Without Debugging
  15. Close the browser and return to your programming environment
  16. Access the TimeSheet.cs file and change the CalculateBiweeklySalary() method as follows:
    public class TimeSheet
    {
        public double Week1TimeWorked;
        public double Week2TimeWorked;
        public double HourlySalary;
    
        public void Initialize(double hSalary, double week1, double week2)
        {
            Week1TimeWorked = week1;
            Week2TimeWorked = week2;
            HourlySalary    = hSalary;
        }
    
        public double CalculateBiweeklySalary()
        {
            return HourlySalary * (Week1TimeWorked + Week2TimeWorked);
        }
    }
  17. Access the Index.cs file and click inside its document to give it focus
  18. To execute the application, on the main menu, click Debug -> Start Without Debugging
  19. Close the browser and return to your programming environment

A Method that Returns an Expression

A method can also return an expression, provided the expression produces a value that is conform to the return type. Here is an example:

class Exercise
{
    double Operate()
    {
		return 24.55 * 4.16;
    }
}

A Simple Returning Method with no Body

If you have a method that either contains only one expression or the contents of its body can be resumed to one line, such a method doesn't need a body. Instead, after the parentheses of the method, type => followed by the returning expression. Here is an example:

class Contractor
{
    public int ContractorCode;
    public string FirstName;

    public string LastName;
    public double HourlySalary;

    public string ContractorName() => FirstName + " " + LastName;
}

Practical LearningPractical Learning: Using a Method without a Body

  1. Access the TimeSheet.cs file and change the CalculateBiweeklySalary() method as follows:
    public class TimeSheet
    {
        public double Week1TimeWorked;
        public double Week2TimeWorked;
        public double HourlySalary;
    
        public void Initialize(double hSalary, double week1, double week2)
        {
            Week1TimeWorked = week1;
            Week2TimeWorked = week2;
            HourlySalary    = hSalary;
        }
    
        public double CalculateBiweeklySalary() => HourlySalary * (Week1TimeWorked + Week2TimeWorked);
    }
  2. Access the Index.cs file and click inside its document to give it focus
  3. To execute the application, on the main menu, click Debug -> Start Without Debugging
  4. Close the browser and return to your programming environment

Techniques of Calling a Method that Returns a Value

You can call a function or method that returns a value as you do for one that is void. If you want to get and use the value returned by the method, you can declare a variable of the return type and assign the call to that variable. The variable would then be carrying the return value of the method and you can use that value any way you want.

class Contractor
{
    public string FirstName;
    public string LastName;

    public string ContractorName() => FirstName + " " + LastName;
}

class Employment
{
    static void Main()
    {
        string fullName = "";
        string fName = "Jennifer";
        string lName = "Clarenden";

        Contractor staff = new Contractor();
        staff.FirstName = fName;
        staff.LastName = lName;

        fullName = staff.ContractorName();

        System.Console.WriteLine("=//= Department Store =//=");
        System.Console.WriteLine("============================");
        System.Console.Write("Employee Name: ");
        System.Console.WriteLine(fullName);
    }
}

This would produce:

=//= Department Store =//=
============================
Employee Name: Jennifer Clarenden
Press any key to continue . . .

In the above code, we first declared a variable in one line and called the method in another line. This is done in case the values of the variable may change. Otherwise, you can declare the variable on the same line where you are calling the method. Here is an example:

class Contractor
{
    public string FirstName;
    public string LastName;

    public string ContractorName() => FirstName + " " + LastName;
}

class Employment
{
    static void Main()
    {
        string fName = "Jennifer";
        string lName = "Clarenden";

        Contractor staff = new Contractor();
        staff.FirstName = fName;
        staff.LastName = lName;

        string fullName = staff.ContractorName();

        System.Console.WriteLine("=//= Department Store =//=");
        System.Console.WriteLine("============================");
        System.Console.Write("Employee Name: ");
        System.Console.WriteLine(fullName);
    }
}

In the previous two examples, we declared a variable to store the return value of the method. This is done if you plan to use the variable many times, or call the method many times, or if the value of the variable will change more than once. If you are planning to call the method once, of if you don't need to store its value in a variable, you can call the method directly where its value is needed. Here is an example:

class Contractor
{
    public string FirstName;
    public string LastName;

    public string ContractorName() => FirstName + " " + LastName;
}

class Employment
{
    static void Main()
    {
        string fName = "Jennifer";
        string lName = "Clarenden";

        Contractor staff = new Contractor();
        staff.FirstName = fName;
        staff.LastName = lName;

        System.Console.WriteLine("=//= Department Store =//=");
        System.Console.WriteLine("============================");
        System.Console.Write("Employee Name: ");
        System.Console.WriteLine(staff.ContractorName());
    }
}

Practical LearningPractical Learning: Returning a Value From a Method 

  1. On the main menu, click Window -> StoreItem.cs
  2. Change the file as follows:
    public class StoreItem
    {
        public int itemNumber;
        public string itemName;
        public string size;
        public double unitPrice;
    
        public void CreateItem()
        {
            itemNumber = 792475;
            itemName = "Aramis Gentlemen Collection 3.4oz JHL Custom Blended Cologne Spray";
            size = "3.4oz";
            unitPrice = 48.00;
        }
    
        public double CalculateTotalValue()
        {
            return unitPrice;
        }
    
        public void Describe()
        {
            System.Console.WriteLine("Department Store");
    
            System.Console.Write("Item #:      ");
            System.Console.WriteLine(itemNumber);
            System.Console.Write("Item Name:   ");
            System.Console.WriteLine(itemName);
            System.Console.Write("Item Size:   ");
            System.Console.WriteLine(size);
            System.Console.Write("Unit Price:  ");
            System.Console.WriteLine(unitPrice);
            System.Console.Write("Total Value: ");
            System.Console.WriteLine(CalculateTotalValue());
        }
    }
  3. Execute the application to see the result
  4. Close the DOS window and return to your programming environment

A Method that May Return Null

If you are creating a method that may or may not return a value, you can indicate that it may return null. To do this, add a question mark to the data type. Here is an example:

class Exercise
{
    double? Operate()
    {
    }
}

In the body of a method, perform any necessary operation such as declaring one or more local variables. At the end of the method, use the return keyword to produce the desired value. Here is an example:

class Exercise
{
    double? Operate()
    {
	return 24.55;
    }
}

Having Many Methods that Return the Same Type of Value

Imagine you have a method that returns a value or an expression. Here is an example:

public class Operation
{
    public double Number1;
    public double Number2;
    public string  Operator;

    public string Calculate()
    {
        return Number1.ToString() + Operator + Number2.ToString();
    }
}

If you need another method that performs the same type of operation and/or returns the same type of value, you don't need to declare a variable to call the first method. Here is an example:

public class Operation
{
    public double Number1;
    public double Number2;
    public string  Operator;

    public string Calculate()
    {
        return Number1.ToString() + Operator + Number2.ToString();
    }

    public string Add()
    {
        return Calculate();
    }
}

In the same way, you can have other methods that call that method. Here are examples:

public class Operation
{
    public double Number1;
    public double Number2;
    public string  Operator;

    public string View()
    {
        return Number1.ToString() + Operator + Number2.ToString();
    }

    public string Add()
    {
        return Calculate();
    }

    public string Subtract()
    {
        return Calculate();
    }

    public string Multiply()
    {
        return Calculate();
    }
}

Practical LearningPractical Learning: Ending the Lesson


Previous Copyright © 2001-2019, FunctionX Next