Home

Introduction to Conditions

 

Introduction to Boolean Values

 

Introduction

In Lesson 3, we introduced numeric values and strings. And we have used those so far. A value is referred to as Boolean if it can be either true or false. As you may imagine, the essence of a Boolean value is to check that a condition is true or false, valid or invalid.

The Boolean Data Type

Like a number or a string, a Boolean value can be stored in a variable. To declare such a variable, use the Boolean keyword. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim EmployeeIsMarried As Boolean

        Return 0
    End Function

End Module

To actually use a Boolean variable, you can assign a value to it. By default, if you declare a Boolean variable but do not initialized it, it receives a value of False:

Public Module Exercise

    Public Function Main() As Integer
        Dim EmployeeIsMarried As Boolean

        MsgBox("Employee Is Married? " & EmployeeIsMarried)
        Return 0
    End Function

End Module

This would produce:

Boolean Variable

To initialize a Boolean variable, assign it a True or a False value. In the Visual Basic language, a Boolean variable can also deal with numeric values. The False value is equivalent to 0. For example, instead of False, you can initialize a Boolean variable with 0. Any other numeric value, whether positive or negative, corresponds to True:

Public Module Exercise

    Public Function Main() As Integer
        Dim EmployeeIsMarried As Boolean

        EmployeeIsMarried = -792730
        MsgBox("Employee Is Married? " & EmployeeIsMarried)
        Return 0
    End Function

End Module

The number can be decimal or exadecimal:

Public Module Exercise

    Public Function Main() As Integer
        Dim EmployeeIsMarried As Boolean

        EmployeeIsMarried = &HFA26B5
        MsgBox("Employee Is Married? " & EmployeeIsMarried)
        Return 0
    End Function

End Module

Boolean Values and Procedures

 

Introduction

As with the other data types that we have used so far, Boolean values can be involved with procedures. This means that a Boolean variable can be passed to a procedure and/or a function can be made to return a Boolean value. Some of the issues involved with procedures require conditional statements that we will study in the next lesson. Still, the basic functionality is possible with what we have learned so far.

Passing a Boolean Variable as Argument

 

Boolean Built-In Functions

 

Converting a Value to Date/Time

To assist you with validating some values or variables to true or false, the Visual Basic language provides many functions. First, to convert a value to Boolean, you can use the CBool() function. Its syntax is:

Function CBool(ByVal Expression As Object) As Boolean

Like all conversion functions, CBool takes one argument, the expression to be evaluate. It should produce a valid Boolean value. If it does, the function returns True or False.

Checking Whether a Value is Numeric

One of the most valuable operations you will perform on a value consists of finding out whether it is numeric or not. To assist you with this, the Visual Basic language provides a function named IsNumeric. Its syntax is:

Public Function IsNumeric(ByVal Expression As Object) As Boolean

This function takes as argument the value or expression to be evaluated. If the argument holds or can produce a valid integer or a decimal value, the function returns True. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Value As Object

        Value = 258.08 * 9920.3479

        MsgBox("Is Numeric? " & IsNumeric(Value))
        Return 0
    End Function

End Module

This would produce:

Is Numeric

If the argument is holding any other value that cannot be identified as a number, the function produces False. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim Value As Object

        Value = #12/4/1770#

        MsgBox("Is Numeric? " & IsNumeric(Value))
        Return 0
    End Function

End Module

This would produce:

Is Nothing

Checking for Valid Date/Time

To find out whether an expression holds a valid date, a valid, or not, you can call the IsDate() function. Its syntax is:

Public Function IsDate(ByVal Expression As Object) As Boolean

This function takes an argument as the expression to be evaluated. If the argument holds a valid date and/or time, the function returns True. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim DateHired As Object

        DateHired = "9/16/2001"
        MsgBox("Is Date? " & IsDate(DateHired))
        Return 0
    End Function

End Module

This would produce:

Is Date

If the value of the argument cannot be evaluated to a valid date or time, the function returns False. Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim DateHired As Object

        DateHired = "Who Knows?"
        MsgBox("Is Date? " & IsDate(DateHired))
        Return 0
    End Function

End Module

This would produce:

Is Date

Checking for Nothing

If you have a variable or an expression and want to find out whether it holds a Nothing value, you can call the IsNothing() function. Its syntax is:

Public Function IsNothing(ByVal Expression As Object) As Boolean

When calling this function, you can pass it a value or an expression. If the argument holds a valid value, this function returns False. If the argument does not hold a value, this function produces True.

Introduction to Enumerations

 

Introduction

An enumeration is a list of numeric values that each can be recognized by, or represented with, a name. To give you an example, imagine you are creating a list of items and want to classify each in a category. The list could be represented as follows:

Public Module Exercise

    Public Function Main() As Integer
        Dim SingleFamily As Integer
        Dim Townhouse As Integer
        Dim Condominium As Integer

        SingleFamily = 1
        Townhouse = 2
        Condominium = 3

        Return 0
    End Function

End Module

Using this approach, you can create a list of values where each member of the list holds a name but actually represents a number.

Creating an Enumeration

To create an enumeration, use the Enum keyword followed by a name. The creation of an enumeration must end with End Enum:

Enum MembershipType

End Enum

Between the Enum Name and the End Enum lines, you can enter the members of the enumeration following some rules:

  • The enumeration must be created outside of a procedure
  • Each member must be on its own line

Here is an example:

Public Module Exercise

    Enum HouseType
        SingleFamily
        Townhouse
        Condominium
    End Enum

End Module

After creating an enumeration, to use it, you can declare a variable from it. For example, you can declare a variable of a HouseType type as follows:

Public Module Exercise

    Enum HouseType
        SingleFamily
        Townhouse
        Condominium
    End Enum

    Public Function Main() As Integer

        Dim TypeOfHouse As HouseType

        Return 0
    End Function

End Module

After declaring such a variable, to initialize it, specify which member of the enumeration would be given to it. You should only assign a known member of the enumeration. To do this, on the right side of the assignment operator, type the name of the enumeration, followed by the period operator, and followed by the member whose value you want to assign. Here is an example:

Public Module Exercise

    Enum HouseType
        SingleFamily
        Townhouse
        Condominium
    End Enum

    Public Function Main() As Integer

        Dim TypeOfHouse As HouseType

        TypeOfHouse = HouseType.SingleFamily

        Return 0
    End Function

End Module

The Value of a Member of an Enumeration

To find out what value the variable is currently holding, you can access the variable. Here is an example:

Public Module Exercise

    Enum HouseType
        SingleFamily
        Townhouse
        Condominium
    End Enum

    Public Function Main() As Integer

        Dim TypeOfHouse As HouseType

        TypeOfHouse = HouseType.Townhouse

        MsgBox("Type of House: " & TypeOfHouse)

        Return 0
    End Function

End Module

This would produce:

Enumeration

