Home

Conditional Switches

   

Case Switches

 

Introduction

When defining an expression whose result would lead to a specific program execution, the switch statement considers that result and executes a statement based on the possible outcome of that expression, this possible outcome is called a case.

The different outcomes are listed in the body of the switch statement and each case has its own execution, if necessary. The body of a switch statement is delimited from an opening to a closing curly brackets: "{" to "}". The syntax of the switch statement is:

switch(Expression)
{
    case Choice1:
         Statement1;
	break;
    case Choice2:
         Statement2;
	break;
    case Choice-n:
         Statement-n;
	break;
}
 

	
In C++, you can omit the break keyword in a case. This creates the "fall through" effect as follows: after code executes in a case, if nothing "stops" it, the execution continues to the next case. This has caused problems and confusing execution in the past in some C++ programs. To avoid it, C# requires code interruption at the end of every case. This interruption is done using the break keyword.

The expression to examine in a case statement is an integer. Since a member of an enumerator (enum) and the character (char) data types are just other forms of integers, they can be used too. Here is an example of using the switch statement:

using System;

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

public class Exercise
{
    public static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var garage = "";

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        switch (choice)
        {
            case 1:
                type = HouseType.SingleFamily;
                break;

            case 2:
                type = HouseType.Townhouse;
                break;

            case 3:
                type = HouseType.Condominium;
                break;
        }

        Console.Write("Does the house have an indoor garage (1=Yes/0=No)? ");
        var answer = int.Parse(Console.ReadLine());
        if (answer == 1)
            garage = "Yes";
        else
            garage = "No";

        Console.WriteLine("\nDesired House Type: {0}", type);
        Console.WriteLine("Has indoor garage?  {0}", garage);

	return 0;
    }
}

When establishing the possible outcomes that the switch statement should consider, at times there will be possibilities other than those listed and you will be likely to consider them. This special case is handled by the default keyword. The default case would be considered if none of the listed cases matches the supplied answer. The syntax of the switch statement that considers the default case would be:

switch(Expression)
{
    case Choice1:
         Statement1;
	break;
    case Choice2:
         Statement2;
	break;
    case Choice-n:
         Statement-n;
	break;
    default:
         Other-Possibility;
	break;
}
In C++, the default section doesn't need a break keyword because it is the last. In C#, every case and the default section must have its own exit mechanism, which is taken care of by a break keyword.

Therefore another version of the program above would be

using System;

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

public class Exercise
{
    public static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var garage = "";

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        switch (choice)
        {
            case 1:
                type = HouseType.SingleFamily;
                break;

            case 2:
                type = HouseType.Townhouse;
                break;

            case 3:
                type = HouseType.Condominium;
                break;

            default:
                type = HouseType.Unknown;
                break;
        }

        Console.Write("Does the house have an indoor garage (1=Yes/0=No)? ");
        var answer = int.Parse(Console.ReadLine());
        if (answer == 1)
            garage = "Yes";
        else
            garage = "No";

        Console.WriteLine("\nDesired House Type: {0}", type);
        Console.WriteLine("Has indoor garage?  {0}", garage);

	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
You Choice? 8
Does the house have an indoor garage (1=Yes/0=No)? 2

Desired House Type: Unknown
Has indoor garage?  No
Press any key to continue . . .

Besides a value of an int type, you can also use another variant of integers on a switch statement. For example, you can use letters to validate the cases. Here is an example:

using System;

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

public class Exercise
{
    public static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var garage = "";

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        switch (choice)
        {
            case 1:
                type = HouseType.SingleFamily;
                break;

            case 2:
                type = HouseType.Townhouse;
                break;

            case 3:
                type = HouseType.Condominium;
                break;

            default:
                type = HouseType.Unknown;
                break;
        }

        Console.Write("Does the house have an indoor garage (y/n)? ");
        var answer = char.Parse(Console.ReadLine());
        
        switch (Answer)
        {
            case 'y':
                garage = "Yes";
                break;

            case 'Y':
                garage = "Yes";
                break;

            case 'n':
                garage = "No";
                break;

            case 'N':
                garage = "No";
                break;

            default:
                garage = "Not Specified";
                break;
        }

