Fundamentals of Classes

Introduction

Imagine you want to describe an object, such as a house. You can declare various variables that each holds one particular value such as the number of bedrooms, the number of doors, the market value of the house, etc. Here is an example:

string typeOfHouse; int yearBuilt; int numberOfBedrooms; double price;

When/if you want to describe such a house, you would have to access each variable, one at a time. As opposed to a simple variable, you can use one or more variables to create one object that includes all the characteristics you want.

A class is a technique of using one or a group of characteristics to describe an object.

Practical Learning: Introducing Classes

• Start Microsoft Visual Studio and create a new Console App that supports .NET 9.0 (Standard Term Support) named PieceWork2

Introduction to Creating a Class

There are various ways you can create a class. We will see different techniques in future lessons. For now, the basic way to start a class is from simple text where you would start with a keyword named class.

The Name of a Class

The class keyword is followed by a name. The name of a class primarily follows the rules of names of varibles:

• A name of a class can use one letter but that's not a good idea
• The name of a class can be a common word. In this case, the first letter should be in uppercase. Examples are: Person, House, Rmployee, or State
• The name of a class can be a combination of words. In this case, the first letter of each word should be in uppercase. Between the words, you can use an underscore or not. Don't leave an empty space between the words. Examples are: TimeSheet, SpecialMenu

The Body of a Class

To present its description, a class has members. The list of the members of a class is specified after the name of the class. The members are included between an opening curly bracket { and a closing curly bracket }. The section between the curly brackets is referred to as the body of the class. It would appear as follows:

class House { /* . . . */ }

In the same way, you can create as many classes as you want in your project. You can create many classes in the same document. Here is an example:

class House {}

class Person {}

class MortgageInformation {}

For your project, you can create each class in its own file or you can create various classes in different files.

Classes and Files

A class is created in a file. If you create a Console Application in Microsoft Visual Stuio, the studio automatically creates a C# file and creates a class in it. On the other hand, you can create a C# file and create a class in it.

A file can contain as many classes as necessary. One way you can organize the classes of your application is to put them in different files. A file can contain one or more classes. A file that contains (a) class(es) is a regular text-based file that has the extension .cs. To create a file for (a) class(es), start a text-based document, type your code, and save the file in the desired location. Normally, all files that belong the same application should be positioned in folders and sub-folders of the project. When saving the file, give it the extension .cs. If you are using Microsoft Visual Studio, there are various ways you can create a class and each would result in a new file for the class.

In the class, you can add the desired members such as regular variables. Here is an example:

class Number
{
}

Practical Learning: Creating a Class

1. On the main menu, click Project -> Add New Item...
2. In the left list of the Add New Item dialog box, under Visual C#, click Code
3. In the middle list, click Code File
4. Change the file name to StaffMember
5. Click Add
6. In the empty document, type of the following code:

   class Driver
   {
   }

7. To create another class, in the Solution Explorer, right-click the second PieceWork2 (the project) -> Add -> New Item...
8. In the middle list of the Add New Item dialog box, make sure Code File is selected.
   Change the file name to Truck
9. Click Add
10. In the empty document, type of the following code:

    /* Piecework is the type of work that is paid on the number 
      * of items produced, the distance driven, etc.
      * In this exercise, a business uses trucks driven by some 
      * employees or contractors to deliver some products. 
      * The drivers are paid based on the distance they travel to 
      * deliver one or many products. */
    class Truck
    {
    }

Introduction to Using a Class

Creating an Object

Like any normal variable, to use a class in your program, you must first declare a variable for it. Declaring a variable of a class is also referred to as creating an object or creating an instance of a class.

As done with the variables we have used so far, to declare a variable for a class, use the name of the class followed by a name for the variable. Here is an example:

House property;

class House
{
}

The variable of a class can also be declared in the body of another class. Here is an example:

// Creating an object of a State class
State ca;

// Creating an instance of the House class
House property;

class House
{
}

class State
{

}

You can also declare variables of different classes in the body of, or outside a class. In C#, the order of appearance of the classes or their variables is not important. Here are examples:

State ca;
House condo;
State nc;