Notice that the value of the member of the enumeration is given as a number. As mentioned already, an enumeration is in fact a list of constant numbers where each member of the list is identified with a name. By default, the first member of the list has a value of 0, the second has a value of 1, etc. Based on this, on the HouseType enumeration, The SingleFamily member has a value of 0, the Townhouse member has a value of 1, and the Condominium member has a value of 2. These are the default values. If you do not want these values, you can explicitly define the value of one or each member of the list.

Suppose you want the SingleFamily member in the above enumeration to have a value of 14. To do this, use the assignment operator "=" to give the desired value. Our enumeration would become:

Public Module Exercise

    Enum HouseType
        SingleFamily = 14
        Townhouse
        Condominium
    End Enum

End Module

In this case, the SingleFamily member now holds now a value of 14, the Townhouse member now holds a value of 15, and the Condominium member now has a value of 16. You can also assign a value to more than one member of an enumeration. Here is an example:

Public Module Exercise

    Enum HouseType
        SingleFamily = 14
        Townhouse = 25
        Condominium
    End Enum

End Module

This time, the SingleFamily member now holds now a value of 14, the Townhouse member now holds a value of 25, and the Condominium member now has a value of 26.

Enumerations are very useful in conditional statements as we will learn in the next lessons.

The Access Modifier of an Enumeration

You can control the access to an enumeration of a module. You can do this using the Private, the Friend, or the Public keywords: 

  • Private: If an enumeration is created as private, any procedure of the same module can access it
  • Friend: If an enumeration is created as a friend, any procedure of the same module or of the same project can access it. A procedures of another program cannot access that enumeration
  • Public: If an enumeration is created as a public, any procedure of the same project or a procedures from another project can access it

To specify the access level, type the desired keyword to the left of the Enum keyword. Here is an example:

Public Module Exercise

    Friend Enum HouseType
        SingleFamily = 14
        Townhouse = 62
        Condominium = 108
    End Enum

    Public Function Main() As Integer

        Dim TypeOfHouse As HouseType

        TypeOfHouse = HouseType.Townhouse

        MsgBox("Type of House: " & TypeOfHouse)

        Return 0
    End Function

End Module

Built-In Enumerations

 

Date/Time-Based Enumerations

In Lesson 7, we saw that, to add a value to a date or a time, you could call the DateAdd() function. One of its syntaxes was:

Public Overloads Function DateAdd( _
   ByVal Interval As DateInterval, _
   ByVal Number As Double, _
   ByVal DateValue As DateTime _
) As DateTime

The first argument of this function takes an argument that belongs to an enumeration named DateInterval. Instead of including a character or a combination of characters in double-quotes with the likelihood of a mistake, this enumeration makes it easy by allowing you to select a member of the enumeration and use an easily recognizable name. The members of the DateInterval enumeration are:

String Interval Enumeration Member Used To Add
s DateInterval.Second Second
n DateInterval.Minute Minute
h DateInterval.Hour Hour
w DateInterval.Weekday Numeric Weekday
ww DateInterval.WeekOfYear Week of the Year
d DateInterval.Day Day
y DateInterval.DayOfYear Numeric Day of the Year
m DateInterval.Month Month
q DateInterval.Quarter Quarter
yyyy DateInterval.Year Year

Notice that by using the DateInterval enumeration as argument, the selected interval is easier to select. Here are examples:

Public Module Exercise

    Public Function Main() As Integer

        Dim LoanStartDate As Date = #6/10/1998#
        Dim DepositTime As Date = TimeValue("7:14:00")

        MsgBox("Loan Length: " & DateAdd(DateInterval.Year, 5, LoanStartDate))
        MsgBox("Time Ready: " & DateAdd(DateInterval.Hour, 8, DepositTime))

        Return 0
    End Function

End Module

We also saw that we could use the DateDiff() function to get the difference between two date or time values. The syntax of the function is:

Public Overloads Function DateDiff( _
    ByVal Interval As [ DateInterval | String ], _
    ByVal Date1 As DateTime, _
    ByVal Date2 As DateTime, _
    Optional ByVal DayOfWeek As FirstDayOfWeek = FirstDayOfWeek.Sunday, _
    Optional ByVal  WeekOfYear As FirstWeekOfYear = FirstWeekOfYear.Jan1 _
) As Long

The first argument can be specified as a string. A better idea is to use a member of the DateInterval enumeration.

The last two arguments of this function are enumeration types. The fourth argument allows you to specify what day should be considered the first of the week. By default, in US English, the first day is Sunday. To change this, use a member of the FirstDayOfWeek enumeration. The members are:

Enumeration Member  Constant Value Description
FirstDayOfWeek.System 0 The compiler will refer to the operating system to find out what day should be the first. In US English, this should be Sunday 
FirstDayOfWeek.Sunday 1 Sunday (the default in US English) 
FirstDayOfWeek.Monday 2 Monday
FirstDayOfWeek.Tuesday 3 Tuesday
FirstDayOfWeek.Wednesday 4 Wednesday
FirstDayOfWeek.Thursday 5 Thursday
FirstDayOfWeek.Friday 6 Friday
FirstDayOfWeek.Saturday 7 Saturday 

By default, the first week of a year is the one that includes January 1st of that year. This is how it is considered in the regular date-based calculations. If you want to change this default setting, you can use the last argument of the DateDiff() function. The value of this argument is from an enumeration named FirstWeekofYear. The members of this enumeration are:

Enumeration Member  Constant Value Description
FirstWeekOfYear.System 0 The compiler will refer to the operating system to find out what day should be the first. This should be the week that includes January 1st 
FirstWeekOfYear.Jan1 1 This will be the week that includes January 1st
FirstWeekOfYear.FirstFourDays 2 This will be the first week that includes at least the first 4 days of the year
FirstWeekOfYear.FirstFullWeek 3 This will be the first week that includes the first 7 4 days of the year

Logical Operators

 

Introduction

A program is a series of instructions that ask the computer (actually the compiler) to check some situations and act accordingly. To check such situations, the computer spends a great deal of its time performing comparisons between values. A comparison is a Boolean operation that produces a True or a False result, depending on the values on which the comparison is performed.

A comparison is performed between two values of the same type For example, you can compare two numbers, two characters, or the names of two cities. On the other hand, a comparison between two disparate values does not bear any meaning. For example, it is difficult to compare a telephone number and somebody's age, or a music category and the distance between two points. Like the binary arithmetic operations, the comparison operations are performed on two values. Unlike arithmetic operations where results are varied, a comparison produces only one of two results. The result can be a logical true or a logical false.

The Visual Basic language is equipped with various operators used to perform any type of comparison between similar values. The values could be numeric, strings, or objects.

