Перейти к содержимому

Flow Control

  • if
  • else
  • else if
  • while (true)
  • continue
  • break
  • do ... while
if (true)
{
Console.WriteLine("Hello");
}
Ответ

true в условии заставляет тело if-а выполняться всегда.

if (false)
{
Console.WriteLine("Hello");
}
Ответ

При компиляции, данный код покажет warning, что код является unreachable. Unreachable означает, что этот код гарантировано никогда не выполнится.

bool execute = true;
if (execute)
{
Console.WriteLine("Hello");
}
bool notExecute = !execute;
if (notExecute)
{
Console.WriteLine("Not executed");
}
Ответ

Здесь, warning-а при компиляции не будет.

При запуске, выведется только Hello.

В чем функциональное и семантическое различие функций F1, F2, F3?

static void F1()
{
if (A())
{
if (B())
{
Console.WriteLine("Hello");
}
}
}
static void F2()
{
if (A() && B())
{
Console.WriteLine("Hello");
}
}
static void F3()
{
bool a = A();
bool b = B();
bool ok = a && b;
if (ok)
{
Console.WriteLine("Hello");
}
}
static bool A()
{
Console.WriteLine("A");
return true;
}
static bool B()
{
Console.WriteLine("B");
return true;
}
Что значит функциональное и семантическое?

Разница может быть:

  • эстетическая — одно субъективно выглядит красивее другого;
  • синтактическая — функции записаны, используя различный код, но совершают то же действие;
  • семантическая — различие в том, какие именно операции используются, как достигается цель;
  • функциональная — функции производят разный видимый результат (печать в консоль, возвращаемое значение).
  • нефункциональная — например, малозаметная разница в скорости выполнения.
Ответ

F1 и F2 семантически и функционально идентичны: при их выполнении выполнятся те же самые действия, и в консоль напишется A и B.

F3 функционально не отличается от F1 и F2, потому что результат выполнения будет тот же, но есть семантическое отличие, поскольку ранее B бы не выполнилась, если A бы вернула false, из-за механизма работы вложенного if и &&.

Можно сделать F3 функционально различной от F1 и F2, если вернуть false из A. В этом случае, B не напечатается.

if (1)
{
Console.WriteLine("Hello");
}
Ответ

if применим только на выражения типа bool (или неявно конвертируемые в bool), тогда как int — это числовой тип.

Данный код не скомпилируется.

if (false)
{
Console.WriteLine("A");
Console.WriteLine("B");
}
Ответ

Ничего не напечатается.

if (false)
Console.WriteLine("A");
Console.WriteLine("B");
Ответ

Напечатается только B, потому что лишь инструкция A прикреплена к if-у.

Эквивалентный код:

if (false)
{
Console.WriteLine("A");
}
Console.WriteLine("B");
if (false)
{
Console.WriteLine("A");
}
else
{
Console.WriteLine("B");
}
Ответ

Данный код выведет “B”, поскольку блок else выполняется тогда, когда не выполняется условие.

bool a = true;
if (a)
{
a = false;
}
else
{
Console.WriteLine("B");
}
Ответ

“B” не напечатается, потому что то, выполнится ли else, определяется на момент проверки a в if, а это происходит до его изменения.

F();
static void F()
{
if (true)
{
return;
}
else
{
Console.WriteLine("Else");
}
Console.WriteLine("After Else");
}
Ответ

Здесь “Else” не напечатается. То, выполнится ли блок else, зависит лишь от условия в if.

“After Else” тоже не напечатается. return полностью прерывает выполнение всей функции, а не только if-а, в котором он был использован.

if (true)
Console.WriteLine("A");
else
Console.WriteLine("B");
Console.WriteLine("C");
Ответ

“B” не напечатается. Напечатаются “A” и “C”.

if (true)
Console.WriteLine("A");
else
{
Console.WriteLine("B");
}
Ответ

Допустимо комбинировать прилепление инструкции и явный блок.

Как обычно записывают данный код, используя цепочку else-if?

if (a)
{
Console.WriteLine("A");
}
else
{
if (b)
{
Console.WriteLine("B");
}
else
{
if (c)
{
Console.WriteLine("C");
}
}
}
Ответ

if обычно цепляют как инструкцию, сопровождающую else:

if (a)
{
Console.WriteLine("A");
}
else if (b)
{
Console.WriteLine("B");
}
else if (c)
{
Console.WriteLine("C");
}

Попытайтесь представить данный код как цепочку else-if, семантически ему идентичную. Как сделать этот код через early return / guard clause?