int choice;
House property;
string selection;
House candy;

class Region
{
    State sc;
    House nation;
    State wa;
}

class House
{
}

class State
{
    House family;
}

If various variables are using the same type, you can declare them using their common class name. Separate the names of variables with commas. Here are examples:

State ca;
Region pacific;
House condo;

House property, candy;

class Region
{
    State sc, wa;
}

class House
{
}

class State
{
    House family, combination, block;
}

Value Types and Reference Types

When you declare a variable of a regular type (string or number), such a value is referred to as a value type. In fact, when you access the value of the variable, you get the actual value itself. The value of such a variable is stored in a memory area referred to as the stack.

After declaring a variable for a class, whenever you need its object, you must use the address of the memory where the object is stored. This means that you are accessing the object using its reference. For this reason, an object created from a class is stored in a type of memory called the heap.

When declaring a variable for a class, to indicate that its value must be stored in the heap, you must initialize it using an operator called new. This operator can be followed by the name of the class followed by parentheses. Here is an example:

House property;
        
property = new House();

class House
{
}

Practical Learning: Creating an Object

• To create some objects, write the following code:

  using static System.Console;
  
  Truck trk = new Truck();
  Driver drv = new Driver();

Introduction to the Members of a Class

Introduction to the Fields of a Class

Consider a class named House:

class House
{
}

As mentioned previously, the section between the curly brackets, { and }, of a class is referred to as its body. In the body of a class, you can create a list of the types that describe an object. These types are referred to as members of the class. At a minimum, these members are created like variables, and therefore are considered member variables.

A Field in a Class

In C#, a variable declared in the body of a class is called a field. Each field is declared as a normal variable with a data type followed by a name. The name of a variable follows the same rules we reviewed for names of variables. Here is an example of a class with a few fields:

class House
{
    int brightness;

    string security;
}

New Convention: From now on, in our lessons, to refer to a field that belongs to a class, we may write class-name.field-name This means that we are referring to the field field-name that is a member of the class class-name.

Each field can be any of the types we have seen so far. For example, a field of a class can be a Boolean type. To create a Boolean field, declare a variable of type bool in the body of a class. Here is an example:

class Driver
{
    bool drivingUnderInfluence;
}

Managing the Fields of a Class

Introduction

To assist you with managing the fields of a class, the Code Editor is equipped with the Types and the Members combo boxes.

The middle combo box displays the class that is currently selected. The right combo box displays the members, such as fields of the class:

Accessing a Field

There are many ways you can access a field:

• Open the file that contains the class and visually locate the field in the file
• In the upper section of the body of the Class View, click the name of the class that contains the field:
  • Its list of members will appear in the lower side of the body. You can then double-click it
  • In the lower section of the Class View, right-click the name of the field and click Go To Definition

Renaming a Field

If you decide to use a different name for a field, you can change it. You can first locate the field in the file and use your knowledge of text editing. As an alternative, after opening the file that contains the class, on the main menu, click Edit -> Find & Replace -> Quick Find, type the name of the field, and click Find Next or Replace. This approach is useful if you want to visit every part where the field is used. If you know for sure that you want to rename a field and everywhere it has been used, Microsoft Visual Studio can assist you.

To rename a field in Microsoft Visual Studio:

• Open the file that contains its class. Either press Ctrl + H or, on main menu, click Edit -> Find & Replace -> Quick Replace. In the Find What combo box, type the name of the field, and click Replace All
• Open the file that contains its class. Click the field to position the caret in it. Press Ctrl + H or, on main menu, click Edit -> Find & Replace -> Quick Replace. In the Find What combo box, make sure the name of the field is entered and click Replace All
• In the upper side of the Class View, click the name of the class. In the lower part, right-click the field and click Rename... In the New Name text box of the Rename dialog box, enter the desired name for the field. Use the check boxes to specify whether you also want the name to be edited in the comment and the strings. Once you are ready, click OK. In the Preview Changes - Rename dialog box, see the list of all parts where the field is used. If everything is alright, click Apply.

Access Modifiers of Class Members

The Private Members of a Class