        Console.WriteLine("\nDesired House Type: {0}", type);
        Console.WriteLine("Has indoor garage?  {0}", garage);

        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
You Choice? 3
Does the house have an indoor garage (y/n)? y

Desired House Type: Condominium
Has indoor garage?  Yes
Press any key to continue . . .

ApplicationApplication: Introducing Conditional Switches

  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
  4. Change the Name to NationalBank3 and press Enter
  5. To create a new file, on the main menu, click Project -> Add New Item...
  6. In the middle list, click Code File
  7. Change the Name of the file to Customer
  8. Click Add
  9. Complete the Customer.cs file as follows:
    public enum AccountType { Checking, Saving, Other }
    
    public class Customer
    {
        public string AccountNumber;
        public AccountType   Type;
        public string FullName;
        public double Balance;
        public short  PIN;
    
        public Customer(string acnt = "000-000000-000",
                        AccountType category = AccountType.Other,
                        string name = "John Doe")
        {
            AccountNumber = acnt;
            Type = category;
            FullName = name;
            PIN = 0;
            Balance = 0.00D;
        }
    }
  10. To create a new file, in the Solution Explorer, right-click NationalBank3 -> Add -> New Item...
  11. In the middle list, make sure Code File is selected.
    Change the Name to Management and press Enter
  12. Complete the file as follows:
    using System;
    
    public class Management
    {
        private Customer CreateNewAccount()
        {
            byte typeOfAccount = 0;
            Customer client = new Customer();
    
            Console.WriteLine("===========================================");
            Console.WriteLine("==-= National Bank =-======================");
            Console.WriteLine("-------------------------------------------");
            Console.Write("Enter a number for the new account(000-000000-000): ");
            client.AccountNumber = Console.ReadLine();
            Console.WriteLine("What type of account the customer wants to open");
            Console.WriteLine("1 - Checking Account");
            Console.WriteLine("2 - Savings Account");
            Console.Write("Enter account type: ");
            typeOfAccount = byte.Parse(Console.ReadLine());
            if (typeOfAccount == 1)
                client.Type = AccountType.Checking;
            else if (typeOfAccount == 2)
                client.Type = AccountType.Saving;
            else
                client.Type = AccountType.Other;
            Console.Write("Enter customer name: ");
            client.FullName = Console.ReadLine();
            Console.Write("Ask the customer to enter a PIN: ");
            client.PIN = short.Parse(Console.ReadLine());
    
            return client;
        }
    
        public double GetMoney()
        {
            double amount = 0;
    
            Console.Write("Amount: ");
            amount = double.Parse(Console.ReadLine());
            return amount;
        }
    
        private void ShowAccountInformation(Customer cust)
        {   
            Console.WriteLine("===========================================");
            Console.WriteLine("==-= National Bank =-======================");
            Console.WriteLine("Customer Account Information");
            Console.WriteLine("-------------------------------------------");
            Console.WriteLine("Account #:    {0}", cust.AccountNumber);
            Console.WriteLine("Account Type: {0}", cust.Type);
            Console.WriteLine("Full Name:    {0}", cust.FullName);
            Console.WriteLine("PIN #:        {0}", cust.PIN);
            Console.WriteLine("Balance:      {0:F}", cust.Balance);
            Console.WriteLine("===========================================");
        }
    
        public static int Main()
        {
            double amount = 0;
            byte nextAction = 0;
            Customer accountHolder = null;
            Management registration = new Management();
    
            Console.Title = "National Bank";
    
            accountHolder = registration.CreateNewAccount();
            Console.WriteLine("Enter the customer's initial deposit");
            accountHolder.Balance = registration.GetMoney();
    
            Console.Clear();
    
            registration.ShowAccountInformation(accountHolder);
    
            Console.WriteLine("What do you want to do now?");
            Console.WriteLine("1 - Check account balance");
            Console.WriteLine("2 - Make a deposit");
            Console.WriteLine("3 - Withdraw money");
            Console.WriteLine("4 - Transfer money from one account to another");
            nextAction = byte.Parse(Console.ReadLine());
    
            switch (nextAction)
            {
                case 1:
                    break;
    
                case 2:
                    Console.Write("Enter the Deposit ");
                    amount = double.Parse(Console.ReadLine());
                    accountHolder.Balance = accountHolder.Balance + amount;
                    break;
    
                case 3:
                    Console.Write("Enter the Withdrawal ");
                    amount = double.Parse(Console.ReadLine());
                    accountHolder.Balance = accountHolder.Balance - amount;
                    break;
    
                case 4:
    Console.WriteLine("Operation not available: You have only one account with us");
                    break;
            }
    
            Console.Clear();
            registration.ShowAccountInformation(accountHolder);
    
            Console.ReadKey();
            return 0;
        }
    }
  13. Press F5 to execute
  14. Enter information as follows:
     
