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 . . .

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

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 . . .

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 . . .

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:

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

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:

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:

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:

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:

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:

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

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:

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:

If the second condition is false, the whole combination is considered 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:

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:

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:

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

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:

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

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

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:

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:

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:

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:

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 . . .

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.

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