There are primary assumptions you should make when writing statements used in conditions:

  • Simplicity and Clarity: A statement should be clear enough and possibly simple but as complete as possible. When a statement becomes long, it can lead to being segmented in short parts, which deceives its clarity and may create other issues.
  • Factual: The statement must be presented as fact and not as opinion. This means that you do not have to like the statement but the majority, including you, must agree that it is true or it is false. In fact, the statement does not have to be correct but it must be agreed upon to be true. Based on this, a statement such as "An hour contains 45 minutes" doesn't have to fit your way of thinking but it must be considered as true or as false.
  • Circumstantial Truthfulness: At the time the statement is made, it must be considered as true or as false even if it can change at another time. For example, suppose that, in a certain year, a statement is formulated as "This year, the month of February has 28 days". Although allowed, you should refrain from regularly using circumstantial truthfulness, unless you have to.
  • Inverse: A statement must be able to find its reverse. This means that, when a statement is made and decided upon to be true or false, an inverse statement must be found to make it false or true. For example, if you have a statement such as "This job applicant is 18 years old", you must be able to state that "This job applicant is not 18 years old" or "This job applicant is younger than 18".

In your programs, make sure you clearly formulate your statements. This would make your programs easy to read and troubleshoot when problems occur (not if, but when).

Equality =

To compare two variables for equality, use the = operator. Its formula is:

Value1 = Value2

The equality operation is used to find out whether two variables (or one variable and a constant) hold the same value. From our formula, the value of Value1 would be compared with the value of Value2. If Value1 and Value2 hold the same value, the comparison produces a True result. If they are different, the comparison renders false or 0:

The comparison for equality

 

Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim IsFullTime As Boolean

        MsgBox("Is Employee Full Time? " & IsFullTime)

        IsFullTime = True

        MsgBox("Is Employee Full Time? " & IsFullTime)

        Return 0
    End Function

End Module

This would produce:

Equality

Equality

Inequality <>

As opposed to checking for equality, you may instead want to know whether two values are different. The operator used to perform this comparison is <> and its formula is:

Variable1 <> Variable2

The comparison for inequality

If the operands on both sides of the operator are the same, the comparison renders false. If both operands hold different values, then the comparison produces a true result. This also shows that the equality = and the inequality <> operators are opposite.

A Lower Value <

To find out whether one value is lower than another, use the < operator. Its syntax is:

Value1 < Value2

The value held by Value1 is compared to that of Value2. As it would be done with other operations, the comparison can be made between two variables, as in Variable1 < Variable2. If the value held by Variable1 is lower than that of Variable2, the comparison produces a True.

Flowchart: Less Than

Here is an example:

Public Module Exercise

    Public Function Main() As Integer
        Dim PartTimeSalary, ContractorSalary As Double
        Dim IsLower As Boolean

        PartTimeSalary = 20.15
        ContractorSalary = 22.48
        IsLower = PartTimeSalary < ContractorSalary

        MsgBox("Part Time Salary: " & vbTab & PartTimeSalary & vbCrLf & _
               "Contractor Salary: " & vbTab & ContractorSalary & vbCrLf & _
               "Is PartTimeSalary < ContractorSalary? " & vbTab & IsLower)

        PartTimeSalary = 25.55
        ContractorSalary = 12.68
        IsLower = PartTimeSalary < ContractorSalary

        MsgBox("Part Time Salary: " & vbTab & PartTimeSalary & vbCrLf & _
               "Contractor Salary: " & vbTab & ContractorSalary & vbCrLf & _
               "Is PartTimeSalary < ContractorSalary? " & vbTab & IsLower)

        Return 0
    End Function

End Module

This would produce:

Less Than

Less Than

Equality and Lower Value <=

The previous two operations can be combined to compare two values. This allows you to know if two values are the same or if the first is less than the second. The operator used is <= and its syntax is:

Value1 <= Value2

The <= operation performs a comparison as any of the last two. If both Value1 and VBalue2 hold the same value, result is true or positive. If the left operand, in this case Value1, holds a value lower than the second operand, in this case Value2, the result is still true:

Less than or equal to

 

Greater Value >

When two values of the same type are distinct, one of them is usually higher than the other. The Visual Basic language provides a logical operator that allows you to find out if one of two values is greater than the other. The operator used for this operation uses the > symbol. Its syntax is:

Value1 > Value2

Both operands, in this case Value1 and Value2, can be variables or the left operand can be a variable while the right operand is a constant. If the value on the left of the > operator is greater than the value on the right side or a constant, the comparison produces a True value. Otherwise, the comparison renders False or null.

 

Greater Than

Here is an example:

Imports System

Public Module Exercise

    Sub Main()
        Dim PartTimeSalary, ContractorSalary As Double
        Dim IsLower As Boolean

        PartTimeSalary = 20.15
        ContractorSalary = 22.48
        IsLower = PartTimeSalary > ContractorSalary

        Console.WriteLine("Part Time Salary:  {0}", PartTimeSalary)
        Console.WriteLine("Contractor Salary: {0}", ContractorSalary)
        Console.WriteLine("Is PartTimeSalary > ContractorSalary? {0}", IsLower)

        PartTimeSalary = 25.55
        ContractorSalary = 12.68
        IsLower = PartTimeSalary > ContractorSalary

        Console.WriteLine()
        Console.WriteLine("Part Time Salary:  {0}", PartTimeSalary)
        Console.WriteLine("Contractor Salary: {0}", ContractorSalary)
        Console.WriteLine("Is PartTimeSalary > ContractorSalary? {0}", IsLower)

        Console.WriteLine()
    End Sub

End Module

This would produce:

Part Time Salary:  20.15
Contractor Salary: 22.48
Is PartTimeSalary > ContractorSalary? False

Part Time Salary:  25.55
Contractor Salary: 12.68
Is PartTimeSalary > ContractorSalary? True

 

Greater or Equal Value >=

The greater than or the equality operators can be combined to produce an operator as follows: >=. This is the "greater than or equal to" operator. Its syntax is:

Value1 >= Value2

A comparison is performed on both operands: Value1 and Value2. If the value of Value1 and that of Value2 are the same, the comparison produces a True value. If the value of the left operand is greater than that of the right operand, the comparison still produces True. If the value of the left operand is strictly less than the value of the right operand, the comparison produces a False result.

 

Greater Than Or Equal
 

 

Enumerations

 

Introduction

Consider that, when creating a program for a real estate company that sells houses, you want the program to ask a customer the type of house that he or she wants to purchase and/or the type of garage that the desired house should have. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
        int TypeOfHouse = 0;
        int TypeOfGarage = 0;

        Console.WriteLine("Enter the type of house you want to purchase");
        Console.WriteLine("1 - Single Family");
        Console.WriteLine("2 - Townhouse");
        Console.WriteLine("3 - Condominium");
        Console.Write("Your Choice: ");
        TypeOfHouse = int.Parse(Console.ReadLine());

        Console.WriteLine("Enter the type of garage you want");
        Console.WriteLine("0 - Doesn't matter");
        Console.WriteLine("1 - Interior");
        Console.WriteLine("2 - Exterior");
        Console.Write("Your Choice: ");
        TypeOfGarage = int.Parse(Console.ReadLine());

        Console.WriteLine("\nHouse Type: {0}", TypeOfHouse);
        Console.WriteLine("Garage Type:  {0}", TypeOfGarage);

        return 0;
    }
}

