На этом шаге мы рассмотрим синтаксис и использование таких конструкций.

    Условные конструкции могут быть вложенными - то есть в одной условной конструкции (внешний if) может использоваться другая условная конструкция (внутренний, или вложенный if), а в нем еще один if и так далее. Причем внутренние условные конструкции могут использоваться и в if-блоке, и в else-блоке внешней условной конструкции. Например, ниже приведен шаблонный код для случая, когда внутренняя условная конструкция размещена внутри if-блока внешней условной конструкции:

// Внешний if:
if (условие) {
  // Внутренняя условная конструкция: 
  if (условие) {
    // Команды if-блока внутренней условной кнструкции
  }
  // Блок else внутренней условной конструкции: 
  else {
    // Команды else-блока внутренней условной конструкции
  }
}
// Блок else внешней условной конструкции: 
else {
  // Команды else-блока внешнего оператора
}

    Достаточно популярной является схема, когда внутренняя условная конструкция размещается в else-блоке внешней условной конструкции. Если таких вложений несколько, то получается конструкция, позволяющая последовательно проверять несколько условий. Ниже приведен подобный код для случая, когда используется четыре вложенных условных конструкции:

if (условие) {
  // Команды выполняются, если условие_1 истинно
 }
 else if (условие_2) {
    // Команды выполняются, если услозие_2 истинно
    }
    else if(услозие_3)  {
      // Команды выполняются, если условие_3 истинно
      }
        else if(условие_4) {
        // Команды выполняются, если условие_4 истинно
        }
else {
  // Команды выполняются, если все условия ложны
} 

    Хотя вся конструкция может выглядеть несколько необычно, но в действительности это всего лишь вложенные условные конструкции. Просто нужно учесть несколько моментов. В первую очередь, следует обратить внимание, что else-блок каждой из условных конструкций состоит только лишь из одного оператора (внутренней условной конструкции). Поэтому else-блоки, за исключением последнего, описываются без использования фигурных скобок.

Напомним, что если if-блок или else-блок состоит из одной команды, то фигурные скобки можно не использовать. Условная конструкция - это одна "составная" команда. Поэтому если eif-блок или else-блок состоит из условной конструкции, то ее в фигурные скобки можно не заключать.

    Условия в условных конструкциях проверяются последовательно: сначала проверяется условие во внешней условной конструкции (условие_1). Если условие истинно, то выполняются команды в if-блоке этой конструкции. Если условие ложно, то выполняется условная конструкция в else-блоке внешней конструкции - и проверяется условие во внутреннем if (условие_2). Если это условие истинно, то выполняются команды в if-блоке данной условной конструкции. Если условие ложно, проверяется условие в следующем if (условие_3), и так далее. В итоге получается следующая схема: проверяется первое условие, и если оно ложно, проверяется второе условие. Если второе условие ложно, проверяется третье условие. Если оно ложно, проверяется четвертое условие, и так далее. Самый последний else-блок выполняется, если все условия оказались ложными.

    В примере ниже представлена программа, в которой используются вложенные условные операторы.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace pr35_1
{
    class Program
    {
        static void Main()
        {
            // Текстовая переменная: 
            string txt;
            // Отображение сообщения: 
            Console.Write("Введите текст: ");
            // Считывание текстовой строки: 
            txt=Console.ReadLine();
            // Если введена непустая строка: 
            if (txt != "") {
                // Отображение сообщения:
                Console.WriteLine("Спасибо, что ввели текст!"); 
                // Если в строке больше десяти символов: 
                if (txt.Length > 10) {
                    // Отображение сообщения:
                    Console.WriteLine("Ого, как много букв!");
                }
                // Если в строке не больше десяти симзолов: 
                else {
                    // Отображение сообщения:
                    Console.WriteLine("Ого, как мало букв!");
                }
            }
             // Если введена пустая строка: 
             else {
                 Console.WriteLine("Жаль, что не ввели текст!");
                }
            Console.ReadLine();
        }
    }
}

    Алгоритм выполнения программы простой: пользователю предлагается ввести текстовое значение, и это значение считывается и записывается в текстовую переменную. Затем в дело вступают вложенные условные конструкции. Во внешнем if проверяется, не пустая ли введенная пользователем текстовая строка. И если строка не пустая, то во внутреннем if проверяется, не превышает ли длина строки значение 10. В зависимости от истинности или ложности этих условий в консольное окно выводятся разные сообщения.

    Для записи текстового значения, введенного пользователем, используется переменная txt. Значение считывается командой txt=Console.ReadLine(). Во внешнем if проверяется условие txt!="". Если условие ложно, то выполняется команда Console.WriteLine("Жаль, что не ввели текст!") в else-блоке внешней условной конструкции. Если же условие txt!="" во внешней условной конструкции истинное, то в if-блоке сначала выполняется команда Console.WriteLine ("Спасибо, что ввели текст!"), после чего на сцену выходит внутренний if. Здесь проверяется условие txt.Length>10. Тут мы воспользовались свойством Length, которое возвращает количество символов в текстовой строке. Следовательно, условие txt.Length>10 истинно в случае, если текстовая строка, на которую ссылается переменная txt, содержит больше 10 символов. Если так, то выполняется команда Console.WriteLine ("Ого, как много букв!") в if-блоке внутренней условной конструкции. Если условие txt.Length>10 ложно, то выполняется команда Console.WriteLine("Ого, как мало букв!") в else-блоке внутренней условной конструкции. Таким образом, возможны три принципиально разных случая:

• пользователь не ввел текст;
• пользователь ввел текст, состоящий больше чем из 10 символов;
• пользователь ввел текст, состоящий не больше чем из 10 символов.

    Результат выполнения программы может быть таким:

Рис.1. Результат выполнения программы

    Это пример ситуации, когда введенный пользователем текст содержит не больше 10 символов. Если пользователь вводит текст, состоящий из более чем 10 символов, то результат может быть следующим.

Рис.2. Результат выполнения программы

    Наконец, если пользователь не вводит текст, то результат выполнения программы такой.

Рис.3. Результат выполнения программы

    Еще один пример, рассматриваемый далее, иллюстрирует схему с вложенными условными конструкциями, когда каждый следующий внутренний if формирует else-блок внешней условной конструкции. Программа, представленная в примере ниже, выполняется по простой схеме: пользователь вводит целое число (предположительно, от 1 до 4), а программа выводит текстовое название этого числа.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace pr35_2
{
    class Program
    {
        static void Main()
        {
            // Переменная для запоминания введенного числа: 
            int number;
            // Отображение сообщения:
            Console.Write("Введите целое число: ");
            // Считывание числа:
            number=Int32.Parse(Console.ReadLine());
            // Если введена единица:
            if(number==1) Console.WriteLine("Единица");
            // Если введена двойка:
            else if(number==2) Console.WriteLine("Двойка");
                // Если введена тройка:
                else if(number==3) Console.WriteLine("Тройка");
                    // Если введена четверка:
                    else if(number==4) Console.WriteLine("Четверка");
                         // Все прочие случаи:
                         else Console.WriteLine("Неизвестное число");
            Console.ReadLine();
        }
    }
}

    Программа "узнает" числа от 1 до 4 включительно. В начале выполнения программы командой Console.Write("Введите целое число: ") отображается приглашение ввести целое число. Число считывается командой number=Int32.Parse(Console.ReadLine()) и записывается в переменную number. Затем задействуется блок из вложенных условных конструкций, в каждой из которых проверяется введенное значение. При наличии совпадения в консольном окне появляется сообщение соответствующего содержания (название введенного числа). Если пользователь ввел число, не попадающее в диапазон значений от 1 до 4, то выполняется команда Console.WriteLine ("Неизвестное число"). Ниже показано, как может выглядеть результат выполнения программы, если пользователь вводит "знакомое" для программы число (здесь и далее жирным шрифтом выделено введенное пользователем значение).

Рис.4. Результат выполнения программы

Рис.5. Результат выполнения программы

    Как мы увидим далее, вложенные условные конструкции - далеко не единственный способ организовать проверку нескольких условий в программе.

    На следующем шаге мы рассмотрим переключатель switch.

Предыдущий шаг Содержание Следующий шаг