Enoncé conditionnels : Conjonction logique : And (ou ET)

Introduction

Imaginez qu'un agent immobilier qui utilisera votre programme rencontre un acheteur potentiel et pose des questions du programme suivant:

using System;

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

class Program
{
    static void Main()
    {
        HouseType type = HouseType.Unknown;
        int choice;
        decimal 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}\n", value);
    }
}

Supposez qu'un client réponde à ces questions : il indique qu'il veut la maison unifamiliale (SingleFamily) mais qu'il ne peut pas se permettre plus de $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 . . .

En condérant la maison de ce client, il y a deux détails à valider ici : la maison doit être une maison unifamiliale (SingleFamily), en second lieu, il doit coûter moins de $550.001. Nous pouvons créer deux énoncés comme suit :

1. La maison est unifamiliale (SingleFamily)
2. La maison coûte moins de $550.001

De notre liste de propriétés immobilières réelles, si nous trouvons une maison qui est une maison unifamiliale (SingleFamily), nous la mettons dans notre liste de propriétés considérées :

D'une part, si nous trouvons une maison qui est inférieur ou égal à $550.000, nous la maintenons :

Une des manières de combiner deux comparaisons est en les joignant. Pour notre client, nous voulons qu'une maison rencontre LES DEUX critères. Si la maison est une maison de ville (Townhouse), basée sur la demande de notre client, sa valeur conditionnelle est fausse. Si la maison est plus de $550.000, la valeur de la valeur booléenne est vraie. L'opérateur booléen utilisé pour joindre deux critères s'appelle AND ou ET. Ceci peut être illustré comme suit :

Dans C#, l'opérateur booléen AND ou ET est exécuté en utilisant l'opérateur &&. Voici un exemple :

using System;

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

class Program
{
    static void Main()
    {
        HouseType type = HouseType.Unknown;
        int choice;
        decimal 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());

        Console.Write("Up to how much can you afford? $");
        value = decimal.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");
    }
}

Voici un exemple d'exécution du programme :

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

Par définition, une conjonction logique combine deux conditions. Pour faciliter la lecture du programme, chaque côté des conditions peut être inclus entre parenthèses. Voici un exemple:

using System;

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

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

        . . .

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

Supposez que nous trouvons une maison unifamiliale. La première condition est vraie pour notre client. Avec opérateur booléen ET, si la première condition est vraie, puis nous considérerons le deuxième critère. Supposez que la maison que nous considérons coûte $750.500 : le prix est hors de la gamme du client. Par conséquent, la deuxième condition est fausse. Dans l'algèbre booléenne ET, si la deuxième condition est fausse, même si la première est vraie, l'énoncé entier est faux. Ceci produirait la table suivante :

Ceci peut être illustré par l'exécution du programme suivant  :

using System;

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

class Program
{
    static void Main()
    {
        HouseType type = HouseType.Unknown;
        int choice;
        decimal 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");
    }
}

Voici un exemple d'exécution du programme :

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

Supposez que nous trouvons une maison urbaine et que cela coûte $420.000. Bien que la deuxième condition soit vraie, la première est fausse. Dans l'algèbre booléenne de ET, l'opération est faux si l'une ou l'autre condition est fausse :

Voici un exemple d'exécution le programme ci-dessus :

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

Si nous trouvons une maison unifamiliale et qu'elle coûte $345.000, les deux conditions sont vraie. Dans l'algèbre booléenne ET, l'opération est vrai si LES DEUX conditions sont vraies. Ceci peut être illustré comme suit :

Ceci peut être indiqué dans l'exécution du programme ci-dessus suivante :

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

Ces quatre tables peuvent être reprises comme suit :

Comme vous pouvez voir, une conjonction logique est vraie seulement si LES DEUX conditions sont vraies.

Comme vu ci-dessus, l'opérateur logique de conjonction est utilisé pour combiner deux conditions. Dans certains cas, vous devrez combiner plus de deux conditions. Imaginez qu'un client veut acheter une maison unifamiliale qui coûte jusqu'à $450.000 avec un garage intérieur. Ceci signifie que la maison doit remplir ces trois conditions:

1. La maison est une maison unifamiliale
2. La maison coûte moins de $450.001
3. La maison a un garage intérieur

Voici le programme qui pourrait être utilisé pour vérifier ces conditions :

using System;

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

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

        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.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");
    }
}

Nous avons vu que quand deux conditions sont combinées, de compilateur contrôle d'abord la première condition, suivie de la seconde. De la même manière, si trois conditions doivent être considérées, le compilateur évalue l'exactitude de la première condition:

Si la première condition (ou toute autre condition) est fausse, l'énoncé entier est faux, indépendamment des résultats des autres. Si la première condition est vraie, alors la deuxième condition est évaluée pour son exactitude :

Si la deuxième condition est fausse, la combinaison entière est considérée fausse :

En évaluant trois conditions, si le premier ou la seconde est fausse, puisque l'énoncé entier deviendrait faux, là il n'y a aucune raison d'évaluer la troisième. Si les premières et deuxièmes conditions sont fausses, il n'y a également aucune raison d'évaluer la troisième condition. Seulement si les deux premières conditions sont vraies la troisième condition sera évaluée :

La combinaison de ces conditions dans une conjonction logique peut être écrite; A && B && C. Si la troisième condition est fausse, la combinaison entière est considérée fausse :

Pour vérifier ceci, voici un exemple d'exécution du programme :

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

De notre discussion jusqu'ici, la table de vérité des combinaisons peut être illustrée comme suit :

La combinaison entière est vraie seulement si chacune des trois conditions est vraie. Ceci peut être illustré comme suit :