Here is an example of running the program:

Enter the type of house you want to purchase
1 - Single Family
2 - Townhouse
3 - Condominium
Your Choice: 3
Enter the type of garage you want
0 - Doesn't matter
1 - Interior
2 - Exterior
Your Choice: 1

House Type:  3
Garage Type: 1
Press any key to continue . . .

For such a program, the numbers can be vague. 1 can be considered a general number but, in our program, it can represent a Single Family house or an Interior type of garage. At the same time, our program uses the constant 1 in particular meaningful ways. To make it possible to give more meaning to a constant number, when the number can be made part of a series, C# allows you to create a type of list.

An enumeration is a series of constant integers that each has a specific position in the list and can be recognized by a meaningful name. Based on this, instead of just remembering that the constant 1 represents Single Family, you can create a list that has that type of house. In another list, instead of using 1 again, you can give it a name. Consequently, in each list, although the constant 1 would still be considered, at least it would mean something precise.

To create an enumeration, you use the enum keyword, followed by the name of the enumeration, followed by a name for each item of the list. The name of the enumerator and the name of each item of the list follows the rules we reviewed for names. The formula of creating an enumeration is:

enum Series_Name {Item1, Item2, Item_n};

Here is an example:

using System;

public class Exercise
{
    enum HouseType { Unknown, SingleFamily, TownHouse, Condominium }
    
    static int Main()
    {
        return 0;
    }
}

Declaring an Enumeration Variable

After creating an enumeration, each member of the enumeration holds a value of a natural number, such as 0, 4, 12, 25, etc. In C#, an enumeration cannot hold character values (of type char). After creating an enumeration, you can declare a variable from it. Here is an example:

using System;

public class Exercise
{
    enum HouseType { Unknown, SingleFamily, TownHouse, Condominium }
    
    static int Main()
    {
        HouseType propType;

        return 0;
    }
}

Just as done with the other types, you can use the var keyword to declare a variable of an enumeration type.

Initializing an Enumeration Variable

After declaring a variable for an enumeration, to initialize it, specify which member of the enumeration would be assigned to the variable. You should only assign a known member of the enumeration. To do this, on the right side of the assignment operator, type the name of the enumeration, followed by the period operator, and followed by the member whose value you want to assign. Here is an example:

using System;

public class Exercise
{
    enum HouseType { Unknown, SingleFamily, TownHouse, Condominium }
    
    static int Main()
    {
        var propType = HouseType.SingleFamily;

        return 0;
    }
}

You can also find out what value the declared variable is currently holding. For example, you can display it on the console using Write() or WriteLine(). Here is an example:

using System;

public class Exercise
{
    enum HouseType { Unknown, SingleFamily, TownHouse, Condominium }
    
    static int Main()
    {
        var propType = HouseType.SingleFamily;

        Console.WriteLine("House Type:  {0}", propType);

        return 0;
    }
}

This would produce:

House Type:  SingleFamily
Press any key to continue . . .

An enumeration is in fact a list of numbers where each member of the list is identified with a name. By default, the first item of the list has a value of 0, the second has a value of 1, and so on. For example, on the HouseType enumeration, Unknown has a value of 0 while Townhouse has a value of 2. These are the default values. If you don't want these values, you can specify the value of one or each member of the list. Suppose you want the Unknown member in the above enumeration to have a value of 5. To do this, use the assignment operator "=" to give the desired value. The enumerator would be:

using System;

public class Exercise
{
    enum HouseType { Unknown = 5, SingleFamily, TownHouse, Condominium }
    
    static int Main()
    {
        return 0;
    }
}

In this case, Unknown now would have a value of 5, SingleFamily would have a value of 6 because it follows a member whose value is 1 (thus 5 + 1 = 6). Townhouse would have a value of 7, and Condominium would have a value of 8. You can also assign a value to more than one member of an enumeration. Here is an example:

using System;

public class Exercise
{
    enum HouseType { Unknown = 3, SingleFamily = 12, TownHouse, Condominium = 8 }
    
    static int Main()
    {
        return 0;
    }
}

In this case, Townhouse would have a value of 13 because it follows SingleFamily that has a value of 12.

Enumerations Visibility

By default, if you create an enumeration the way we have proceeded so far, it would be available only in the project it belongs to. As done for a class, you can control an enumeration's accessibility outside of its project. This means that you can hide or make it visible outside of its project. To do this, you can precede it with the private or the public keyword. Here is an example:

using System;

public class Exercise
{
    public enum HouseType
    {
        Unknown,
        SingleFamily,
        TownHouse,
        Condominium
    }
    
    static int Main()
    {
        HouseType propType = HouseType.SingleFamily;

        Console.WriteLine("House Type:  {0}", propType);
        return 0;
    }
}

An Enumeration as a Member Variable

After creating an enumeration, you can use it as a data type to declare a variable. To create a field that is of an enumeration type, follow the same rules as done for the primitive types: the name of the enumeration, followed by the name of the variable, and followed by a semi-colon. Here is an example:

public enum HouseType
{
    Unknown,
    SingleFamily,
    TownHouse,
    Condominium
}

public class House
{
    HouseType PropertyType;
}

In the same way, you can declare as many enumeration variables as you want. After declaring the variable, to initialize it, assign it the desired member of the enumeration. Here is an example:

public enum HouseType
{
    Unknown,
    SingleFamily,
    TownHouse,
    Condominium
}

public class House
{
    HouseType PropertyType;

    public House()
    {
        PropertyType = HouseType.Unknown;
    }
}

Once the member variable has been initialized, you can use it as you see fit as we will learn and practice in future sections and lessons. At a minimum, you can pass it to Write() or WriteLine() to display its value. Here is an example:

using System;

public enum HouseType
{
    Unknown,
    SingleFamily,
    TownHouse,
    Condominium
}

public class House
{
    public HouseType PropertyType;

    public House()
    {
        PropertyType = HouseType.Unknown;
    }

    public void Display()
    {
        Console.WriteLine("Property Type: {0}", PropertyType);
    }
}

public class Exercise
{
    static int Main()
    {
        var propType = new House();
        propType.Display();
        Console.WriteLine();

        propType.PropertyType = HouseType.SingleFamily;
        propType.Display();
        Console.WriteLine();

	return 0;
    }
}

This would produce:

Property Type: Unknown

Property Type: SingleFamily

Press any key to continue . . .

Using it as normal data type, you can create a method that returns an enumeration. You can also pass an enumeration to a method as argument.