When it comes to visibility, the parts of an object fall into two main categories: those you can touch and those you don't have access to. The parts you cannot access or cannot see are referred to as private. When creating a class, to specify that a member must be hidden to outside objects, precede its declaration with a keyword named private. Here are examples:

class House
{
    string Location;
    
    // A private field
    private string floorPlan;
    // A private field
    private int Basement;
}

When a member is marked private, other members of the same class can access it. Objects outside the class and members of other classes cannot access a private member.

Practical Learning: Adding Private Members to a Class

• Change the document as follows:

  using static System.Console;
  
  int miles;
  double pieceworkRate;
  
  Truck trk = new Truck();
  Driver drv = new Driver();

The Public Members of a Class

The parts of an object that other objects have access to are referred to as public. To indicate that a member of a class must be accessible outside the class, precede its declaration with a keyword named public. Here are examples:

class House
{
    // A public field
    public string BuildingPermit;
    // A public field
    public double MarketValue;
}

The public and private keywords are referred to as access levels.

By default, if you create a member (field, etc) in a class but don't specify its access level, the member is considered private and cannot be accessed from outside the class, that is by a non-member of that class. Therefore, to make a member accessible by other classes, you must mark it as public.

You can use a mix of public and private members in a class and there is no rule on which access level should be listed first or last. To reduce confusion as to what member is public or private, you should always specify the access level of each member.

Practical Learning: Adding Public Members to a Class

1. Click the StaffMember.cs tab to access the class
2. Change the class as follows:

   class Driver
   {
       public string first_name;
       public string last_name;
   }

3. Click the Truck.cs tab to access the class
4. Change the class as follows:

   /* Piecework is the type of work that is paid on the number 
     * of items produced, the distance driven, etc.
     * In this exercise, a business uses trucks driven by some 
     * employees or contractors to deliver some products. 
     * The drivers are paid based on the distance they travel to 
     * deliver one or many products. */
   class Truck
   {
       public string make;
       public string model;
   }

Sharing a Class

Sometimes you want your code to be shared among various languages such as C++/CLI, Visual Basic, F#, etc. In other words, code from these other languages should be able to "read" or access code written in a C# application. To make this possible, a C# class can be created as a public object.

If you want your class to be accessible to code written in other languages, precede the class keyword with the public keyword when creating it. Here is an example:

public class Number
{
    int minimum;
    string sign;
}

Practical Learning: Adding Members to a Class

• Change the class as follows:

  /* Piecework is the type of work that is paid on the number 
    * of items produced, the distance driven, etc.
    * In this exercise, a business uses trucks driven by some 
    * employees or contractors to deliver some products. 
    * The drivers are paid based on the distance they travel to 
    * deliver one or many products. */
  public class Truck
  {
      public string make;
      public string model;
  }

• Click the StaffMember.cs tab and change the class as follows:

  public class Driver
  {
    public string first_name;
    public string last_name;
  }

The Internal Members of a Class

Normally, when you create a class, you may want to access its members in various of the project. That is, you may want other classes of the same project to access one or more members of the class, but you may not want other projects to access such a member. If you want to create a member of a class so that only objects of the same project can access that member, you can mark it with the internal keyword.

Initializing an Object

The Period Operator

After creating a member of a class, to access it from another class, first declare a variable of its class as we know already. To actually access the member, use the period operator ".".

After declaring an instance of a class, you can access each of its members and assign it the desired value. Here is an example:

House prop = new House(); prop.PropertyType = "Condominium"; prop.Bedrooms = 2; prop.MarketValue = 165820; class House { public string PropertyType; public int Bedrooms; public double MarketValue; }

Once a field has been initialized, you can use the period operator to access it and retrieve its value:

using static System.Console;

House prop = new House();

prop.PropertyType = "Condominium";
prop.Bedrooms = 2;
prop.MarketValue = 165820;

WriteLine("=//= Altair Realtors =//=");
WriteLine("Properties Inventory");
Write("Property Type: ");
WriteLine(prop.PropertyType);
Write("Bedrooms: ");
WriteLine(prop.Bedrooms);
Write("Parmet Value: ");
WriteLine(prop.MarketValue);