    Account # 202-410443-240
    Account Type: 1
    Customer Name: Paul Martin Eloundou
    PIN: 8402
    Initial Deposit: 750
    ===========================================
    ==-= National Bank =-======================
    -------------------------------------------
    Enter a number for the new account(000-000000-000)202-410443-240
    What type of account the customer wants to open
    1 - Checking Account
    2 - Savings Account
    Enter account type: 1
    Enter customer name: Paul Martin Eloundou
    Ask the customer to enter a PIN: 8402
    Enter the customer's initial deposit
    Amount: 750
  15. Press Enter
    ===========================================
    ==-= National Bank =-======================
    Customer Account Information
    -------------------------------------------
    Account #:    202-410443-240
    Account Type: Checking
    Full Name:    Paul Martin Eloundou
    PIN #:        8402
    Balance:      750.00
    ===========================================
    What do you want to do now?
    1 - Check account balance
    2 - Make a deposit
    3 - Withdraw money
    4 - Transfer money from one account to another
  16. When asked for the next action, type 2 and press Enter
  17. Type the amount as 226.85 and press Enter
  18. Press Enter to close the DOS window and return to your programming environment

Combining Cases

Each of the cases we have used so far examined only one possibility before executing the corresponding statement. You can combine cases to execute the same statement. To do this, type a case, its value, and the semi-colon. Type another case using the same formula. When the cases are ready, you can then execute the desired statement. Here is an example:

using System;

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

public class Exercise
{
    public static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var garage = "";

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        switch (choice)
        {
            case 1:
                type = HouseType.SingleFamily;
                break;

            case 2:
                type = HouseType.Townhouse;
                break;

            case 3:
                type = HouseType.Condominium;
                break;

            default:
                type = HouseType.Unknown;
                break;
        }

        Console.Write("Does the house have an indoor garage (y/n)? ");
        var answer = char.Parse(Console.ReadLine());
        switch (answer)
        {
            case 'y':
            case 'Y':
                garage = "Yes";
                break;

            case 'n':
            case 'N':
                garage = "No";
                break;

            default:
                garage = "Not Specified";
                break;
        }

        Console.WriteLine("\nDesired House Type: {0}", type);
        Console.WriteLine("Has indoor garage?  {0}", garage);

        return 0;
    }
}

This would produce:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 3
Does the house have an indoor garage (y/n)? Y

Desired House Type: Condominium
Has indoor garage?  Yes
Press any key to continue . . .

Using Enumerations

One of the most fundamental uses of enumerations is to process them in a switch statement. To do this, you pass the value of an enumeration to a switch. The values of the enumerations are then processed in the case statements. Here is an example:

using System;

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

public class Exercise
{
    public static int Main()
    {
        var PropertyType = "";
        var choice = 0;
        var garage = "";

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        switch ((HouseType)choice)
        {
            case HouseType.SingleFamily:
                PropertyType = "Single Family";
                break;

            case HouseType.Townhouse:
                PropertyType = "Townhouse";
                break;

            case HouseType.Condominium:
                PropertyType = "Condominium";
                break;

            default:
                PropertyType = "Unknown";
                break;
        }

        Console.Write("Does the house have an indoor garage (y/n)? ");
        var answer = char.Parse(Console.ReadLine());
        
        switch (answer)
        {
            case 'y':
            case 'Y':
                garage = "Yes";
                break;

            case 'n':
            case 'N':
                garage = "No";
                break;

            default:
                garage = "Not Specified";
                break;
        }

        Console.WriteLine("\nDesired House Type: {0}", PropertyType);
        Console.WriteLine("Has indoor garage?  {0}", garage);

        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
You Choice? 1
Does the house have an indoor garage (y/n)? N

Desired House Type: Single Family
Has indoor garage?  No
Press any key to continue . . .

Logical Conjunction: AND

 

Introduction

Imagine that a real estate agent who will be using your program is meeting with a potential buyer and asking questions from the following program:

using System;

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

public class Program
{
    static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var value = 0D;

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        if (choice == 1)
            type = HouseType.SingleFamily;
        if (choice == 2)
            type = HouseType.Townhouse;
        if (choice == 3)
            type = HouseType.Condominium;

        Console.Write("Up to how much can you afford? $");
        value = double.Parse(Console.ReadLine());

        Console.WriteLine("\nDesired House Type:      {0}", type);
        Console.WriteLine("Maximum value afforded:  {0:C}\n", value);

	return 0;
    }
}

Suppose a customer responds to these questions: she indicates that she wants single family house but she cannot afford more than $550,000:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 1
Up to how much can you afford? $550000

Desired House Type:      SingleFamily
Maximum value afforded:  $550,000.00

Press any key to continue . . .

When considering a house for this customer, there are two details to be validated here: the house must be a single family home, second, it must cost less than $550,001. We can create two statements as follows:

  1. The house is single family
  2. The house costs less than $550,000

From our list of real estate properties, if we find a house that is a single family home, we put it in our list of considered properties:

Type of House House
The house is single family True

On the other hand, if we find a house that is less than or equal to $550,000, we retain it:

Price Range Value
$550,000 True

One of the ways you can combine two comparisons is by joining them. For our customer, we want a house to meet BOTH criteria. If the house is a town house, based on the request of our customer, its conditional value is false. If the house is more than $550,000, the value of the Boolean Value is true. The Boolean operator used to join two criteria is called AND. This can be illustrated as follows:

Type of House House Value Result
Town House $625,000 Town House AND $625,000
False False False

In C#, the Boolean AND operator is performed using the && operator. Here is an example:

using System;

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

public class Exercise
{
    static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var value = 0D;

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        Console.Write("Up to how much can you afford? $");
        value = double.Parse(Console.ReadLine());

        if(choice == 1)
            type = HouseType.SingleFamily;
        if (choice == 2)
            type = HouseType.Townhouse;
        if (choice == 3)
            type = HouseType.Condominium;
        Console.WriteLine("\nDesired House Type:      {0}", type);
        Console.WriteLine("Maximum value afforded:  {0:C}", value);

        if (type == HouseType.SingleFamily && value <= 550000)
            Console.WriteLine("\nDesired House Matched");
	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
You Choice? 1
Up to how much can you afford? $450000

Desired House Type:      SingleFamily
Maximum value afforded:  $450,000.00

Desired House Matched
Press any key to continue . . .

By definition, a logical conjunction combines two conditions. To make the program easier to read, each side of the conditions can be included in parentheses. Here is an example:

using System;

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

public class Exercise
{
    static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var value = 0D;

        . . .