Practical LearningPractical Learning: Creating and Using Enumerations

  1. Access the Flower.cs file
  2. To create some enumerations, change the file as follows:
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FlowerShop1
    {
        public enum FlowerType
        {
            Roses = 1,
            Lilies,
            Daisies,
            Carnations,
            LivePlant,
            Mixed
        }
    
        public enum FlowerColor
        {
            Red = 1,
            White,
            Yellow,
            Pink,
            Orange,
            Blue,
            Lavender,
            Mixed
        }
    
        public enum FlowerArrangement
        {
            Bouquet = 1,
            Vase,
            Basket,
            Mixed
        }
    
        public class Flower
        {
            public FlowerType Type;
            public FlowerColor Color;
            public FlowerArrangement Arrangement;
            public decimal UnitPrice;
    
            public Flower()
            {
                Type = FlowerType.Mixed;
                Color = FlowerColor.Mixed;
                Arrangement = FlowerArrangement.Vase;
                UnitPrice = 0.00M;
            }
            public Flower(FlowerType type)
            {
                Type = type;
                Color = FlowerColor.Mixed;
                Arrangement = FlowerArrangement.Vase;
                UnitPrice = 0.00M;
            }
            public Flower(FlowerType type, FlowerColor color,
                    FlowerArrangement argn, decimal price)
            {
                Type = type;
                Color = color;
                Arrangement = argn;
                UnitPrice = price;
            }
        }
    }
  3. Access the Program.cs file
  4. To use the enumerations, change the file as follows:
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FlowerShop1
    {
        public class Program
        {
            private static OrderProcessing CreateFlowerOrder()
            {
                OrderProcessing order = new OrderProcessing();
                int type, color, qty;
                int arrangement;
                decimal price;
    
                Console.WriteLine("=======================");
                Console.WriteLine("==-=-=Flower Shop=-=-==");
                Console.WriteLine("-----------------------");
    
                Console.WriteLine("Enter the Type of Flower Order");
                Console.WriteLine("1. Roses");
                Console.WriteLine("2. Lilies");
                Console.WriteLine("3. Daisies");
                Console.WriteLine("4. Carnations");
                Console.WriteLine("5. Live Plant");
                Console.WriteLine("6. Mixed");
                Console.Write("Your Choice: ");
                type = int.Parse(Console.ReadLine());
    
                Console.WriteLine("Enter the Color");
                Console.WriteLine("1. Red");
                Console.WriteLine("2. White");
                Console.WriteLine("3. Yellow");
                Console.WriteLine("4. Pink");
                Console.WriteLine("5. Orange");
                Console.WriteLine("6. Blue");
                Console.WriteLine("7. Lavender");
                Console.WriteLine("8. Mixed");
                Console.Write("Your Choice: ");
                color = int.Parse(Console.ReadLine());
    
                Console.WriteLine("Enter the Type of Arrangement");
                Console.WriteLine("1. Bouquet");
                Console.WriteLine("2. Vase");
                Console.WriteLine("3. Basket");
                Console.WriteLine("4. Mixed");
                Console.Write("Your Choice: ");
                arrangement = int.Parse(Console.ReadLine());
    
                Console.Write("Enter the Unit Price: ");
                price = decimal.Parse(Console.ReadLine());
    
                Console.Write("Enter Quantity:       ");
                qty = int.Parse(Console.ReadLine());
    
                Flower flr = new Flower((FlowerType)type,
                                        (FlowerColor)color,
                                        (FlowerArrangement)arrangement,
                                        price);
                order.FlowerOrder = flr;
                order.Quantity = qty;
    
                return order;
            }
    
            private static void ShowFlowerOrder(OrderProcessing order)
            {
                Console.WriteLine("=======================");
                Console.WriteLine("==-=-=Flower Shop=-=-==");
                Console.WriteLine("-----------------------");
                Console.WriteLine("Flower Type:  {0}", order.FlowerOrder.Type);
                Console.WriteLine("Flower Color: {0}", order.FlowerOrder.Color);
                Console.WriteLine("Arrangement:  {0}", 
    		order.FlowerOrder.Arrangement);
                Console.WriteLine("Price:        {0:C}", 
    		order.FlowerOrder.UnitPrice);
                Console.WriteLine("Quantity:     {0}", order.Quantity);
                Console.WriteLine("Total Price:  {0:C}", order.GetTotalPrice());
                Console.WriteLine("=======================");
            }
    
            static void Main(string[] args)
            {
                OrderProcessing flower = CreateFlowerOrder();
                Console.WriteLine();
    
                ShowFlowerOrder(flower);
                Console.WriteLine();
            }
        }
    }
  5. Execute the application and process an order. Here is an example:
     
    =======================
    ==-=-=Flower Shop=-=-==
    -----------------------
    Enter the Type of Flower Order
    1. Roses
    2. Lilies
    3. Daisies
    4. Carnations
    5. Live Plant
    6. Mixed
    Your Choice: 5
    Enter the Color
    1. Red
    2. White
    3. Yellow
    4. Pink
    5. Orange
    6. Blue
    7. Lavender
    8. Mixed
    Your Choice: 7
    Enter the Type of Arrangement
    1. Bouquet
    2. Vase
    3. Basket
    4. Mixed
    Your Choice: 3
    Enter the Unit Price: 35.95
    Enter Quantity:       4
    
    =======================
    ==-=-=Flower Shop=-=-==
    -----------------------
    Flower Type:  LivePlant
    Flower Color: Lavender
    Arrangement:  Basket
    Price:        $35.95
    Quantity:     4
    Total Price:  $143.80
    =======================
    
    Press any key to continue . . .
  6. Close the DOS window

Boolean Variables

 

Introduction

When interacting with a computer, a user submits values to a running application. Some of these values are valid. Some other values must be rejected or changed. To take care of these, the values must be checked, examined, re-examined, etc. The validity of a value is checked against its type. For example, a number can be checked as being equal to another. A condition can be checked as being true. A measure can be checked as to whether it is higher than a certain threshold.

To perform the necessary validations of values, the C# language provides some symbols, referred to as Boolean operators. 