class House
{
    public string PropertyType;
    public int    Bedrooms;
    public double MarketValue;
}

This would produce:

=//= Altair Realtors =//=
Properties Inventory
Property Type:  Condominium
Bedrooms: 2
Market Value:  165820
Press any key to continue . . .

Practical Learning: Using Classes

1. Click the PieceDelivery.cs tab and change its document as follows:

   using static System.Console;
   
   int miles;
   double pieceworkRate;
     
   Truck trk = new Truck();
   Driver drv = new Driver();
     
   drv.first_name = "Lilianne";
   drv.last_name = "Gleason";
   trk.make = "Ford";
   trk.model = "E-350 Rockport Cutaway";
   miles = 748;
   pieceworkRate = .47;
     
   WriteLine(" - Piece Work Delivery -");
   WriteLine("============================================");
   WriteLine("Driver:         " + drv.first_name + " " + drv.last_name);
   WriteLine("Truck Details:  " + trk.make + " " + trk.model);
   WriteLine("--------------------------------------------");
   WriteLine("Miles Driven:   {0}", miles);
   WriteLine("Piecework Rate: {0}", pieceworkRate);
   WriteLine("Gross Salary:   {0}", miles * pieceworkRate);
   WriteLine("============================================");

2. To execute, on the main menu, click Debug -> Start Without Debugging:

    - Piece Work Delivery -
   ============================================
   Driver:         Lilianne Gleason
   Truck Details:  Ford E-350 Rockport Cutaway
   --------------------------------------------
   Miles Driven:   748
   Piecework Rate: 0.47
   Gross Salary:   351.56
   ============================================
   Press any key to close this window . . .

3. To close the window and return to Microsoft Visual Studio, press G
4. To request values from a user, change the document as follows:

   using static System.Console;
   
   int miles;
   double pieceworkRate;
     
   Truck trk = new Truck();
   Driver drv = new Driver();
     
   drv.first_name = "Lilianne";
   drv.last_name = "Gleason";
   trk.make = "Ford";
   trk.model = "E-350 Rockport Cutaway";
     
   WriteLine("Enter the values for the delivery");
   Write("Miles Driven:   ");
   miles = int.Parse(ReadLine());
   Write("Piecework Rate: ");
   pieceworkRate = double.Parse(ReadLine());
     
   WriteLine(" - Piece Work Delivery -");
   WriteLine("============================================");
   WriteLine("Driver:         " + drv.first_name + " " + drv.last_name);
   WriteLine("Truck Details:  " + trk.make + " " + trk.model);
   WriteLine("--------------------------------------------");
   WriteLine("Miles Driven:   {0}", miles);
   WriteLine("Piecework Rate: {0}", pieceworkRate);
   WriteLine("Gross Salary:   {0}", miles * pieceworkRate);
   WriteLine("============================================");

5. To execute, on the main menu of Microsoft Visual Studio, click Debug -> Start Without Debugging...
6. For the number of Miles Driven, type 1137 and press Enter
7. Change the Piecework Rate, type 0.47 and press Enter:

   Enter the values for the delivery
   Miles Driven:   1137
   Piecework Rate: 0.47
    - Piece Work Delivery -
   ============================================
   Driver:         Lilianne Gleason
   Truck Details:  Ford E-350 Rockport Cutaway
   --------------------------------------------
   Miles Driven:   1137
   Piecework Rate: 0.47
   Gross Salary:   534.39
   ============================================
   Press any key to close this window . . .

8. Press B to close the window and return to your programming environment

Generating a Class

To create a class, you can also use skeleton code to start a class:

• In the section of the Code Editor where you want to add the class, right-click, position the mouse on Snippet and click Insert Snippet...

  

  Double-click Visual C#. In the list that appears, double-click class
• If you had already written code, such as declaring some variables, and you want to include that code in a new class, select that code. Right-click it, position the mouse on Snippet, and click Surround With...

  

  In the list that appears, double-click class

A class with the default name MyClass would be added. You can accept that name or change it.

Practical Learning: Ending the Lesson

• Close your programming environment

Previous	Copyright © 2001-2025, FunctionX	Monday 03 March 2025, 12:48	Next