if (a)
{
Console.WriteLine("A");
}
else
{
Console.WriteLine("After A");
if (b)
{
Console.WriteLine("B");
}
else
{
Console.WriteLine("After B");
if (c)
{
Console.WriteLine("C");
}
else
{
Console.WriteLine("After C");
}
}
}
Ответ (цепочка)

Этот код невозможно представить как цепочку. Некуда поставить “After B” и “After C” так, чтобы они выполнялись по тем же правилам. Можно попробовать их продублировать, но тогда они не будут семантически эквивалентны:

if (a)
{
Console.WriteLine("A");
}
else if (b)
{
Console.WriteLine("After A");
Console.WriteLine("B");
}
else if (c)
{
Console.WriteLine("After A");
Console.WriteLine("After B");
Console.WriteLine("C");
}
else
{
Console.WriteLine("After A");
Console.WriteLine("After B");
Console.WriteLine("After C");
}
Ответ (guard clause / early return)
  1. Создается функция для этого кусочка кода;
  2. Внутри каждого if прописывается return;
  3. else и блоки пропадают.
F(a, b, c);
static void F(bool a, bool b, bool c)
{
if (a)
{
Console.WriteLine("A");
return;
}
Console.WriteLine("After A");
if (b)
{
Console.WriteLine("B");
return;
}
Console.WriteLine("After B");
if (c)
{
Console.WriteLine("C");
return;
}
Console.WriteLine("After C");
}
Зачем этот guard clause / early return?
  • Чтобы поднять обработку ошибок вверх функции, а основную логику опустить вниз. Это делает очевидным тот факт, что логика зависит от корректности данных, которая проверялась на момент обработки ошибок (контракт).
  • Убирает лишнюю вложенность условий;
  • Способствует локальности кода проверки ошибки и ее обработки.

Пример кода без применения guard clause / early return:

static void SendWelcomeEmail(User user)
{
// Условия перечислены с увеличением вложенности.
if (user != null)
{
if (user.IsActive)
{
if (user.EmailConfirmed)
{
// Код с самим действием спрятан в середине функции.
Console.WriteLine($"Sending email to {user.Email}");
}
else
{
Console.WriteLine("Email not confirmed.");
}
}
else
{
Console.WriteLine("User is not active.");
}
}
// Не соблюдается локальность:
// обработка удалена в исходном коде от связанной проверки.
else
{
Console.WriteLine("User not found.");
}
}

Тот же код, с его применением:

static void SendWelcomeEmail(User user)
{
// Можно блоком разграничить контракт
// (необходимые условия для выполнения основного действия),
// или вынести его в свою функцию.
{
// Соблюдена локальность: условия рядом с их обработкой.
if (user == null)
{
Console.WriteLine("User not found.");
return;
}
if (!user.IsActive)
{
Console.WriteLine("User is not active.");
return;
}
if (!user.EmailConfirmed)
{
Console.WriteLine("Email not confirmed.");
return;
}
}
// Основной код находится после всех проверок, а не в середине.
Console.WriteLine($"Sending email to {user.Email}");
}

Выполните в голове данный код:

int i = 0;
while (true)
{
if (i == 4)
{
Console.WriteLine("ERROR: Should not happen");
break;
}
if (i == 3)
{
Console.WriteLine("Exit");
break;
}
if (i == 0)
{
Console.WriteLine("Increase by 2 on first iter");
i += 2;
continue;
}
if (i == 0)
{
Console.WriteLine("Iteration continued? Or skipped?");
}
Console.WriteLine("Increase by 1 normally");
i++;
// Implicit continue.
// continue;
}
Что делают break и continue

break прекращает выполнение цикла (переходит на первую инструкцию после цикла).

continue переходит в начало цикла (дальнейшие инструкции из тела цикла не выполняются для этой итерации).

Ответ

“Increase by 2 on first iter” напечатается в первой итерации цикла, i++ не выполнится из-за continue.

Условие i == 0 истинно только в этой первой итерации, а continue прерывает ее: он возвращает выполнение в начало цикла, из-за чего пропускаются все инструкции ниже. Поэтому второй блок с проверкой i == 0 не выполнится, и “Iteration continued? Or skipped?” не напечатается никогда.

“Increase by 1 normally” напечатается во второй итерации цикла, после прохождения с неудачей всех проверок if-ов.

“Exit” напечатается в третьей итерации, тогда как проверки i == 0 и инструкция i++ не выполнятся, поскольку break прервет выполнение цикла.

Increase by 2 on first iter
Increase by 1 normally
Exit

Что вернет эта функция, если ее вызвать?

static int F()
{
while (true)
{
if (true)
{
return 0;
}
break;
}
return 1;
}
Ответ

При выполнении return 0, прерывается не только цикл, но и последующее выполнение оставшегося кода функции.

break и return 1 никогда не выполнятся.