Practical LearningPractical Learning: Introducing Boolean Variables

  1. Start Microsoft Visual C#
  2. Create a new Console Application named FlowerShop1
  3. To create a new class, on the main menu, click Project -> Add Class...
  4. Set the Name of the class to Flower and click Add
  5. Complete the Flower.cs file as follows:
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FlowerShop1
    {
        public class Flower
        {
            public int Type;
            public int Color;
            public char Arrangement;
            public decimal UnitPrice;
    
            public Flower()
            {
                Type = 0;
                Color = 0;
                Arrangement = 'B';
                UnitPrice = 0.00M;
            }
    
            public Flower(int type)
            {
                Type = type;
                Color = 0;
                Arrangement = 'B';
                UnitPrice = 0.00M;
            }
    
            public Flower(int type, int color,
                    char argn, decimal price)
            {
                Type = type;
                Color = color;
                Arrangement = argn;
                UnitPrice = price;
            }
        }
    }
  6. To create a new class, in the Solution Explorer, right-click the project name, position the mouse on Add and click Class...
  7. Set the Name of the class to OrderProcessing and click Add
  8. Complete the OrderProcessing.cs file as follows:
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FlowerShop1
    {
        public class OrderProcessing
        {
            public OrderProcessing()
            {
                FlowerOrder = new Flower();
            }
    
            public Flower FlowerOrder;
            public int Quantity;
    
            public decimal GetTotalPrice()
            {
                return Quantity * FlowerOrder.UnitPrice;
            }
        }
    }
  9. Access the Program.cs file and complete it as follows:
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace FlowerShop1
    {
        public class Program
        {
            private static OrderProcessing CreateFlowerOrder()
            {
                OrderProcessing order = new OrderProcessing();
                int type, color, qty;
                char arrangement;
                decimal price;
    
                Console.WriteLine("=======================");
                Console.WriteLine("==-=-=Flower Shop=-=-==");
                Console.WriteLine("-----------------------");
    
                Console.WriteLine("Enter the Type of Flower Order");
                Console.WriteLine("1. Roses");
                Console.WriteLine("2. Lilies");
                Console.WriteLine("3. Daisies");
                Console.WriteLine("4. Carnations");
                Console.WriteLine("5. Live Plant");
                Console.WriteLine("6. Mixed");
                Console.Write("Your Choice: ");
                type = int.Parse(Console.ReadLine());
    
                Console.WriteLine("Enter the Color");
                Console.WriteLine("1. Red");
                Console.WriteLine("2. White");
                Console.WriteLine("3. Yellow");
                Console.WriteLine("4. Pink");
                Console.WriteLine("5. Orange");
                Console.WriteLine("6. Blue");
                Console.WriteLine("7. Lavender");
                Console.WriteLine("8. Mixed");
                Console.Write("Your Choice: ");
                color = int.Parse(Console.ReadLine());
    
                Console.WriteLine("Enter the Type of Arrangement");
                Console.WriteLine("U. Bouquet");
                Console.WriteLine("V. Vase");
                Console.WriteLine("B. Basket");
                Console.WriteLine("M. Mixed");
                Console.Write("Your Choice: ");
                arrangement = char.Parse(Console.ReadLine());
    
                Console.Write("Enter the Unit Price: ");
                price = decimal.Parse(Console.ReadLine());
    
                Console.Write("Enter Quantity:       ");
                qty = int.Parse(Console.ReadLine());
    
                Flower flr = new Flower(type, color, arrangement, price);
                order.FlowerOrder = flr;
                order.Quantity = qty;
    
                return order;
            }
    
            private static void ShowFlowerOrder(OrderProcessing order)
            {
                Console.WriteLine("=======================");
                Console.WriteLine("==-=-=Flower Shop=-=-==");
                Console.WriteLine("-----------------------");
                Console.WriteLine("Flower Type:  {0}", 
    		order.FlowerOrder.Type);
                Console.WriteLine("Flower Color: {0}", 
    		order.FlowerOrder.Color);
                Console.WriteLine("Arrangement:  {0}", 
    		order.FlowerOrder.Arrangement);
                Console.WriteLine("Price:        {0:C}", 
    		order.FlowerOrder.UnitPrice);
                Console.WriteLine("Quantity:     {0}", order.Quantity);
                Console.WriteLine("Total Price:  {0:C}", 
    		order.GetTotalPrice());
                Console.WriteLine("=======================");
            }
    
            static void Main(string[] args)
            {
                OrderProcessing flower = CreateFlowerOrder();
                Console.WriteLine();
    
                ShowFlowerOrder(flower);
                Console.WriteLine();
            }
        }
    }
  10. Execute the application and test it. Here is an example:
     
    =======================
    ==-=-=Flower Shop=-=-==
    -----------------------
    Enter the Type of Flower Order
    1. Roses
    2. Lilies
    3. Daisies
    4. Carnations
    5. Live Plant
    6. Mixed
    Your Choice: 4
    Enter the Color
    1. Red
    2. White
    3. Yellow
    4. Pink
    5. Orange
    6. Blue
    7. Lavender
    8. Mixed
    Your Choice: 6
    Enter the Type of Arrangement
    U. Bouquet
    V. Vase
    B. Basket
    M. Mixed
    Your Choice: V
    Enter the Unit Price: 37.95
    Enter Quantity:       2
    
    =======================
    ==-=-=Flower Shop=-=-==
    -----------------------
    Flower Type:  4
    Flower Color: 6
    Arrangement:  V
    Price:        $37.95
    Quantity:     2
    Total Price:  $75.90
    =======================
    
    Press any key to continue . . .
  11. Close the DOS window

Declaring a Boolean Variable

A variable is referred to as Boolean if it can hold a value that is either true or false. To declare a Boolean variable, you can use either the var or the bool keyword. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
        bool DrinkingUnderAge;

	return 0;
    }
}

Alternatively, you can declare a Boolean variable using the Boolean data type. The Boolean data type is part of the System namespace. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
        bool DrinkingUnderAge;
    	Boolean TheFloorIsCoveredWithCarpet;

	return 0
    }
}

After the variable has been declared, you must initialize it with a true or a false value. In fact, if you declare it as var, you must initialize it. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
        var DrinkingUnderAge = true;

        return 0;
    }
}

To display the value of a Boolean variable on the console, you can type its name in the parentheses of the Write() or the WriteLine() methods of the Console class. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
        var DrinkingUnderAge = true;

        Console.WriteLine("Drinking Under Age: {0}", DrinkingUnderAge);
        return 0;
    }
}

This would produce:

Drinking Under Age: True
Press any key to continue . . .

At any time and when you judge it necessary, you can change the value of the Boolean variable by assigning it a true or false value. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
        var DrinkingUnderAge = true;

        Console.WriteLine("Drinking Under Age: {0}", DrinkingUnderAge);

        DrinkingUnderAge = false;
        Console.WriteLine("Drinking Under Age: {0}", DrinkingUnderAge);
        return 0;
    }
}

This would produce:

Drinking Under Age: True
Drinking Under Age: False
Press any key to continue . . .

Retrieving the Value of a Boolean Variable

As reviewed for the other data types, you can request the value of a Boolean variable from the user. In this case, the user must type either True (or true) or False (or false) and you can retrieve it using the Read() or the ReadLine() methods of the Console class. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
        var DrivingUnderAge = false;

        Console.WriteLine("Were you driving under age?");
        Console.Write("If Yes, enter True. Otherwise enter False: ");
        DrivingUnderAge = bool.Parse(Console.ReadLine());

        Console.WriteLine("\nWas Driving Under Age: {0}\n", DrivingUnderAge);
        return 0;
    }
}

Here is an example of running the program:

Were you driving under age?
If Yes, enter True. Otherwise enter False: true

Was Driving Under Age: True

Press any key to continue . . .

Creating a Boolean Field

Like the other types of variables we used in previous lessons, a Boolean variable can be made a field of a class. You declare it like any other variable, using the bool keyword or the Boolean data type. Here is an example:

public class House
{
    public char TypeOfHome;
    public int Bedrooms;
    public float Bathrooms;
    public byte Stories;
    public bool HasCarGarage;
    public int YearBuilt;
    public double Value;
}