        if( (type == HouseType.SingleFamily) && (value <= 550000) )
            Console.WriteLine("\nDesired House Matched");
	return 0;
    }
}

Suppose we find a single family home. The first condition is true for our customer. With the AND Boolean operator, if the first condition is true, then we consider the second criterion. Suppose that the house we are considering costs $750,500: the price is out of the customer's range. Therefore, the second condition is false. In the AND Boolean algebra, if the second condition is false, even if the first is true, the whole condition is false. This would produce the following table:

Type of House House Value Result
Single Family $750,500 Single Family AND $750,500
True False False

This can be illustrated by the following run of the program:

using System;

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

class Program
{
    static void Main()
    {
        var type = HouseType.Unknown;
        int choice;
        var value = 0M;

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        if (choice == 1)
            type = HouseType.SingleFamily;
        if (choice == 2)
            type = HouseType.Townhouse;
        if (choice == 3)
            type = HouseType.Condominium;

        Console.Write("Up to how much can you afford? $");
        value = decimal.Parse(Console.ReadLine());

        Console.WriteLine("\nDesired House Type:      {0}", type);
        Console.WriteLine("Maximum value afforded:  {0:C}", value);

        if (type == HouseType.SingleFamily && value <= 550000)
            Console.WriteLine("\nDesired House Matched");
        else
            Console.WriteLine("\nThe House Doesn't Match the Desired Criteria");
    }
}

Here is an example of running the program:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 1
Up to how much can you afford? $750000

Desired House Type:      SingleFamily
Maximum value afforded:  $750,000.00

The House Doesn't Match the Desired Criteria
Press any key to continue . . .

Suppose we find a townhouse that costs $420,000. Although the second condition is true, the first is false. In Boolean algebra, an AND operation is false if either condition is false:

Type of House House Value Result
Town House $420,000 Town House AND $420,000
False True False

Here is an example of running the above program:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 2
Up to how much can you afford? $420000

Desired House Type:      Townhouse
Maximum value afforded:  $420,000.00

The House Doesn't Match the Desired Criteria
Press any key to continue . . .

If we find a single family home that costs $345,000, both conditions are true. In Boolean algebra, an AND operation is true if BOTH conditions are true. This can be illustrated as follows:

Type of House House Value Result
Single Family $345,000 Single Family AND $345,000
True True True

This can be revealed in the following run of the above program:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 1
Up to how much can you afford? $345000

Desired House Type:      SingleFamily
Maximum value afforded:  $345,000.00

Desired House Matched
Press any key to continue . . .

These four tables can be resumed as follows:

If Condition1 is If Condition2 is Condition1
AND
Condition2
False False False
False True False
True False False
True True True

As you can see, a logical conjunction is true only of BOTH conditions are true.

Combining Conjunctions

As seen above, the logical conjunction operator is used to combine two conditions. In some cases, you will need to combine more than two conditions. Imagine a customer wants to purchase a single family house that costs up to $450,000 with an indoor garage. This means that the house must fulfill these three requirements:

  1. The house is a single family home
  2. The house costs less than $450,001
  3. The house has an indoor garage

Here the program that could be used to check these conditions:

using System;

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

public class Exercise
{
    static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var value = 0D;
        var hasIndoorGarage = false;

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        if (choice == 1)
            type = HouseType.SingleFamily;
        if (choice == 2)
            type = HouseType.Townhouse;
        if (choice == 3)
            type = HouseType.Condominium;

        Console.Write("Up to how much can you afford? $");
        value = double.Parse(Console.ReadLine());

        Console.Write("Does the house have an indoor garage (1=Yes/0=No)? ");
        int ans = int.Parse(Console.ReadLine());

        Console.WriteLine("\nDesired House Type:      {0}", type);
        Console.WriteLine("Maximum value afforded:  {0:C}", value);
        Console.Write("House has indoor garage: ");
        if (ans == 1)
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");

        if ((type == HouseType.SingleFamily) && (value <= 550000) && (ans == 1))
            Console.WriteLine("\nDesired House Matched");
        else
            Console.WriteLine("\nThe House Doesn't Match the Desired Criteria");

        return 0;
    }
}

We saw that when two conditions are combined, the compiler first checks the first condition, followed by the second. In the same way, if three conditions need to be considered, the compiler evaluates the truthfulness of the first condition:

Type of House
A
Town House
False

If the first condition (or any condition) is false, the whole condition is false, regardless of the outcome of the other(s). If the first condition is true, then the second condition is evaluated for its truthfulness:

Type of House Property Value
A B
Single Family $655,000
True False

If the second condition is false, the whole combination is considered false:

A B A && B
True False False

When evaluating three conditions, if either the first or the second is false, since the whole condition would become false, there is no reason to evaluate the third. If both the first and the second conditions are false, there is also no reason to evaluate the third condition. Only if the first two conditions are true will the third condition be evaluated whether it is true:

Type of House Property Value Indoor Garage
A B C
Single Family $425,650 None
True True False

The combination of these conditions in a logical conjunction can be written as A && B && C. If the third condition is false, the whole combination is considered false:

A B A && B C A && B && C
True True True False False

To verify this, here is an example of running the program:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 1
Up to how much can you afford? $425000
Does the house have an indoor garage (1=Yes/0=No)? 0

Desired House Type:      SingleFamily
Maximum value afforded:  $425,000.00
House has indoor garage: No

The House Doesn't Match the Desired Criteria
Press any key to continue . . .

From our discussion so far, the truth table of the combinations can be illustrated as follows:

A B C A && B && C
False Don't Care Don't Care False
True False Don't Care False
True True False False

The whole combination is true only if all three conditions are true. This can be illustrated as follows:

A B C A && B && C
False False False False
False False True False
True False False False
True False True False
False True False False
False True True False
True True False False
True True True True
 

Logical Disjunction: OR

 

Introduction

Our real estate company has single family homes, townhouses, and condominiums. All of the condos have only one level, also referred to as a story. Some of the single family homes have one story, some have two and some others have three levels. All townhouses have three levels.

Another customer wants to buy a home. The customer says that he primarily wants a condo, but if our real estate company doesn't have a condominium, that is, if the company has only houses, whatever it is, whether a house or a condo, it must have only one level (story) (due to an illness, the customer would not climb the stairs). When considering the properties of our company, we would proceed with these statements:

