Язык программирования C#9 и платформа .NET5

Язык C# требует, чтобы вся логика программы содержалась внутри определения типа (вспомните из главы 1, что тип — это общий термин, относящийся к любому члену из множества {класс, интерфейс, структура, перечисление, делегат}). В отличие от многих других языков программирования создавать глобальные функции или глобальные элементы данных в C# невозможно. Взамен все данные-члены и все методы должны находиться внутри определения типа. Первым делом создадим новое пустое решение под названием

Chapter3_AllProject.sln

SimpleCSharpApp

Выберите в Visual Studio шаблон Blank Solution (Пустое решение) в диалоговом окне Create a new project (Создание нового проекта). После открытия решения щелкните правой кнопкой мыши на имени решения в окне Solution Explorer (Проводник решений) и выберите в контекстном меню пункт Add►New Project (Добавить►Новый проект). Выберите шаблон ConsoleАрр (.NET Core) (Консольное приложение (.NET Core)) на языке С#, назначьте ему имя

SimpleCSharpApp

Введите в окне командной строки следующие команды:

dotnet new sin -n Chapter3_AllProjects

dotnet new console -lang c# -n SimpleCSharpApp

  -o .\SimpleCSharpApp -f net5.0

dotnet sin .\Chapter3_AllProjects.sin add .\SimpleCSharpApp

Наверняка вы согласитесь с тем, что код в первоначальном файле

Program.cs

using System;

namespace SimpleCSharpApp

{

  class Program

  {

   static void Main(string[] args)

   {

    Console.WriteLine("Hello World!");

   }

  }

}

Теперь модифицируем метод

Main()

Program

class Program

{

  static void Main(string[] args)