When initializing an object that has a Boolean variable as a member, simply assign true or false to the variable. In the same way, you can retrieve or check the value that a Boolean member variable is holding by simply accessing it. Here are examples:

using System;

public class House
{
    public char TypeOfHome;
    public int Bedrooms;
    public float Bathrooms;
    public byte Stories;
    public bool HasCarGarage;
    public int YearBuilt;
    public double Value;
}

public class Program
{
    static int Main()
    {
        var Condominium = new
        {
            HasCarGarage = false,
            YearBuilt = 2002,
            Bathrooms = 1.5F,
            Stories = 18,
            Value = 155825,
            Bedrooms = 2,
            TypeOfHome = 'C'
        };

        Console.WriteLine("=//= Altair Realty =//=");
        Console.WriteLine("=== Property Listing ===");
        Console.WriteLine("Type of Home:        {0}", Condominium.TypeOfHome);
        Console.WriteLine("Number of Bedrooms:  {0}", Condominium.Bedrooms);
        Console.WriteLine("Number of Bathrooms: {0}", Condominium.Bathrooms);
        Console.WriteLine("Number of Stories:   {0}", Condominium.Stories);
        Console.WriteLine("Year Built:          {0}", Condominium.YearBuilt);
        Console.WriteLine("Has Car Garage:      {0}", Condominium.HasCarGarage);
        Console.WriteLine("Monetary Value:      {0}\n", Condominium.Value);

        return 0;
    }
}

This would produce:

=//= Altair Realty =//=
=== Property Listing ===
Type of Home:        C
Number of Bedrooms:  2
Number of Bathrooms: 1.5
Number of Stories:   18
Year Built:          2002
Has Car Garage:      False
Monetary Value:      155825

Press any key to continue . . .

Boolean Arguments

Like parameters of the other types, you can pass an argument of type bool or Boolean to a method. Such an argument would be treated as holding a true or false value.

The Equality Operator ==

To compare two variables for equality, C# uses the == operator. The formula used is:

Value1 == Value2

The equality operation is used to find out whether two variables (or one variable and a constant) hold the same value. From our syntax, the compiler would compare the value of Value1 with that of Value2. If Value1 and Value2 hold the same value, the comparison produces a true result. If they are different, the comparison renders false.

Most of the comparisons performed in C# will be applied to conditional statements. The result of a comparison can also be assigned to a variable. To store the result of a comparison, you should include the comparison operation between parentheses. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
	var Value1 = 15;
	var Value2 = 24;

	Console.Write("Value 1 = ");
	Console.WriteLine(Value1);
	Console.Write("Value 2 = ");
	Console.WriteLine(Value2);
	Console.Write("Comparison of Value1 == 15 produces ");
	Console.WriteLine(Value1 == 15);

        return 0;
    }
}

This would produce:

Value 1 = 15
Value 2 = 24
Comparison of Value1 == 15 produces True

It is important to make a distinction between the assignment "=" and the logical equality operator "==". The first is used to give a new value to a variable, as in Number = 244. The operand on the left side of = must always be a variable and never a constant. The == operator is never used to assign a value; this would cause an error. The == operator is used only to compare to values. The operands on both sides of == can be variables, constants, or one can be a variable while the other is a constant. If you use one operator in place of the other, you would receive an error when you compile the program.

The Logical Not Operator !

When a variable is declared and receives a value (this could be done through initialization or a change of value) in a program, it becomes alive. It can then participate in any necessary operation. The compiler keeps track of every variable that exists in the program being processed. When a variable is not being used or is not available for processing (in visual programming, it would be considered as disabled) to make a variable (temporarily) unusable, you can nullify its value. C# considers that a variable whose value is null is stern. To render a variable unavailable during the evolution of a program, apply the logical not operator which is !. Its syntax is:

!Value

There are two main ways you can use the logical not operator. As we will learn when studying conditional statements, the most classic way of using the logical not operator is to check the state of a variable.

To nullify a variable, you can write the exclamation point to its left. Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
	bool HasAirCondition = true;
	bool DoesIt;

	Console.Write("HasAirCondition = ");
	Console.WriteLine(HasAirCondition);
	DoesIt = !HasAirCondition;
	Console.Write("DoesIt          = ");
	Console.WriteLine(DoesIt);

        return 0;
    }
}

This would produce:

HasAirCondition = True
DoesIt          = False

When a variable holds a value, it is "alive". To make it not available, you can "not" it. When a variable has been "notted", its logical value has changed. If the logical value was true, which is 1, it would be changed to false, which is 0. Therefore, you can inverse the logical value of a variable by "notting" or not "notting" it.

The Inequality Operator !=

As opposed to Equality, C# provides another operator used to compare two values for inequality. This operation uses a combination of equality and logical not operators. It combines the logical not ! and a simplified == to produce !=. Its syntax is:

Value1 != Value2

The != is a binary operator (like all logical operator except the logical not, which is a unary operator) that is used to compare two values. The values can come from two variables as in Variable1 != Variable2. Upon comparing the values, if both variables hold different values, the comparison produces a true or positive value. Otherwise, the comparison renders false or a null value:

Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
	var Value1 = 212;
	var Value2 = -46;
	var Value3 = (Value1 != Value2);

	Console.Write("Value1 = ");
	Console.WriteLine(Value1);
	Console.Write("Value2 = ");
	Console.WriteLine(Value2);
	Console.Write("Value3 = ");
	Console.Write(Value3);
	Console.WriteLine();

        return 0;
    }
}

The inequality is obviously the opposite of the equality.

The Comparison for a Lower Value <

To find out whether one value is lower than another, use the < operator. Its syntax is:

Value1 < Value2

The value held by Value1 is compared to that of Value2. As it would be done with other operations, the comparison can be made between two variables, as in Variable1 < Variable2. If the value held by Variable1 is lower than that of Variable2, the comparison produces a true or positive result.

Flowchart: Less Than

Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
	var Value1 = 15;
	var Value2 = (Value1 < 24);

	Console.Write("Value 1 = ");
	Console.WriteLine(Value1);	
	Console.Write("Value 2 = ");
	Console.WriteLine(Value2);
	Console.WriteLine();

        return 0;
    }
}

This would produce:

Value 1 = 15
Value 2 = True

Combining Equality and Lower Value <=

The previous two operations can be combined to compare two values. This allows you to know if two values are the same or if the first is less than the second. The operator used is <= and its syntax is:

Value1 <= Value2

The <= operation performs a comparison as any of the last two. If both Value1 and VBalue2 hold the same value, result is true or positive. If the left operand, in this case Value1, holds a value lower than the second operand, in this case Value2, the result is still true.

Less Than Or Equal

Here is an example:

using System;

public class Exercise
{
    static int Main()
    {
	var Value1 = 15;
	var Value2 = (Value1 <= 24);

	Console.Write("Value 1 = ");
	Console.WriteLine(Value1);	
	Console.Write("Value 2 = ");
	Console.WriteLine(Value2);
	Console.WriteLine();

        return 0;
    }
}