  1. The property is a condominium
  2. The property has one story

If we find a condo, since all of our condos have only one level, the criterion set by the customer is true. Even if we were considering another (type of) property, it wouldn't matter. This can be resumed in the following table:

Type of House House
Condominium True

The other properties would not be considered, especially if they have more than one story:

Number of Stories Value
3 False

To check for either of two conditions, in Boolean algebra, you can use an operator called OR. We can show this operation as follows:

Condominium One Story Condominium OR 1 Story
True False True

In Boolean algebra, this type of comparison is performed using the OR operator. In C#, the OR operator is performed using the || operator. Here is an example:

using System;

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

public class Exercise
{
    static int Main()
    {
        var type = HouseType.Unknown;
        var choice = 0;
        var stories = 1;

        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("You Choice? ");
        choice = int.Parse(Console.ReadLine());

        if (choice == 1)
            type = HouseType.SingleFamily;
        if (choice == 2)
            type = HouseType.Townhouse;
        if (choice == 3)
            type = HouseType.Condominium;

        Console.Write("How many stories? ");
        stories = int.Parse(Console.ReadLine());

        Console.WriteLine("\nDesired House Type: {0}", type);
        Console.WriteLine("Number of Stories:  {0}", stories);

        if ((type == HouseType.Condominium) || (stories == 1))
            Console.WriteLine("\nDesired House Matched");
        else
            Console.WriteLine("\nThe House Doesn't Match the Desired Criteria");

        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
You Choice? 3
How many stories? 6

Desired House Type: Condominium
Number of Stories:  6

Desired House Matched
Press any key to continue . . .

Suppose that, among the properties our real estate company has available, there is no condominium. In this case, we would then consider the other properties:

Type of House House
Single Family False

If we have a few single family homes, we would look for one that has only one story. Once we find one, our second criterion becomes true:

Type of House One Story Condominium OR 1 Story
False True True

This can be illustrated in the following run of the above program:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 1
How many stories? 1

Desired House Type: SingleFamily
Number of Stories:  1

Desired House Matched
Press any key to continue . . .

If we find a condo and it is one story, both criteria are true. This can be illustrated in the following table:

Type of House One Story Condominium OR 1 Story
False True True
True True True

The following run of the program demonstrates this:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 3
How many stories? 1

Desired House Type: Condominium
Number of Stories:  1

Desired House Matched
Press any key to continue . . .

A Boolean OR operation produces a false result only if BOTH conditions ARE FALSE:

If Condition1 is If Condition2 is Condition1 OR Condition2
False True True
True False True
True True True
False False False

Here is another example of running the program:

Enter the type of house you want to purchase
1. Single Family
2. Townhouse
3. Condominium
You Choice? 2
How many stories? 2

Desired House Type: Townhouse
Number of Stories:  2

The House Doesn't Match the Desired Criteria
Press any key to continue . . .

Combinations of Disjunctions

As opposed to evaluating only two conditions, you may face a situation that presents three of them and must consider a combination of more than two conditions.

ApplicationApplication: Ending the Lesson

  1. Close your programming environment
  2. When asked whether you want to save, click No
 

Previous Copyright © 2010-2012 FunctionX Next