  {

   // Вывести пользователю простое сообщение.

   Console.WriteLine("***** My First C# App *****);

   Console.WriteLine("Hello World!");

   Console.WriteLine();

   // Ожидать нажатия клавиши , прежде чем завершить работу.

   Console.ReadLine();

  }

}

На заметку! Язык программирования C# чувствителен к регистру. Следовательно,

Main

main

Readline

ReadLine

public

lock

class

dynamic

Console.WriteLine

System.Windows.MessageBox

System.Data.SqlClient

Предыдущий код содержит определение типа класса, который поддерживает единственный метод по имени

Main()

Main()

Program;

Main()

Выражаясь формально, класс, в котором определен метод

Main()

Main()

Обратите внимание, что сигнатура метода

Main()

static

Помимо наличия ключевого слова

static

Main()

string[] args

args

Main()

void

return

Внутри метода

Main()

Program

Console

System

WriteLine()

Console.ReadLine()

Console.ReadLine()

*.ехе

System.Console

Использование вариаций метода Main() (обновление в версии 7.1)

По умолчанию Visual Studio будет генерировать метод

Main()

void

Main()

// Возвращаемый тип int, массив строк в качестве параметра.

static int Main(string[] args)

{

  // Перед выходом должен возвращать значение!

  return 0;

}

// Нет возвращаемого типа, нет параметров.

static void Main()

{

}

// Возвращаемый тип int, нет параметров.

static int Main()

{

  // Перед выходом должен возвращать значение!

  return 0;

}

С выходом версии С# 7.1 метод

Main()

static Task Main()

static Task Main()

static Task Main(string[])

static Task Main(string[])

На заметку! Метод

Main()

Main()

Очевидно, что выбор способа создания метода

Main()

Main()

int

void

Main()

Использование операторов верхнего уровня (нововведение в версии 9.0)

Хотя и верно то, что до выхода версии C# 9.0 все приложения .NET Core на языке C# обязаны были иметь метод

Main()

Program

Main()

Program.cs

using System;

// Отобразить пользователю простое сообщение.

Console.WriteLine(***** Му First C# Арр *****);

Console.WriteLine("Hello World!");

Console.WriteLine();

// Ожидать нажатия клавиши , прежде чем завершить работу.

Console.ReadLine();

Запустив программу, вы увидите, что получается тот же самый результат! Существует несколько правил применения операторов верхнего уровня.

• Операторы верхнего уровня можно использовать только в одном файле внутри приложения.

• В случае применения операторов верхнего уровня программа не может иметь объявленную точку входа.

• Операторы верхнего уровня нельзя помещать в пространство имен.

• Операторы верхнего уровня по-прежнему имеют доступ к строковому массиву аргументов.

• Операторы верхнего уровня возвращают код завершения приложения (как объясняется в следующем разделе) с использованием

return

• Функции, которые объявлялись в классе

Program

• Дополнительные типы можно объявлять после всех операторов верхнего уровня. Объявление любых типов до окончания операторов верхнего уровня приводит к ошибке на этапе компиляции.

"За кулисами" компилятор заполняет пробелы. Исследуя сгенерированный код IL для обновленного кода, вы заметите такое определение

TypeDef

// TypeDef #1 (02000002)

// -------------------------------------------------------

//  TypDefName: $  (02000002)

//   Flags   : [NotPublic] [AutoLayout] [Class] [Abstract] [Sealed] [AnsiClass] 

   [BeforeFieldInit]  (00100180)

//  Extends  : 0100000D [TypeRef] System.Object

//  Method #1 (06000001) [ENTRYPOINT]

//  -------------------------------------------------------

//      MethodName: 
$ (06000001)

Сравните его с определением

TypeDef

// -------------------------------------------------------

// TypDefName: CalculatorExamples.Program  (02000002)

//  Flags   : [NotPublic] [AutoLayout] [Class] [AnsiClass] 

   [BeforeFieldInit]  (00100000)

//  Extends  : 0100000C [TypeRef] System.Object

//  Method #1 (06000001) [ENTRYPOINT]

//  -------------------------------------------------------

//     MethodName: Main (06000001)

В примере из главы 1 обратите внимание, что значение

TypDefName

CalculatorExamples

Program

MethodName

Main

$

TypDefName

$

Указание кода ошибки приложения (обновление в версии 9.0)

Хотя в подавляющем большинстве случаев методы

Main()

void

int

Task

0

-1

0

Main()

void

При использовании операторов верхнего уровня (следовательно, в отсутствие метода

Main()

0

Main()

В ОС Windows возвращаемое приложением значение сохраняется в переменной среды по имени

%ERRORLEVEL%

%ERRORLEVEL%

ExitCode

Поскольку возвращаемое значение передается системе в момент завершения работы приложения, вполне очевидно, что получить и отобразить финальный код ошибки во время выполнения приложения невозможно. Однако мы покажем, как просмотреть код ошибки по завершении программы, изменив операторы верхнего уровня следующим образом:

// Обратите внимание, что теперь возвращается int, а не void.

// Вывести сообщение и ожидать нажатия клавиши .

Console.WriteLine("***** My First C# App *****");

Console.WriteLine("Hello World!");

Console.WriteLine();

Console.ReadLine();

// Возвратить произвольный код ошибки.

return -1;

Если программа в качестве точки входа по-прежнему использует метод

Main()

int

void

static int Main()

{

  …

}

Теперь давайте захватим возвращаемое значение программы с помощью пакетного файла. Используя проводник Windows, перейдите в папку, где находится файл решения (например,

С:\SimpleCSharpApp

SimpleCSharpApp.cmd

*.cmd

@echo off

rem Пакетный файл для приложения SimpleCSharpApp.exe,

rem в котором захватывается возвращаемое им значение.

dotnet run

@if "%ERRORLEVEL%" == "0" goto success

:fail

  echo This application has failed!

  echo return value = %ERRORLEVEL%

  goto end

:success

  echo This application has succeeded!

  echo return value = %ERRORLEVEL%

  goto end

:end

echo All Done.

Откройте окно командной подсказки (или терминал VSC) и перейдите в папку, содержащую новый файл

*.cmd

Main()

-1

0

This application has succeeded!

***** My First C# App *****

Hello World!

This application has failed!

return value = -1

All Done.

Ниже приведен сценарий

PowerShell

*.cmd

dotnet run

if ($LastExitCode -eq 0) {

  Write-Host "This application has succeeded!"

} else

{

 Write-Host "This application has failed!"

}

Write-Host "All Done."

Введите

PowerShell

.\SimpleCSharpApp.psl

Вот что вы увидите в терминальном окне:

***** My First C# App *****

Hello World!

This application has failed!

All Done.

В подавляющем большинстве приложений C# (если только не во всех) в качестве возвращаемого значения будет применяться

void

Main()

void

Обработка аргументов командной строки

Теперь, когда вы лучше понимаете, что собой представляет возвращаемое значение метода

Main()

for

// Вывести сообщение и ожидать нажатия клавиши .

Console.WriteLine("***** My First C# App *****"); 

Console.WriteLine("Hello World!"); 

Console.WriteLine(); 

// Обработать любые входные аргументы. 

for (int i = 0; i < args.Length; i++) 

{ 

  Console.WriteLine("Arg: {0}", args[i]); 

} 

Console.ReadLine(); 

// Возвратить произвольный код ошибки,

return 0; 

На заметку! В этом примере применяются операторы верхнего уровня, т.е. метод

Main()

Main()

args

Снова загляните в код IL, который сгенерирован для программы, использующей операторы верхнего уровня. Обратите внимание, что метод

$

args

.class private abstract auto ansi sealed beforefieldinit '$'

    extends [System.Runtime]System.Object

{

  .custom instance void [System.Runtime]System.Runtime.CompilerServices.

CompilerGeneratedAttribute::.ctor()=

   ( 01 00 00 00 )

  .method private hidebysig static

      void '
$'(string[] args) cil managed

  {

   .entrypoint

   ...

  } // end of method '$'::'
$'

} // end of class '$'

Если в программе в качестве точки входа по-прежнему применяется метод

Main()

args

static int Main(string[] args)

{

  ...

}

Здесь с использованием свойства

Length

System.Array

System.Array

C:\SimpleCSharpApp>dotnet run /arg1 -arg2

***** My First C# App *****

Hello World!

Arg: /arg1

Arg: -arg2

Вместо стандартного цикла

for

foreach

foreach

// Обратите внимание, что в случае применения foreach

// отпадает необходимость в проверке размера массива.

foreach(string arg in args)

{

  Console.WriteLine("Arg: {0}", arg);

}

Console.ReadLine();

return 0;

Наконец, доступ к аргументам командной строки можно также получать с помощью статического метода

GetCommandLineArgs()

System.Environment

string

Main()

string

// Получить аргументы с использованием System.Environment.

string[] theArgs = Environment.GetCommandLineArgs();

foreach(string arg in theArgs)

{

  Console.WriteLine("Arg: {0}", arg);

}

Console.ReadLine();

return 0;

На заметку! Метод

GetCommandLineArgs()

Main()

string[] args

Разумеется, именно на вас возлагается решение о том, на какие аргументы командной строки должна реагировать программа (если они вообще будут предусмотрены), и как они должны быть сформатированы (например, с префиксом

-

/

-godmode

Указание аргументов командной строки в Visual Studio

В реальности конечный пользователь при запуске программы имеет возможность предоставлять аргументы командной строки. Тем не менее, указывать допустимые флаги командной строки также может требоваться во время разработки в целях тестирования программы. Чтобы сделать это в Visual Studio, щелкните правой кнопкой на имени проекта в окне Solution Explorer, выберите в контекстном меню пункт Properties (Свойства), в открывшемся окне свойств перейдите на вкладку Debug (Отладка) в левой части окна, введите желаемые аргументы в текстовом поле Application arguments (Аргументы приложения) и сохраните изменения (рис. 3.1).

Указанные аргументы командной строки будут автоматически передаваться методу

Main()

Почти во всех примерах приложений, создаваемых в начальных главах книги, будет интенсивно применяться класс

System.Console

Класс

Console

Console

Выполнение базового ввода и вывода с помощью класса Console

Дополнительно к членам, описанным в табл. 3.2, в классе

Console

Console

WriteLine()

Write()

ReadLine()

Read()

Чтобы реализовать базовый ввод-вывод с применением класса

Console

BasicConsoleIO

dotnet new console -lang c# -n BasicConsoleIO -o .\BasicConsoleIO -f net5.0

dotnet sln .\Chapter3_AllProjects.sln add .\BasicConsoleIO

Замените код

Program.cs

using System;

Console.WriteLine("***** Basic Console I/O *****");

GetUserData();

Console.ReadLine();

static void GetUserData()

{

}

На заметку! В Visual Studio и Visual Studio Code поддерживается несколько "фрагментов кода", которые после своей активизации вставляют код. Фрагмент кода

cw

Console.WriteLine()

cw

Теперь поместите после операторов верхнего уровня реализацию метода

GetUserData()

static void GetUserData()

{

  // Получить информацию об имени и возрасте.

  Console.Write("Please enter your name: ");  // Предложить ввести имя

  string userName = Console.ReadLine();

  Console.Write("Please enter your age: ");  // Предложить ввести возраст

  string userAge = Console.ReadLine();

  // Просто ради забавы изменить цвет переднего плана.

  ConsoleColor prevColor = Console.ForegroundColor;

  Console.ForegroundColor = ConsoleColor.Yellow;

  // Вывести полученную информацию на консоль.

  Console.WriteLine("Hello {0}! You are {1} years old.",

  userName, userAge);

  // Восстановить предыдущий цвет переднего плана.

  Console.ForegroundColor = prevColor;

}

После запуска приложения входные данные будут совершенно предсказуемо выводиться в окно консоли (с использованием указанного специального цвета).

Форматирование консольного вывода

В ходе изучения нескольких начальных глав вы могли заметить, что внутри различных строковых литералов часто встречались такие конструкции, как

{0}

{1}

printf()

Console.WriteLine()

Первый параметр метода

WriteLine()

{0}

{1}

{2}

0

WriteLine()

На заметку! Если уникально нумерованных заполнителей больше, чем заполняющих аргументов, тогда во время выполнения будет сгенерировано исключение, связанное с форматом. Однако если количество заполняющих аргументов превышает число заполнителей, то лишние аргументы просто игнорируются.

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

"9, Number 9, Number 9"

// Джон говорит...

Console.WriteLine("{0}, Number {0}, Number {0}", 9);

Также вы должны знать о возможности помещения каждого заполнителя в любую позицию внутри строкового литерала. К тому же вовсе не обязательно, чтобы заполнители следовали в возрастающем порядке своих номеров, например:

// Выводит: 20, 10, 30

Console.WriteLine("{1}, {0}, {2}", 10, 20, 30);

Строки можно также форматировать с использованием интерполяции строк, которая рассматривается позже в главе.

Форматирование числовых данных

Если для числовых данных требуется более сложное форматирование, то каждый заполнитель может дополнительно содержать разнообразные символы форматирования, наиболее распространенные из которых описаны в табл. 3.3.

Символы форматирования добавляются к заполнителям в виде суффиксов после двоеточия (например,

{0:С}

{1:d}

{2:X}

Main()

FormatNumericalData()

Program

// Демонстрация применения некоторых дескрипторов формата,

static void FormatNumericalData()

{

  Console.WriteLine("The value 99999 in various formats:");

  Console.WriteLine("c format: {0:c}", 99999);

  Console.WriteLine("d9 format: {0:d9}", 99999);

  Console.WriteLine("f3 format: {0:f3}", 99999);

  Console.WriteLine("n format: {0:n}", 99999);

  // Обратите внимание, что использование для символа

  // шестнадцатеричного формата верхнего или нижнего регистра

  // определяет регистр отображаемых символов.

  Console.WriteLine("E format: {0:E}", 99999);

  Console.WriteLine("e format: {0:e}", 99999);

  Console.WriteLine("X format: {0:X}", 99999);

  Console.WriteLine("x format: {0:x}", 99999);

}

Ниже показан вывод, получаемый в результате вызова метода

FormatNumericalData()

The value 99999 in various formats:

c format: $99,999.00

d9 format: 000099999

f3 format: 99999.000

n format: 99,999.00

E format: 9.999900E+004

e format: 9.999900e+004

X format: 1869F

x format: 1869f

В дальнейшем будут встречаться и другие примеры форматирования; если вас интересуют дополнительные сведения о форматировании строк, тогда обратитесь в документацию по .NET Core (

https://docs.microsoft.com/ru-ru/dotnet/standard/base-types/formatting-types

Форматирование числовых данных за рамками консольных приложений

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

string.Format()

Метод

string.Format()

string

// Использование string.Format() для форматирования строкового литерала.

 string userMessage = string.Format("100000 in hex is {0:x}", 100000);

Подобно любому языку программирования для фундаментальных типов данных в C# определены ключевые слова, которые используются при представлении локальных переменных, переменных-членов данных в классах, возвращаемых значений и параметров методов. Тем не менее, в отличие от других языков программирования такие ключевые слова в C# являются чем-то большим, нежели просто лексемами, распознаваемыми компилятором. В действительности они представляют собой сокращенные обозначения полноценных типов из пространства имен

System

На заметку! Вспомните из главы 1, что совместимый с CLS код .NET Core может быть задействован в любом другом управляемом языке программирования .NET Core. Если в программах открыт доступ к данным, не совместимым с CLS, тогда другие языки .NET Core могут быть не в состоянии их использовать.

Объявление и инициализация переменных

BasicDataTypes

dotnet new console -lang c# -n BasicDataTypes -o .\BasicDataTypes -f net5.0

dotnet sln .\Chapter3_AllProjects.sln add .\BasicDataTypes

using System;

using System.Numerics;

Console.WriteLine("***** Fun with Basic Data Types *****\n");

LocalVarDeclarations()

static void LocalVarDeclarations()

{

  Console.WriteLine("=> Data Declarations:");

  // Локальные переменные объявляются так:

  // типДанных имяПеременной;

  int myInt;

  string myString;

  Console.WriteLine();

}

static void LocalVarDeclarations()

{

  Console.WriteLine("=> Data Declarations:");

  // Локальные переменные объявляются и инициализируются так:

 // типДанных имяПеременной = начальноеЗначение;

  int myInt = 0;

  // Объявлять и присваивать можно также в двух отдельных строках.

  string myString;

  myString = "This is my character data";

  Console.WriteLine();

}

bool

static void LocalVarDeclarations()

{

  Console.WriteLine("=> Data Declarations:");

  int myInt = 0;

  string myString;

  myString = "This is my character data";

  // Объявить три переменных типа bool в одной строке.

  bool b1 = true, b2 = false, b3 = b1;

  Console.WriteLine();

}

bool

System.Boolean

LocalVarDeclarations()

static void LocalVarDeclarations()

{

  Console.WriteLine("=> Data Declarations:");

  // Локальные переменные объявляются и инициализируются так:

  // типДанных имяПеременной = начальноеЗначение;  int myInt = 0;

  string myString;

  myString = "This is my character data";

  // Объявить три переменных типа bool в одной строке,

  bool b1 = true, b2 = false, b3 = b1;

  // Использовать тип данных System.Boolean для объявления булевской переменной.

  System.Boolean b4 = false;

  Console.WriteLine("Your data: {0}, {1}, {2}, {3}, {4}, {5}",

    myInt, myString, b1, b2, b3, b4);

  Console.WriteLine();

}

default

default

DefaultDeclarations()

static void DefaultDeclarations()

{

  Console.WriteLine("=> Default Declarations:");

  int myInt = default;

}

Использование внутренних типов данных и операции new (обновление в версии 9.0)

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

new

• переменные типа

bool

false

• переменные числовых типов устанавливаются в

0

0.0

• переменные типа

char

• переменные типа

BigInteger

0

• переменные типа

DateTime

1/1/0001 12:00:00 AM

• объектные ссылки (включая переменные типа

string

null

На заметку! Тип данных

BigIntege

Применение ключевого слова

new

static void NewingDataTypes()

{

  Console.WriteLine("=> Using new to create variables:");

  bool b = new bool();        // Устанавливается в false

  int i = new int();         // Устанавливается в 0

  double d = new double();      // Устанавливается в 0.0

  DateTime dt = new DateTime();   // Устанавливается в 1/1/0001 12:00:00 AM

  Console.WriteLine("{0}, {1}, {2}, {3}", b, i, d, dt);

  Console.WriteLine();

}

В версии C# 9.0 появился сокращенный способ создания экземпляров переменных, предусматривающий применение ключевого слова

new()

NewingDataTypes

static void NewingDataTypesWith9()

{

  Console.WriteLine("=> Using new to create variables:");

  bool b = new();      // Устанавливается в false

  int i = new();      // Устанавливается в 0

  double d = new();     // Устанавливается в 0.0

  DateTime dt = new();   // Устанавливается в 1/1/0001 12:00:00 AM

  Console.WriteLine("{0}, {1}, {2}, {3}", b, i, d, dt);

  Console.WriteLine();

}

Иерархия классов для типов данных

Интересно отметить, что даже элементарные типы данных в.NET Core организованы в иерархию классов. Если вы не знакомы с концепцией наследования, тогда найдете все необходимые сведения в главе 6. А до тех пор просто знайте, что типы, находящиеся в верхней части иерархии классов, предоставляют определенное стандартное поведение, которое передается производным типам. На рис. 3.2 показаны отношения между основными системными типами.

Обратите внимание, что каждый тип в конечном итоге оказывается производным от класса

System.Object

ToString()

Equals()

GetHashCode()

Также важно отметить, что многие числовые типы данных являются производными от класса

System.ValueType

System.ValueType

System.Type

System.String

System.Array

System.Exception

System.Delegate

Не вдаваясь глубоко в детали классов

System.Object

System.ValueType

int

System.Int32

System.Int32

int

System.Object

static void ObjectFunctionality()

{

  Console.WriteLine("=> System.Object Functionality:");

  // Ключевое слово int языка C# - это в действительности сокращение для

  // типа System.Int32, который наследует от System.Object следующие члены:

  Console.WriteLine("12.GetHashCode() = {0}", 12.GetHashCode());

  Console.WriteLine("12.Equals(23) = {0}", 12.Equals(23));

  Console.WriteLine("12.ToString() = {0}", 12.ToString());

  Console.WriteLine("12.GetType() = {0}", 12.GetType());

  Console.WriteLine();

}

Вызов метода

ObjectFunctionality()

Main()

=> System.Object Functionality:

12.GetHashCode() = 12

12.Equals(23) = False

12.ToString() = 12

12.GetType() = System.Int32

Члены числовых типов данных

Продолжая эксперименты со встроенными типами данных С#, следует отметить, что числовые типы .NET Core поддерживают свойства

MaxValue

MinValue

MinValue

MaxValue

System.Double

static void DataTypeFunctionality()

{

  Console.WriteLine("=> Data type Functionality:");

  Console.WriteLine("Max of int: {0}", int.MaxValue);

  Console.WriteLine("Min of int: {0}", int.MinValue);

  Console.WriteLine("Max of double: {0}", double.MaxValue);

  Console.WriteLine("Min of double: {0}", double.MinValue);

  Console.WriteLine("double.Epsilon: {0}", double.Epsilon);

  Console.WriteLine("double.PositiveInfinity: {0}",

   double.PositiveInfinity);

  Console.WriteLine("double.NegativeInfinity: {0}",

   double.NegativeInfinity);

  Console.WriteLine();

}

В случае определения литерального целого числа (наподобие

500

int

55.333

double

long

l

L

4L

float

f

F

5.3F

m

М

300.5М

Члены System.Boolean

Рассмотрим тип данных

System.Boolean

bool

true

false

System.Boolean

MinValue

MaxValue

TrueString

FalseString

"True"

"False"

Вот пример:

Console.WriteLine("bool.FalseString: {0}", bool.FalseString);

Console.WriteLine("bool.TrueString: {0}", bool.TrueString);

Члены System.Char

Текстовые данные в C# представляются посредством ключевых слов

string

char

System.String

System.Char

string

"Hello"

char

string

'Н'

Помимо возможности хранения одиночного элемента символьных данных тип

System.Char

System.Char

static void CharFunctionality()

{

  Console.WriteLine("=> char type Functionality:");

  char myChar = 'a';

  Console.WriteLine("char.IsDigit('a'): {0}", char.IsDigit(myChar));

  Console.WriteLine("char.IsLetter('a'): {0}", char.IsLetter(myChar));

  Console.WriteLine("char.IsWhiteSpace('Hello There', 5): {0}",

   char.IsWhiteSpace("Hello There", 5));

  Console.WriteLine("char.IsWhiteSpace('Hello There', 6): {0}",

   char.IsWhiteSpace("Hello There", 6));

  Console.WriteLine("char.IsPunctuation('?'): {0}",

   char.IsPunctuation('?'));

  Console.WriteLine();

}

В методе

CharFunctionality()

System.Char

Разбор значений из строковых данных

Типы данных .NET Core предоставляют возможность генерировать переменную лежащего в основе типа, имея текстовый эквивалент (например, путем выполнения разбора) Такой прием может оказаться исключительно удобным, когда вы хотите преобразовывать в числовые значения некоторые вводимые пользователем данные (вроде элемента, выбранного в раскрывающемся списке внутри графического пользовательского интерфейса) Ниже приведен пример метода

ParseFromStrings()

static void ParseFromStrings()

{

  Console.WriteLine("=> Data type parsing:");

  bool b = bool.Parse("True");

  Console.WriteLine("Value of b: {0}", b);  // Вывод значения b

  double d = double.Parse("99.884");

  Console.WriteLine("Value of d: {0}", d);  // Вывод значения d

  int i = int.Parse("8");

  Console.WriteLine("Value of i: {0}", i);  // Вывод значения i

  char c = Char.Parse("w");

  Console.WriteLine("Value of c: {0}", c);  // Вывод значения с

  Console.WriteLine();

}

Использование метода TryParse() для разбора значений из строковых данных

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

bool b = bool.Parse("Hello");

Решение предусматривает помещение каждого вызова

Parse()

try-catch

TryParse()

TryParse()

out

out

bool

ParseFromStringWithTryParse()

static void ParseFromStringsWithTryParse()

{

  Console.WriteLine("=> Data type parsing with TryParse:");

  if (bool.TryParse("True", out bool b))

  {

   Console.WriteLine("Value of b: {0}", b);  // Вывод значения b

  }

  else

  {

   Console.WriteLine("Default value of b: {0}", b);

          // Вывод стандартного значения b

  }

  string value = "Hello";

  if (double.TryParse(value, out double d))

  {

   Console.WriteLine("Value of d: {0}", d);

  }

  else

 {

   // Преобразование входного значения в double потерпело неудачу

  // и переменной было присвоено стандартное значение.

   Console.WriteLine("Failed to convert the input ({0}) to a double

 and

            the variable was 

assigned the default {1}", value,d);

  }

  Console.WriteLine();

}

Если вы только начали осваивать программирование и не знаете, как работают операторы

if/else

TryParse()

true

TryParse()

false

Использование типов System.DateTime и System.TimeSpan

В пространстве имен

System

DateTime

TimeSpan

System.Void

Тип

DateTime

TimeSpan

static void UseDatesAndTimes()

{

  Console.WriteLine("=> Dates and Times:");

  // Этот конструктор принимает год, месяц и день.

  DateTime dt = new DateTime(2015, 10, 17);

  // Какой это день месяца?

  Console.WriteLine("The day of {0} is {1}", dt.Date, dt.DayOfWeek);

  // Сейчас месяц декабрь.

  dt = dt.AddMonths(2);

  Console.WriteLine("Daylight savings: {0}", dt.IsDaylightSavingTime());

  // Этот конструктор принимает часы, минуты и секунды.

  TimeSpan ts = new TimeSpan(4, 30, 0);

  Console.WriteLine(ts);

  // Вычесть 15 минут из текущего значения TimeSpan и вывести результат.

  Console.WriteLine(ts.Subtract(new TimeSpan(0, 15, 0)));

}

Работа с пространством имен System.Numerics

В пространстве имен

System.Numerics

BigInteger

BigInteger

На заметку! В пространстве имен

System.Numerics

Complex

Complex

Несмотря на то что во многих приложениях .NET Core потребность в структуре

BigInteger

using

// Здесь определен тип BigInteger:

using System.Numerics;

Теперь с применением операции

new

BigInteger

int

double

BigInteger

Простейший подход предусматривает определение большого числового значения в виде текстового литерала, который затем может быть преобразован в переменную

BigInteger

Parse()

BigInteger

На заметку! После того как переменной

BigInteger

BigInteger

BigInteger

Multiply()

В любом случае после определения переменной

BigInteger

float

int

BigInteger

BigInteger

BigInteger

static void UseBigInteger()

{

  Console.WriteLine("=> Use BigInteger:");

  BigInteger biggy =

   BigInteger.Parse("9999999999999999999999999999999999999999999999");

  Console.WriteLine("Value of biggy is {0}", biggy);

  Console.WriteLine("Is biggy an even value?: {0}", biggy.IsEven);

  Console.WriteLine("Is biggy a power of two?: {0}", biggy.IsPowerOfTwo);

  BigInteger reallyBig = BigInteger.Multiply(biggy,

   BigInteger.Parse("8888888888888888888888888888888888888888888"));

  Console.WriteLine("Value of reallyBig is {0}", reallyBig);

}

Важно отметить, что тип данных

BigInteger

+

-

*

BigInteger.Multiply()

BigInteger reallyBig2 = biggy * reallyBig;

К настоящему моменту вы должны понимать, что ключевые слова С#, представляющие базовые типы данных, имеют соответствующие типы в библиотеках базовых классов .NET Core, каждый из которых предлагает фиксированную функциональность. Хотя абсолютно все члены этих типов данных в книге подробно не рассматриваются, имеет смысл изучить их самостоятельно. Подробные описания разнообразных типов данных .NET Core можно найти в документации по .NET Core — скорее всего, вы будете удивлены объемом их встроенной функциональности.

Использование разделителей групп цифр (нововведение в версии 7.0)

Временами при присваивании числовой переменной крупных чисел цифр оказывается больше, чем способен отслеживать глаз. В версии C# 7.0 был введен разделитель групп цифр в виде символа подчеркивания (

_

int

long

decimal

double

static void DigitSeparators()

{

  Console.WriteLine("=> Use Digit Separators:");

  Console.Write("Integer:");    // Целое

  Console.WriteLine(123_456);

  Console.Write("Long:");      // Длинное целое

  Console.WriteLine(123_456_789L);

  Console.Write("Float:");     // С плавающей точкой

  Console.WriteLine(123_456.1234F);

  Console.Write("Double:");     // С плавающей точкой двойной точности

  Console.WriteLine(123_456.12);

  Console.Write("Decimal:");    // Десятичное

  Console.WriteLine(123_456.12M);

            // Обновление в версии 7.2: шестнадцатеричное значение

           // может начинаться с символа _

  Console.Write("Hex:");

  Console.WriteLine(0x_00_00_FF);  // Шестнадцатеричное

}

Использование двоичных литералов (нововведение в версии 7.0/7.2)

В версии C# 7.0 появился новый литерал для двоичных значений, которые представляют, скажем, битовые маски. Новый разделитель групп цифр работает с двоичными литералами, а в версии C# 7.2 разрешено начинать двоичные и шестнадцатеричные числа начинать с символа подчеркивания. Теперь двоичные числа можно записывать ожидаемым образом, например:

0b_0001_0000

Вот метод, в котором иллюстрируется использование новых литералов с разделителем групп цифр:

static void BinaryLiterals()

{

  // Обновление в версии 7.2: двоичное значение может начинаться с символа _

  Console.WriteLine("=> Use Binary Literals:");

  Console.WriteLine("Sixteen: {0}",0b_0001_0000);    // 16

  Console.WriteLine("Thirty Two: {0}",0b_0010_0000);  // 32

  Console.WriteLine("Sixty Four: {0}",0b_0100_0000);  // 64

}

Класс

System.String

Выполнение базовых манипуляций со строками

Работа с членами

System.String

string

System.String

Создайте новый проект консольного приложения по имени

FunWithStrings

using System;

using System.Text;

BasicStringFunctionality();

static void BasicStringFunctionality()

{

  Console.WriteLine("=> Basic String functionality:");

  string firstName = "Freddy";

  // Вывод значения firstName.

  Console.WriteLine("Value of firstName: {0}", firstName);

  // Вывод длины firstname.

  Console.WriteLine("firstName has {0} characters.", firstName.Length);

  // Вывод firstName в верхнем регистре.

  Console.WriteLine("firstName in uppercase: {0}", firstName.ToUpper());

  // Вывод firstName в нижнем регистре.

  Console.WriteLine("firstName in lowercase: {0}", firstName.ToLower());

  // Содержит ли firstName букву у?

  Console.WriteLine("firstName contains the letter y?: {0}",

           firstName.Contains("y"));

  // Вывод firstName после замены.

  Console.WriteLine("New first name: {0}", firstName.Replace("dy", ""));

  Console.WriteLine();

}

Здесь объяснять особо нечего: метод просто вызывает разнообразные члены, такие как

ToUpper()

Contains()

string

***** Fun with Strings *****

=> Basic String functionality:

Value of firstName: Freddy

firstName has 6 characters.

firstName in uppercase: FREDDY

firstName in lowercase: freddy

firstName contains the letter y?: True

firstName after replace: Fred

Несмотря на то что вывод не выглядит особо неожиданным, вывод, полученный в результате вызова метода

Replace()

firstName

string

Выполнение конкатенации строк

Переменные

string

+

static void StringConcatenation()

{

  Console.WriteLine("=> String concatenation:");

  string s1 = "Programming the ";

  string s2 = "PsychoDrill (PTP)";

  string s3 = s1 + s2;

  Console.WriteLine(s3);

  Console.WriteLine();

}

Интересно отметить, что при обработке символа

+

String.Concat()

String.Concat()

static void StringConcatenation()

{

  Console.WriteLine("=> String concatenation:");

  string s1 = "Programming the ";

  string s2 = "PsychoDrill (PTP)";

  string s3 = String.Concat(s1, s2);

  Console.WriteLine(s3);

  Console.WriteLine();

}

Использование управляющих последовательностей

Подобно другим языкам, основанным на С, строковые литералы C# могут содержать разнообразные управляющие последовательности, которые позволяют уточнять то, как символьные данные должны быть представлены в потоке вывода. Каждая управляющая последовательность начинается с символа обратной косой черты, за которым следует специфический знак. В табл. 3.6 перечислены наиболее распространенные управляющие последовательности.

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

\t

\"

\\

\n

static void EscapeChars()

{

  Console.WriteLine("=> Escape characters:\a");

  string strWithTabs = "Model\tColor\tSpeed\tPet Name\a ";

  Console.WriteLine(strWithTabs);

  Console.WriteLine("Everyone loves \"Hello World\"\a ");

  Console.WriteLine("C:\\MyApp\\bin\\Debug\a ");

  // Добавить четыре пустых строки и снова выдать звуковой сигнал.

  Console.WriteLine("All finished.\n\n\n\a ");

  Console.WriteLine();

}

Выполнение интерполяции строк

Синтаксис с фигурными скобками, продемонстрированный ранее в главе

({0}, {1}

Взгляните на показанный ниже дополнительный метод в нашем классе

Program(StringInterpolation()

string

static void StringInterpolation()

{

   Console.WriteLine("=> String interpolation:\a");

   // Некоторые локальные переменные будут включены в крупную строку.

   int age = 4;

   string name = "Soren";

   // Использование синтаксиса с фигурными скобками.

   string greeting = string.Format("Hello {0} you are {1} years old.",

                   name, age);

   Console.WriteLine(greeting);

   // Использование интерполяции строк.

   string greeting2 = $"Hello {name} you are {age} years old.";

   Console.WriteLine(greeting2);

}

В переменной

greeting2

$

С новым синтаксисом связан еще один интересный аспект: фигурные скобки, используемые в интерполяции строк, обозначают допустимую область видимости. Таким образом, с переменными можно применять операцию точки, чтобы изменять их состояние. Рассмотрим модификацию кода присваивания переменных

greeting

greeting2

string greeting = string.Format("Hello {0} you are {1} years old.",

                  name.ToUpper(), age);

string greeting2 = $"Hello {name.ToUpper()} you are {age} years old.";

Здесь посредством вызова

ToUpper()

{age += 1}

Полезно также отметить, что в рамках нового синтаксиса внутри строкового литерала по-прежнему можно использовать управляющие последовательности. Таким образом, для вставки символа табуляции необходимо применять последовательность

\t

string greeting = string.Format("\tHello {0} you are {1} years old.",

                  name.ToUpper(), age);

string greeting2 = $"\tHello {name.ToUpper()} you are {age} years old.";

Определение дословных строк (обновление в версии 8.0)

Когда вы добавляете к строковому литералу префикс

@

string

\\

// Следующая строка воспроизводится дословно,

// так что отображаются все управляющие символы.

Console.WriteLine(@"C:\MyApp\bin\Debug");

Также обратите внимание, что дословные строки могут использоваться для предохранения пробельных символов в строках, разнесенных по нескольким строкам вывода:

// При использовании дословных строк пробельные символы предохраняются.

string myLongString = @"This is a very

   very

      very

        long string";

Console.WriteLine(myLongString);

Применяя дословные строки, в литеральную строку можно также напрямую вставлять символы двойной кавычки, просто дублируя знак

"

Console.WriteLine(@"Cerebus said ""Darrr! Pret-ty sun-sets""");

Дословные строки также могут быть интерполированными строками за счет указания операций интерполяции (

$

@

string interp = "interpolation";

string myLongString2 = $@"This is a very

  very

     long string with {interp}";

Нововведением в версии C# 8 является то, что порядок следования этих операций не имеет значения. Работать будет либо

$@

@$

Работа со строками и операциями равенства

==

! =

true

string

string

static void StringEquality()

{

  Console.WriteLine("=> String equality:");

  string s1 = "Hello!";

  string s2 = "Yo!";

  Console.WriteLine("s1 = {0}", s1);

  Console.WriteLine("s2 = {0}", s2);

  Console.WriteLine();

  // Проверить строки на равенство.

  Console.WriteLine("s1 == s2: {0}", s1 == s2);

  Console.WriteLine("s1 == Hello!: {0}", s1 == "Hello!");

  Console.WriteLine("s1 == HELLO!: {0}", s1 == "HELLO!");

  Console.WriteLine("s1 == hello!: {0}", s1 == "hello!");

  Console.WriteLine("s1.Equals(s2): {0}", s1.Equals(s2));

  Console.WriteLine("Yo!.Equals(s2): {0}", "Yo!".Equals(s2));

  Console.WriteLine();

}

string

"Hello!"

"HELLO!"

"hello!"

string

System.String

Equals()

String

"Yo!"

System.String

Модификация поведения сравнения строк

Как уже упоминалось, операции равенства строк (

Compare()

,

Equals()

и

==

), а также функция

IndexOf()

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

if (firstString.ToUpper() == secondString.ToUpper())

{

  // Делать что-то

}

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

ToUpper()

? Результатом будет трудная в обнаружении ошибка.

Гораздо лучший прием предусматривает применение перегруженных версий перечисленных ранее методов, которые принимают значение перечисления

StringComparison

, управляющего выполнением сравнения. Значения

StringComparison

описаны в табл. 3.7.

Чтобы взглянуть на результаты применения

StringComparison

, создайте новый метод по имени

StringEqualitySpecifyingCompareRules()

со следующим кодом:

static void StringEqualitySpecifyingCompareRules()

{

  Console.WriteLine("=> String equality (Case Insensitive:");

  string s1 = "Hello!";

  string s2 = "HELLO!";

  Console.WriteLine("s1 = {0}", s1);

  Console.WriteLine("s2 = {0}", s2);

  Console.WriteLine();

  // Проверить результаты изменения стандартных правил сравнения.

  Console.WriteLine("Default rules: s1={0},s2={1}s1.Equals(s2): {2}",

           s1, s2, 

s1.Equals(s2));

 Console.WriteLine("Ignore case: s1.Equals(s2,

           StringComparison.OrdinalIgnoreCase): {0}",

           s1.Equals(s2, StringComparison.OrdinalIgnoreCase));

  Console.WriteLine("Ignore case, Invariant Culture: s1.Equals(s2,

        StringComparison.

InvariantCultureIgnoreCase): {0}",

        s1.Equals(s2, StringComparison.InvariantCultureIgnoreCase));

  Console.WriteLine();

  Console.WriteLine("Default rules: s1={0},s2={1} s1.IndexOf(\"E\"): {2}",

           s1, s2, 

s1.IndexOf("E"));

  Console.WriteLine("Ignore case: s1.IndexOf(\"E\",

           StringComparison.OrdinalIgnoreCase): 

           {0}", s1.IndexOf("E",

           StringComparison.OrdinalIgnoreCase));

  Console.WriteLine("Ignore case, Invariant Culture: s1.IndexOf(\"E\",

       StringComparison.

InvariantCultureIgnoreCase): {0}",

       s1.IndexOf("E", StringComparison.InvariantCultureIgnoreCase));

  Console.WriteLine();

}

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

StringComparison

становится обязательным.

Строки неизменяемы

Один из интересных аспектов класса

System.String

System.String

string

string

static void StringsAreImmutable()

{

  Console.WriteLine("=> Immutable Strings:\a");

  // Установить начальное значение для строки.

  string s1 = "This is my string.";

  Console.WriteLine("s1 = {0}", s1);

  // Преобразована ли строка si в верхний регистр?

  string upperString = s1.ToUpper();

  Console.WriteLine("upperString = {0}", upperString);

  // Нет! Строка si осталась в том же виде!

  Console.WriteLine("s1 = {0}", s1);

}

Просмотрев показанный далее вывод, можно убедиться, что в результате вызова метода

ToUpper()

string(s1)

string

s1 = This is my string.

upperString = THIS IS MY STRING.

s1 = This is my string.

Тот же самый закон неизменяемости строк действует и в случае применения операции присваивания С#. Чтобы проиллюстрировать, реализуем следующий метод

StringsAreImmutable2()

static void StringsAreImmutable2()

{

   Console.WriteLine("=> Immutable Strings 2:\a");

  string s2 = "My other string";

  s2 = "New string value";

}

Скомпилируйте приложение и запустите

ildasm.exe

StringsAreImmutable2()

.method private hidebysig static void  StringsAreImmutable2() cil managed

{

  // Code size    21 (0x15)

  .maxstack  1

  .locals init (string V_0)

  IL_0000:  nop

  IL_0001:  ldstr    "My other string"

  IL_0006:  stloc.0

  IL_0007:  ldstr    "New string value" /* 70000B3B */

  IL_000c:  stloc.0

  IL_000d:  ldloc.0

  IL_0013:  nop

  IL_0014:  ret

} // end of method Program::StringsAreImmutable2

Хотя низкоуровневые детали языка CIL пока подробно не рассматривались, обратите внимание на многочисленные вызовы кода операции

ldstr

ldstr

string

string

"Му other string"

Так что же в точности из всего этого следует? Выражаясь кратко, класс

string

string

Однако когда строится приложение, в котором текстовые данные будут часто изменяться (подобное текстовому процессору), то представление обрабатываемых текстовых данных с применением объектов

string

Использование типа System.Text.StringBuilder

С учетом того, что тип

string

System.Text

StringBuilder

System.String

StringBuilder

StringBuilder

// Здесь определен класс StringBuilder:

using System.Text;

Уникальность класса

StringBuilder

StringBuilder

new

StringBuilder

static void FunWithStringBuilder()

{

  Console.WriteLine("=> Using the StringBuilder:");

  StringBuilder sb = new StringBuilder("**** Fantastic Games ****");

  sb.Append("\n");

  sb.AppendLine("Half Life");

  sb.AppendLine("Morrowind");

  sb.AppendLine("Deus Ex" + "2");

  sb.AppendLine("System Shock");

  Console.WriteLine(sb.ToString());

  sb.Replace("2", " Invisible War");

  Console.WriteLine(sb.ToString());

  Console.WriteLine("sb has {0} chars.", sb.Length);

  Console.WriteLine();

}

Здесь создается объект

StringBuilder

"**** Fantastic Games ****"

StringBuilder

// Создать экземпляр StringBuilder с исходным размером в 256 символов.

StringBuilder sb = new StringBuilder("**** Fantastic Games ****", 256);

При добавлении большего количества символов, чем в указанном лимите, объект

StringBuilder

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

TypeConversions

using System;

Console.WriteLine("***** Fun with type conversions *****");

// Сложить две переменные типа short и вывести результат.

short numb1 = 9, numb2 = 10;

Console.WriteLine("{0} + {1} = {2}",

  numb1, numb2, Add(numb1, numb2));

Console.ReadLine();

static int Add(int x, int y)

{

  return x + y;

}

Легко заметить, что метод

Add()

int

short

Причина, по которой компилятор считает такой код синтаксически корректным, связана с тем, что потеря данных в нем невозможна. Из-за того, что максимальное значение для типа

short

int

short

int

На заметку! Разрешенные расширяющие и сужающие (обсуждаются далее) преобразования, поддерживаемые для каждого типа данных С#, описаны в разделе "Type Conversion Tables in .NET" ("Таблицы преобразования типов в .NET") документации по .NET Core.

Несмотря на то что неявное расширение типов благоприятствовало в предыдущем примере, в других ситуациях оно может стать источником ошибок на этапе компиляции. Например, пусть для переменных

numb1

numb2

short

Add()

short

static void Main(string[] args)

{

  Console.WriteLine("***** Fun with type conversions *****");

  // Следующий код вызовет ошибку на этапе компиляции!

  short numb1 = 30000, numb2 = 30000;

  short answer = Add(numb1, numb2);

  Console.WriteLine("{0} + {1} = {2}",

   numb1, numb2, answer);

  Console.ReadLine();

}

В данном случае компилятор сообщит об ошибке:

Cannot implicitly convert type 'int' to 'short'. An explicit conversion exists (are you missing a cast?)

He удается неявно преобразовать тип int в short. Существует явное преобразование (возможно, пропущено приведение)

Проблема в том, что хотя метод

Add()

int

System.Int32

short,

short

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

// Снова ошибка на этапе компиляции!

static void NarrowingAttempt()

{

  byte myByte = 0;

  int myInt = 200;

  myByte = myInt;

  Console.WriteLine("Value of myByte: {0}", myByte);

}

Здесь значение, содержащееся в переменной типа

int(myInt)

byte

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

()

Program

class Program

{

  static void Main(string[] args)

  {

   Console.WriteLine("***** Fun with type conversions *****");

   short numb1 = 30000, numb2 = 30000;

   // Явно привести int к short (и разрешить потерю данных).

   short answer = (short)Add(numb1, numb2);

   Console.WriteLine("{0} + {1} = {2}",

    numb1, numb2, answer);

   NarrowingAttempt();

   Console.ReadLine();

  }

 static int Add(int x, int y)

 {

   return x + y;

 }

  static void NarrowingAttempt()

  {

   byte myByte = 0;

   int myInt = 200;

   // Явно привести int к byte (без потери данных).

   myByte = (byte)myInt;

   Console.WriteLine("Value of myByte: {0}", myByte);

  }

}

Теперь компиляция кода проходит успешно, но результат сложения оказывается совершенно неправильным:

***** Fun with type conversions *****

30000 + 30000 = -5536

Value of myByte: 200

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

NarrowingAttempt()

byte

short

Main()

Для построения приложений, в которых потеря данных не допускается, язык C# предлагает ключевые слова

checked

unchecked

Использование ключевого слова checked

Давайте начнем с выяснения роли ключевого слова

checked

Program

byte

int

byte

static void ProcessBytes()

{

  byte b1 = 100;

  byte b2 = 250;

  byte sum = (byte)Add(b1, b2);

  // В sum должно содержаться значение 350.

  // Однако там оказывается значение 94!

  Console.WriteLine("sum = {0}", sum);

}

Удивительно, но при просмотре вывода приложения обнаруживается, что в переменной sum содержится значение 94 (а не 350, как ожидалось). Причина проста. Учитывая, что

System.Byte

sum

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

К счастью, язык C# предоставляет ключевое слово

checked

checked

Если происходит переполнение, тогда во время выполнения генерируется исключение

System.OverflowException

try

catch

static void ProcessBytes()

{

  byte b1 = 100;

  byte b2 = 250;

  // На этот раз сообщить компилятору о необходимости добавления

  // кода CIL, необходимого для генерации исключения, если возникает

  // переполнение или потеря значимости.

  try

  {

   byte sum = checked((byte)Add(b1, b2));

   Console.WriteLine("sum = {0}", sum);

  }

  catch (OverflowException ex)

  {

   Console.WriteLine(ex.Message);

  }

}

Обратите внимание, что возвращаемое значение метода

Add()

checked

sum

byte

Message

Arithmetic operation resulted in an overflow.

Арифметическая операция привела к переполнению.

Чтобы обеспечить принудительную проверку переполнения для целого блока операторов, контекст

checked

try

{

  checked

  {

   byte sum = (byte)Add(b1, b2);

   Console.WriteLine("sum = {0}", sum);

  }

}

catch (OverflowException ex)

{

  Console.WriteLine(ex.Message);

}

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

Настройка проверки переполнения на уровне проекта

Если создается приложение, в котором никогда не должно возникать молчаливое переполнение, то может обнаружиться, что в контекст ключевого слова

checked

/checked

checked

   true

Настройка проверки переполнения на уровне проекта (Visual Studio)

Для активизации флага

/checked

/checked

На заметку! Если вы не выберете в списке вариант All Configurations, тогда настройка будет применена только к конфигурации, выбранной в текущий момент (т.е Debug (Отладка) или Release (Выпуск)).

Использование ключевого слова unchecked

А теперь предположим, что проверка переполнения и потери значимости включена в масштабах проекта, но есть блок кода, в котором потеря данных приемлема. Как с ним быть? Учитывая, что действие флага

/checked

unchecked

unchecked

checked

// Предполагая, что флаг /checked активизирован, этот блок

// не будет генерировать исключение времени выполнения.

unchecked

{

  byte sum = (byte)(b1 + b2);

  Console.WriteLine("sum = {0} ", sum);

}

Подводя итоги по ключевым словам

checked

unchecked

checked

/checked

unchecked

Вплоть до этого места в главе при объявлении каждой локальной переменной явно указывался ее тип данных:

static void DeclareExplicitVars()

{

  // Явно типизированные локальные переменные

  // объявляются следующим образом:

  // типДанных имяПеременной = начальноеЗначение;

  int myInt = 0;

  bool myBool = true;

  string myString = "Time, marches on...";

}

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

var

var

int

bool

string

Чтобы прояснить роль неявной типизации, создайте новый проект консольного приложения по имени

ImplicitlyTypedLocalVars

Program.cs

using System;

using System.Linq;

Console.WriteLine("***** Fun with Implicit Typing *****");

Добавьте следующую функцию, которая демонстрирует неявные объявления:

static void DeclareImplicitVars ()

{

  // Неявно типизированные локальные переменные

  // объявляются следующим образом:

  // var имяПеременной = начальноеЗначение;

  var myInt = 0;

  var myBool = true;

  var myString = "Time, marches on...";

}

На заметку! Строго говоря,

var

var

var

В таком случае, основываясь на первоначально присвоенных значениях, компилятор способен вывести для переменной

myInt

System.Int32

myBool

System.Boolean

myString

System.String

DeclareImplicitVars()

static void DeclareImplicitVars()

{

  // Неявно типизированные локальные переменные,

  var myInt = 0;

  var myBool = true;

  var myString = "Time, marches on...";

  // Вывести имена лежащих в основе типов.

  Console.WriteLine("myInt is a: {0}", myInt.GetType().Name);

           // Вывод типа myInt

  Console.WriteLine("myBool is a: {0}", myBool.GetType().Name);

           // Вывод типа myBool

  Console.WriteLine("myString is a: {0}", myString.GetType().Name);

           // Вывод типа myString

}

На заметку! Имейте в виду, что такую неявную типизацию можно использовать для любых типов, включая массивы, обобщенные типы (см. главу 10) и собственные специальные типы. В дальнейшем вы увидите и другие примеры неявной типизации. Вызов метода

DeclareImplicitVars()

***** Fun with Implicit Typing *****

myInt is a: Int32

myBool is a: Boolean

myString is a: String

Неявное объявление чисел

Неявное объявление Как утверждалось ранее, целые числа по умолчанию получают тип

int

double

DeclareImplicitNumerics

static void DeclareImplicitNumerics ( )

{

  // Неявно типизированные числовые переменные.

  var myUInt = 0u;

  var myInt = 0;

  var myLong = 0L;

  var myDouble = 0.5;

  var myFloat = 0.5F;

  var myDecimal = 0.5M;

  // Вывод лежащего в основе типа.

  Console.WriteLine("myUInt is a: {0}", myUInt.GetType().Name);

  Console.WriteLine("myInt is a: {0}", myInt.GetType().Name);

  Console.WriteLine("myLong is a: {0}", myLong.GetType().Name);

  Console.WriteLine("myDouble is a: {0}", myDouble.GetType().Name);

  Console.WriteLine("myFloat is a: {0}", myFloat.GetType().Name);

  Console.WriteLine("myDecimal is a: {0}", myDecimal.GetType().Name);

}

Ограничения неявно типизированных переменных

С использованием ключевого слова

var

var

class ThisWillNeverCompile

{

  // Ошибка! Ключевое слово var не может применяться к полям!

  private var myInt = 10;

  // Ошибка! Ключевое слово var не может применяться

  // к возвращаемому значению или типу параметра!

  public var MyMethod(var x, var y){}

}

Кроме того, локальным переменным, которые объявлены с ключевым словом

var

null

null

// Ошибка! Должно быть присвоено значение!

var myData;

// Ошибка! Значение должно присваиваться в самом объявлении!

var myInt;

myInt = 0;

// Ошибка! Нельзя присваивать null в качестве начального значения!

var myObj = null;

Тем не менее, присваивать

null

// Допустимо, если SportsCar имеет ссылочный тип!

var myCar = new SportsCar();

myCar = null;

Вдобавок значение неявно типизированной локальной переменной допускается присваивать другим переменным, которые типизированы как неявно, так и явно:

// Также нормально!

var myInt = 0;

var anotherlnt = myInt;

string myString = "Wake up!";

var myData = myString;

Кроме того, неявно типизированную локальную переменную разрешено возвращать вызывающему коду при условии, что возвращаемый тип метода и выведенный тип переменной, определенной посредством

var

static int GetAnlntO

{

  var retVal = 9;

  return retVal;

}

Неявно типизированные данные строго типизированы

Имейте в виду, что неявная типизация локальных переменных дает в результате строго типизированные данные. Таким образом, применение ключевого слова

var

var

Variant

На заметку! В C# поддерживается возможность динамической типизации с применением ключевого слова

dynamic

Взамен средство выведения типов сохраняет аспект строгой типизации языка C# и воздействует только на объявление переменных при компиляции. Затем данные трактуются, как если бы они были объявлены с выведенным типом; присваивание такой переменной значения другого типа будет приводить к ошибке на этапе компиляции.

static void ImplicitTypingIsStrongTyping()

{

  // Компилятору известно, что s имеет тип System.String.

  var s = "This variable can only hold string data!";

  s = "This is fine...";

  // Можно обращаться к любому члену лежащего в основе типа.

  string upper = s.ToUpper();

  // Ошибка! Присваивание числовых данных строке не допускается!

  s = 44;

}

Полезность неявно типизированных локальных переменных

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

var

int

int

Однако, как будет показано в начале главы 13, в наборе технологий LINQ применяются выражения запросов, которые могут выдавать динамически создаваемые результирующие наборы, основанные на формате самого запроса. В таких случаях неявная типизация исключительно удобна, потому что вам не придется явно определять тип, который запрос может возвращать, а в ряде ситуаций это вообще невозможно. Посмотрите, сможете ли вы определить лежащий в основе тип данных

subset

static void LinqQueryOverInts()

{

  int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 };

  // Запрос LINQ!

  var subset = from i in numbers where i < 10 select i;

  Console.Write("Values in subset: ");

  foreach (var i in subset)

  {

   Console.Write("{0} ", i);

  }

  Console.WriteLine();

  // К какому же типу относится subset?

  Console.WriteLine("subset is a: {0}", subset.GetType().Name);

  Console.WriteLine("subset is defined in: {0}",

            subset.GetType().Namespace);

}

Вы можете предположить, что типом данных

subset

ildasm.exe

Фактически можно было бы даже утверждать, что единственным случаем, когда применение ключевого слова

var

int

int

var

Все языки программирования предлагают средства для повторения блоков кода до тех пор, пока не будет удовлетворено условие завершения. С каким бы языком вы не имели дело в прошлом, итерационные операторы C# не должны вызывать особого удивления или требовать лишь небольшого объяснения. В C# предоставляются четыре итерационные конструкции:

• цикл

for

• цикл

foreach/in

• цикл

while

• цикл

do/while

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

IterationsAndDecisions

На заметку! Материал данного раздела главы будет кратким и по существу, т.к. здесь предполагается наличие у вас опыта работы с аналогичными ключевыми словами (

if

for

switch

https://docs.microsoft.com/ru-ru/dotnet/csharp/

Использование цикла for

Когда требуется повторять блок кода фиксированное количество раз, хороший уровень гибкости предлагает оператор

for

// Базовый цикл for.

static void ForLoopExample()

{

  // Обратите внимание, что переменная i видима только в контексте цикла for.

  for(int i = 0; i < 4; i++)

  {

   Console.WriteLine("Number is: {0} ", i);

  }

  // Здесь переменная i больше видимой не будет.

}

Все трюки, которые вы научились делать в языках С, C++ и Java, по-прежнему могут использоваться при формировании операторов

for

--

goto

continue

break

Использование цикла foreach

Ключевое слово

foreach

for

foreach

Однако если нужно просто выполнить проход по коллекции элемент за элементом, то цикл

foreach

foreach

in

// Проход по элементам массива посредством foreach.

static void ForEachLoopExample()

{

  string[] carTypes = {"Ford", "BMW", "Yugo", "Honda" };

  foreach (string c in carTypes)

  {

   Console.WriteLine(c);

  }

  int[] myInts = { 10, 20, 30, 40 };

  foreach (int i in myInts)

  {

   Console.WriteLine(i);

  }

}

За ключевым словом

in

IEnumerable

List

foreach

Использование неявной типизации в конструкциях foreach

В итерационных конструкциях

foreach

subset

using

using System.Linq;

static void LinqQueryOverInts()

{

  int[] numbers = { 10, 20, 30, 40, 1, 2, 3, 8 };

  // Запрос LINQ!

  var subset = from i in numbers where i < 10 select i;

  Console.Write("Values in subset: ");

  foreach (var i in subset)

  {

   Console.Write("{0} ", i);

  }

}

Использование циклов while и do/while

Итерационная конструкция

while

while

"In while loop"

yes

static void WhileLoopExample()

{

  string userIsDone = "";

  // Проверить копию строки в нижнем регистре.

  while(userIsDone.ToLower() != "yes")

  {

   Console.WriteLine("In while loop");

   Console.Write("Are you done? [yes] [no]: "); // Запрос продолжения

   userIsDone = Console.ReadLine();

  }

}

С циклом

while

do/while

while

do/while

do/while

while

static void DoWhileLoopExample()

{

  string userIsDone = "";

  do

  {

   Console.WriteLine("In do/while loop");

   Console.Write("Are you done? [yes] [no]: ");

   userIsDone = Console.ReadLine();

  }while(userIsDone.ToLower() != "yes"); // Обратите внимание на точку с запятой!

}

Теперь, когда вы умеете многократно выполнять блок операторов, давайте рассмотрим следующую связанную концепцию — управление потоком выполнения программы. Для изменения потока выполнения программы на основе разнообразных обстоятельств в C# определены две простые конструкции:

• оператор

if/else

• оператор

switch

На заметку! В версии C# 7 выражение

is

switch

if/else

switch

is

Использование оператора if/else

Первым мы рассмотрим оператор

if/else

if/else

-1

0

Использование операций отношения и равенства

Обычно для получения литерального булевского значения в операторах

if/else

И снова программисты на С и C++ должны помнить о том, что старые трюки с проверкой условия, которое включает значение, не равное нулю, в языке C# работать не будут. Пусть необходимо проверить, содержит ли текущая строка более нуля символов. У вас может возникнуть соблазн написать такой код:

static void IfElseExample()

{

  // This is illegal, given that Length returns an int, not a bool.

  string stringData = "My textual data";

  if(stringData.Length)

  {

   // Строка длиннее 0 символов

   Console.WriteLine("string is greater than 0 characters");

  }

  else

  {

   // Строка не длиннее 0 символов

   Console.WriteLine("string is not greater than 0 characters");

  }

  Console.WriteLine();

}

Если вы хотите использовать свойство

String.Length

// Допустимо, т.к. условие возвращает true или false.

If (stringData.Length > 0)

{

  Console.WriteLine("string is greater than 0 characters");

}

Использование операторов if/else и сопоставления с образцом (нововведение в версии 7.0)

В версии C# 7.0 появилась возможность применять в операторах

if/else

is

Метод

IfElsePatternMatching()

string

int

static void IfElsePatternMatching()

{

  Console.WriteLine("===If Else Pattern Matching ===/n");

  object testItem1 = 123;

  object testItem2 = "Hello";

  if (testItem1 is string myStringValue1)

  {

   Console.WriteLine($"{myStringValue1} is a string");

          // testIteml имеет тип string

  }

  if (testItem1 is int myValue1)

  {

   Console.WriteLine($"{myValue1} is an int");

          // testIteml имеет тип int

  }

  if (testItem2 is string myStringValue2)

  {

   Console.WriteLine($"{myStringValue2} is a string");

          // testItem2 имеет тип string

  }

  if (testItem2 is int myValue2)

  {

   Console.WriteLine($"{myValue2} is an int");

          // testItem2 имеет тип int

  }

  Console.WriteLine();

}

Внесение улучшений в сопоставление с образцом (нововведение в версии 9.0)

В версии C# 9.0 внесено множество улучшений в сопоставление с образцом, как показано в табл. 3.9.

В модифицированном методе

IfElsePatternMatchingUpdatedInCSharp9()

static void IfElsePatternMatchingUpdatedInCSharp9()

{

   Console.WriteLine("================ C# 9

            If Else Pattern Matching Improvements 

            ===============/n");

   object testItem1 = 123;

   Type t = typeof(string);

   char c = 'f';

   // Образцы типов

   if (t is Type)

   {

     Console.WriteLine($"{t} is a Type");

         // t является Type

   }

   // Относительные, конъюнктивные и дизъюнктивные образцы

   if (c is >= 'a' and <= 'z' or >= 'A' and <= 'Z')

   {

     Console.WriteLine($"{c} is a character");

         // с является символом

   };

   //Parenthesized patterns

   if (c is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z') or '.' or ',')

   {

     Console.WriteLine($"{c} is a character or separator");

         // c является символом или разделителем

   };

   //Negative patterns

   if (testItem1 is not string)

   {

     Console.WriteLine($"{testItem1} is not a string");

         // с не является строкой

   }

   if (testItem1 is not null)

   {

     Console.WriteLine($"{testItem1} is not null");

         // с не является null

   }

   Console.WriteLine();

}

Использование условной операции (обновление в версиях 7.2, 9.0)

Условная операция (

?:

if/else

условие ? первое_выражение : второе_выражение;

Условие представляет собой условную проверку (часть

if

if/else

?

true

else

if/else

static void ExecuteIfElseUsingConditionalOperator()

{

  string stringData = "My textual data";

  Console.WriteLine(stringData.Length > 0

   ? "string is greater than 0 characters"    // строка длиннее 0 символов

   : "string is not greater than 0 characters"); // строка не длиннее 0 символов

  Console.WriteLine();

}

С условной операцией связаны некоторые ограничения. Во-первых, типы конструкций

первое_выражение

второе_выражение

Во-вторых, условная операция может использоваться только в операторах присваивания. Следующий код приведет к выдаче на этапе компиляции сообщения об ошибке "Only assignment, call, increment, decrement, and new object expressions can be used as a statement" (В качестве оператора могут применяться только выражения присваивания, вызова, инкремента, декремента и создания объекта):

stringData.Length > 0

   ? Console.WriteLine("string is greater than 0 characters")

   : Console.WriteLine("string is not greater than 0 characters");

В версии C# 7.2 появилась возможность использования условной операции для возвращения ссылки на результат условия. В следующем примере задействованы две формы условной операции:

static void ConditionalRefExample()

{

  var smallArray = new int[] { 1, 2, 3, 4, 5 };

  var largeArray = new int[] { 10, 20, 30, 40, 50 };

  int index = 7;

  ref int refValue = ref ((index < 5)

   ? ref smallArray[index]

   : ref largeArray[index - 5]);

  refValue = 0;

  index = 2;

  ((index < 5)

   ? ref smallArray[index]

   : ref largeArray[index - 5]) = 100;

  Console.WriteLine(string.Join(" ", smallArray));

  Console.WriteLine(string.Join(" ", largeArray));

}

Если вы не знакомы с ключевым словом

ref

refValue

refValue

refValue

0

Использование логических операций

Для выполнения более сложных проверок оператор

if

else

На заметку! Операции

&&

||

false

&

|

Использование оператора switch

Еще одной простой конструкцией C# для реализации выбора является оператор

switch

switch

default

// Switch on a numerical value.

static void SwitchExample()

{

  Console.WriteLine("1 [C#], 2 [VB]");

  Console.Write("Please pick your language preference: ");

         // Выберите предпочитаемый язык:

  string langChoice = Console.ReadLine();

  int n = int.Parse(langChoice);

  switch (n)

  {

   case 1:

    Console.WriteLine("Good choice, C# is a fine language.");

          // Хороший выбор. C# - замечательный язык.

    break;

   case 2:

    Console.WriteLine("VB: OOP, multithreading, and more!");

          // VB: ООП, многопоточность и многое другое!

    break;

   default:

    Console.WriteLine("Well...good luck with that!");

          // Что ж... удачи с этим!

    break;

  }

}

На заметку! Язык C# требует, чтобы каждый блок

case

default

return

break

goto

Одна из замечательных особенностей оператора

switch

string

char

string

bool

int

long

enum

switch

string

static void SwitchOnStringExample()

{

  Console.WriteLine("C# or VB");

  Console.Write("Please pick your language preference: ");

  string langChoice = Console.ReadLine();

  switch (langChoice.ToUpper())

  {

   case "C#":

    Console.WriteLine("Good choice, C# is a fine language.");

    break;

   case "VB":

    Console.WriteLine("VB: OOP, multithreading and more!");

    break;

   default:

    Console.WriteLine("Well...good luck with that!");

    break;

  }

}

Оператор

switch

enum

SwitchOnEnumExample()

switch

System.DayOfWeek

switch

enum

static void SwitchOnEnumExample()

{

  Console.Write("Enter your favorite day of the week: ");

       // Введите любимый день недели:

  DayOfWeek favDay;

  try

  {

   favDay = (DayOfWeek) Enum.Parse(typeof(DayOfWeek), Console.ReadLine());

  }

  catch (Exception)

  {

   Console.WriteLine("Bad input!");

           // Недопустимое входное значение!

   return;

  }

  switch (favDay)

  {

  case DayOfWeek.Sunday:

    Console.WriteLine("Football!!");

           // Футбол! !

    break;

   case DayOfWeek.Monday:

    Console.WriteLine("Another day, another dollar");

            // Еще один день, еще один доллар.

    break;

   case DayOfWeek.Tuesday:

    Console.WriteLine("At least it is not Monday");

            // Во всяком случае, не понедельник.

    break;

   case DayOfWeek.Wednesday:

    Console.WriteLine("A fine day.");

            // Хороший денек.

    break;

   case DayOfWeek.Thursday:

    Console.WriteLine("Almost Friday...");

           // Почти пятница...

    break;

   case DayOfWeek.Friday:

    Console.WriteLine("Yes, Friday rules!");

           // Да, пятница рулит!

    break;

   case DayOfWeek.Saturday:

    Console.WriteLine("Great day indeed.");

            // Действительно великолепный день.

    break;

  }

  Console.WriteLine();

}

Сквозной проход от одного оператора

case

case

case

case DayOfWeek.Saturday:

case DayOfWeek.Sunday:

  Console.WriteLine("It’s the weekend!");

  break;

Помещение любого кода между операторами

case

В дополнение к операторам

return

break

switch

goto

case

case

goto

switch

static void SwitchWithGoto()

{

  var foo = 5;

  switch (foo)

  {

   case 1:

    // Делать что-то

    goto case 2;

   case 2:

    // Делать что-то другое

    break;

  case 3:

    // Еще одно действие

    goto default;

   default:

    // Стандартное действие

    break;

  }

} 

Выполнение сопоставления с образцом в операторах switch (нововведение в версии 7.0, обновление в версии 9.0)

До выхода версии C# 7 сопоставляющие выражения в операторах

switch

switch

case

case

case

return

break

goto

На заметку! Если вы новичок в объектно-ориентированном программировании, тогда материал этого раздела может слегка сбивать с толку. Все прояснится в главе 6, когда мы вернемся к новым средствам сопоставления с образцом C# 7 в контексте базовых и производных классов. Пока вполне достаточно понимать, что появился мощный новый способ написания операторов

switch

Добавьте еще один метод по имени

ExecutePatternMatchingSwitch()

static void ExecutePatternMatchingSwitch()

{

  Console.WriteLine("1 [Integer (5)], 2 [String (\"Hi\")], 3 [Decimal (2.5)]");

  Console.Write("Please choose an option: ");

  string userChoice = Console.ReadLine();

  object choice;

  // Стандартный оператор switch, в котором применяется

  // сопоставление с образцом с константами

  switch (userChoice)

  {

   case "1":

    choice = 5;

    break;

   case "2":

    choice = "Hi";

    break;

   case "3":

    choice = 2.5;

    break;

   default:

    choice = 5;

    break;

  }

  // Новый оператор switch, в котором применяется

  // сопоставление с образцом с типами

  switch (choice)

  {

   case int i:

    Console.WriteLine("Your choice is an integer.");

          // Выбрано целое число

    break;

   case string s:

    Console.WriteLine("Your choice is a string.");

          // Выбрана строка

    break;

   case decimal d:

    Console.WriteLine("Your choice is a decimal.");

          // Выбрано десятичное число

    break;

   default:

    Console.WriteLine("Your choice is something else");

          // Выбрано что-то другое

    break;

  }

  Console.WriteLine();

}

В первом операторе

switch

switch

object

int

string

decimal

case

case

default

// Новый оператор switch, в котором применяется

// сопоставление с образцом с типами

switch (choice)

{

  case int i:

   Console.WriteLine("Your choice is an integer {0}.",i);

   break;

  case string s:

   Console.WriteLine("Your choice is a string. {0}", s);

   break;

  case decimal d:

   Console.WriteLine("Your choice is a decimal. {0}", d);

   break;

  default:

   Console.WriteLine("Your choice is something else");

   break;

}

Кроме оценки типа сопоставляющего выражения к операторам

case

when

static void ExecutePatternMatchingSwitchWithWhen()

{

  Console.WriteLine("1 [C#], 2 [VB]");

  Console.Write("Please pick your language preference: ");

  object langChoice = Console.ReadLine();

  var choice = int.TryParse(langChoice.ToString(),

               out int c) ? c : langChoice;

  switch (choice)

  {

   case int i when i == 2:

   case string s when s.Equals("VB", StringComparison.OrdinalIgnoreCase):

    Console.WriteLine("VB: OOP, multithreading, and more!");

            // VB: ООП, многопоточность и многое другое!

    break;

   case int i when i == 1:

   case string s when s.Equals("C#", StringComparison.OrdinalIgnoreCase):

    Console.WriteLine("Good choice, C# is a fine language.");

            // Хороший выбор. C# - замечательный язык.

    break;

   default:

    Console.WriteLine("Well...good luck with that!");

            // Хорошо, удачи с этим!

    break;

  }

  Console.WriteLine();

}

Здесь к оператору

switch

case

case

case

case

switch (choice)

{

  case int i:

   //do something

   break;

  case int i when i == 0:

   //do something

   break;

  case int i when i == -1:

   // do something

   break;

}

В первоначальном выпуске C# 7 возникало небольшое затруднение при сопоставлении с образцом, когда в нем использовались обобщенные типы. В версии C# 7.1 проблема была устранена. Обобщенные типы рассматриваются в главе 10.

На заметку! Все продемонстрированные ранее улучшения сопоставления с образцом в C# 9.0 также можно применять в операторах

switch

Использование выражений switch (нововведение в версии 8.0)

В версии C# 8 появились выражения

switch

FromRainbowClassic()

static string FromRainbowClassic(string colorBand)

{

  switch (colorBand)

  {

   case "Red":

    return "#FF0000";

   case "Orange":

    return "#FF7F00";

   case "Yellow":

    return "#FFFF00";

   case "Green":

    return "#00FF00";

   case "Blue":

    return "#0000FF";

   case "Indigo":

    return "#4B0082";

   case "Violet":

    return "#9400D3";

   default:

    return "#FFFFFF";

  };

}

С помощью новых выражений

switch

static string FromRainbow(string colorBand)

{

  return colorBand switch

  {

   "Red" => "#FF0000",

   "Orange" => "#FF7F00",

   "Yellow" => "#FFFF00",

   "Green" => "#00FF00",

   "Blue" => "#0000FF",

   "Indigo" => "#4B0082",

   "Violet" => "#9400D3",

   _ => "#FFFFFF",

  };

}

В приведенном примере присутствует много непонятного, начиная с лямбда-операции (

=>

_

Перед тем, как завершить обсуждение темы выражений

switch

string

int

(string, int)

В показанном ниже примере два значения, передаваемые методу

RockPapeScissors()

switch

switch

//Switch expression with Tuples

static string RockPaperScissors(string first, string second)

{

  return (first, second) switch

  {

   ("rock", "paper") => "Paper wins.",

   ("rock", "scissors") => "Rock wins.",

   ("paper", "rock") => "Paper wins.",

   ("paper", "scissors") => "Scissors wins.",

   ("scissors", "rock") => "Rock wins.",

   ("scissors", "paper") => "Scissors wins.",

   (_, _) => "Tie.",

  };

}

Чтобы вызвать метод

RockPaperScissors()

Main()

Console.WriteLine(RockPaperScissors("paper","rock"));

Console.WriteLine(RockPaperScissors("scissors","rock"));

Мы еще вернемся к этому примеру в главе 4, где будут представлены кортежи.

Как вам уже наверняка известно, массив — это набор элементов данных, для доступа к которым применяется числовой индекс. Выражаясь более конкретно, массив представляет собой набор расположенных рядом элементов данных одного и того же типа (массив элементов

int

string

SportsCar

FunWithArrays

SimpleArrays()

Console.WriteLine("***** Fun with Arrays *****");

SimpleArrays();

Console.ReadLine();

static void SimpleArrays()

{