This would produce:

Value 1 = 15
Value 2 = True

The Comparison for a Greater Value >

When two values of the same type are distinct, one of them is usually higher than the other. C# provides a logical operator that allows you to find out if one of two values is greater than the other. The operator used for this operation uses the > symbol. Its syntax is:

Value1 > Value2

Both operands, in this case Value1 and Value2, can be variables or the left operand can be a variable while the right operand is a constant. If the value on the left of the > operator is greater than the value on the right side or a constant, the comparison produces a true or positive value . Otherwise, the comparison renders false or null:

Greater Than

 

The Greater Than or Equal Operator >=

The greater than or the equality operators can be combined to produce an operator as follows: >=. This is the "greater than or equal to" operator. Its syntax is:

Value1 >= Value2

A comparison is performed on both operands: Value1 and Value2. If the value of Value1 and that of Value2 are the same, the comparison produces a true or positive value. If the value of the left operand is greater than that of the right operand,, the comparison produces true or positive also. If the value of the left operand is strictly less than the value of the right operand, the comparison produces a false or null result:

Flowchart: Greater Than Or Equal To

Here is a summary table of the logical operators we have studied:

 
Operator Meaning Example Opposite
== Equality to a == b !=
!= Not equal to 12 != 7 ==
< Less than 25 < 84 >=
<= Less than or equal to Cab <= Tab >
> Greater than 248 > 55 <=
>= Greater than or equal to Val1 >= Val2 <
 

Logically Incrementing or Decrementing a Value

 

Incrementing a Variable

We are used to counting numbers such as 1, 2, 3, 4, etc. In reality, when counting such numbers, we are simply adding 1 to a number in order to get the next number in the range. The simplest technique of incrementing a value consists of adding 1 to it. After adding 1, the value or the variable is (permanently) modified and the variable would hold the new value. This is illustrated in the following example:

// This program studies value incrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of incrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Value = Value + 1;

	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of incrementing a value
Value = 12
Value = 13

C# provides a special operator that takes care of this operation. The operator is called the increment operator and is represented by ++. Instead of writing Value = Value + 1, you can write Value++ and you would get the same result. The above program can be re-written as follows:

// This program studies value incrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of incrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Value++;

	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

The ++ is a unary operator because it operates on only one variable. It is used to modify the value of the variable by adding 1 to it. Every time the Value++ is executed, the compiler takes the previous value of the variable, adds 1 to it, and the variable holds the incremented value:

// This program studies value incrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of incrementing a value");

	Value++;
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Value++;
	Console.Write("Value = ");
	Console.WriteLine(Value);
		
	Value++;
	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of incrementing a value
Value = 13
Value = 14
Value = 15

Pre and Post-Increment

When using the ++ operator, the position of the operator with regard to the variable it is modifying can be significant. To increment the value of the variable before re-using it, you should position the operator on the left of the variable:

// This program studies value incrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of incrementing a value");

	Console.Write("Value = ");
	Console.WriteLine(Value);

	Console.Write("Value = ");
	Console.WriteLine(++Value);
		
	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of incrementing a value
Value = 12
Value = 13
Value = 13

When writing ++Value, the value of the variable is incremented before being called. On the other hand, if you want to first use a variable, then increment it, in other words, if you want to increment the variable after calling it, position the increment operator on the right side of the variable:

// This program studies value incrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of incrementing a value");

	Console.Write("Value = ");
	Console.WriteLine(Value);

	Console.Write("Value = ");
	Console.WriteLine(Value++);
		
	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of incrementing a value
Value = 12
Value = 12
Value = 13

Decrementing a Value

When counting numbers backward, such as 8, 7, 6, 5, etc, we are in fact subtracting 1 from a value in order to get the lesser value. This operation is referred to as decrementing a value. This operation works as if a value is decremented by 1, as in Value = Value 1:

// This program studies value decrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of decrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Value = Value - 1;

	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of decrementing a value
Value = 12
Value = 11

As done to increment, C# provides a quicker way of subtracting 1 from a value. This is done using the decrement operator, that is --. To use the decrement operator, type - on the left or the right side of the variable when this operation is desired. Using the decrement operator, the above program could be written:

// This program studies value decrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of decrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Value--;

	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

Pre Decrementing a Value

Once again, the position of the operator can be important. If you want to decrement the variable before calling it, position the decrement operator on the left side of the operand. This is illustrated in the following program:

// This program studies value decrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of decrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Console.Write("Value = ");
	Console.WriteLine(--Value);
		
	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of decrementing a value
Value = 12
Value = 11
Value = 11

If you plan to decrement a variable only after it has been accessed, position the operator on the right side of the variable. Here is an example:

// This program studies value decrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12;

	Console.WriteLine("Techniques of decrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Console.Write("Value = ");
	Console.WriteLine(Value--);
		
	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of decrementing a value
Value = 12
Value = 12
Value = 11

Techniques of Incrementing and Decrementing a Variable

It is not unusual to add or subtract a constant value to or from a variable. All you have to do is to declare another variable that would hold the new value. Here is an example:

// This program studies value incrementing and decrementing
using System;

public class Exercise
{
    static int Main()
    {
	double Value = 12.75;
	double NewValue;

	Console.WriteLine("Techniques of incrementing and decrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	NewValue = Value + 2.42;
		
	Console.Write("Value = ");
	Console.WriteLine(NewValue);

        return 0;
    }
}

This would produce:

Techniques of incrementing and decrementing a value
Value = 12.75
Value = 15.17

The above technique requires that you use an extra variable in your application. The advantage is that each value can hold its own value although the value of the second variable depends on whatever would happen to the original or source variable.

Sometimes in your program you will not need to keep the original value of the source variable. You may want to permanently modify the value that a variable is holding. In this case you can perform the addition operation directly on the variable by adding the desired value to the variable. This operation modifies whatever value a variable is holding and does not need an additional variable.

To add a value to a variable and change the value that the variable is holding, you can combine the assignment = and the addition + operators to produce a new operator as +=

Here is an example:

// This program studies value incrementing and decrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12.75;

	Console.WriteLine("Techniques of incrementing and decrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Value += 2.42;
		
	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This program produces the same result as the previous. To decrement the value of a variable, instead of the addition, use the subtraction and apply the same technique. In the above program, the variable can have its value decremented by combining the assignment and the subtraction operations on the variable. This is done with the -= operator. Here is an example:

// This program studies value incrementing and decrementing
using System;

public class Exercise
{
    static int Main()
    {
	var Value = 12.75;

	Console.WriteLine("Techniques of incrementing and decrementing a value");
	Console.Write("Value = ");
	Console.WriteLine(Value);

	Value -= 2.42;
		
	Console.Write("Value = ");
	Console.WriteLine(Value);

        return 0;
    }
}

This would produce:

Techniques of incrementing and decrementing a value
Value = 12.75
Value = 10.33

 

 

Previous Copyright 2008 Yevol Next