Основы программирования на C#: Практический курс

Введение в C#: Настройка среды, переменные и типы данных

Добро пожаловать на курс «Основы программирования на C#: Практический курс». Это первая статья, с которой начнется ваше погружение в один из самых мощных и востребованных языков программирования в мире. C# (произносится как «си-шарп») — это универсальный язык, разработанный компанией Microsoft, который позволяет создавать всё: от простых консольных утилит до сложных веб-сервисов, мобильных приложений и даже видеоигр на движке Unity.

В этой статье мы пройдем путь от установки необходимых инструментов до написания вашей первой программы, которая умеет хранить и обрабатывать данные.

Зачем учить C#?

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

* Строгая типизация: C# не позволяет совершать многие глупые ошибки, проверяя код еще до его запуска. * Кроссплатформенность: Благодаря платформе .NET, ваш код может работать на Windows, macOS и Linux. * Огромное сообщество: Если у вас возникнет вопрос, скорее всего, кто-то уже задал его на форуме и получил ответ.

Настройка рабочей среды

Программисту нужен инструмент. Для C# «золотым стандартом» является Visual Studio (не путать с Visual Studio Code, хотя и он подходит). Для начала обучения мы рекомендуем использовать Visual Studio Community — это бесплатная, но полнофункциональная версия среды разработки (IDE).

Установка Visual Studio

Скачайте установщик с официального сайта Microsoft.

Запустите его. Вам будет предложено выбрать «рабочие нагрузки» (workloads).

Обязательно поставьте галочку напротив пункта «Разработка классических приложений .NET» (или .NET Desktop Development).

Нажмите «Установить».

!Выбор необходимой рабочей нагрузки при установке Visual Studio

После установки запустите Visual Studio и выберите «Создание нового проекта». В поиске шаблонов найдите «Консольное приложение» (Console App). Это самый простой тип программ, который идеально подходит для обучения. Дайте проекту имя, например, MyFirstApp, и нажмите «Создать».

Анатомия программы на C#

Когда проект создастся, вы увидите код, который Visual Studio сгенерировала автоматически. Давайте разберем его построчно. Это ваш первый шаг к пониманию структуры языка.

Разберем, что здесь происходит:

using System; — это подключение пространства имен. Представьте, что System — это огромная библиотека с книгами. Подключая её, мы говорим программе: «Я буду использовать инструменты из этой библиотеки».

namespace MyFirstApp — это пространство имен вашего приложения. Это как фамилия для вашего кода, чтобы он не путался с чужим кодом.

class Program — весь код в C# живет внутри классов. Класс — это контейнер для данных и методов.

static void Main(string[] args) — это точка входа. Самая важная часть. Когда вы запускаете программу, компьютер ищет именно метод Main и начинает выполнение команд внутри него.

Console.WriteLine("Hello, World!"); — это команда, которая выводит текст на экран. Обратите внимание на точку с запятой ; в конце. В C# она обязательна в конце каждой команды, как точка в конце предложения.

!Иерархическая структура программы на C#

Переменные: Хранение данных

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

> Переменная — это именованная область памяти, в которую можно положить значение, чтобы использовать его позже.

Представьте переменную как коробку. У коробки есть:

Тип (какого размера и формы эта коробка, что в нее можно положить).

Имя (надпись на коробке, чтобы мы могли её найти).

Значение (то, что лежит внутри).

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

Объявление и инициализация

Чтобы создать переменную в C#, нужно сначала указать её тип, затем имя, и (по желанию) сразу присвоить значение. Синтаксис выглядит так:

Пример:

Здесь мы создали коробку типа int (целое число), назвали её age и положили туда число 25. Знак = в программировании означает не равенство, а присваивание. Мы берем то, что справа, и кладем в то, что слева.

Основные типы данных

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

Вот основные типы данных, которые вам понадобятся на старте:

| Тип C# | Описание | Пример значения | Размер в памяти | | :--- | :--- | :--- | :--- | | int | Целые числа (от -2 млрд до 2 млрд) | 42, -10, 0 | 4 байта | | long | Очень большие целые числа | 9000000000 | 8 байт | | double | Дробные числа (с плавающей точкой) | 3.14, -0.01 | 8 байт | | string | Строка (текст) | "Привет", "C#" | Зависит от длины | | char | Один символ | 'A', '7', '!' | 2 байта | | bool | Логический тип (истина или ложь) | true, false | 1 байт |

Особенности работы с типами

Строки (string) всегда пишутся в двойных кавычках: "Текст".

Символы (char) всегда пишутся в одинарных кавычках: 'A'.

Дробные числа (double) используют точку как разделитель: 5.5.

Пример кода с разными типами:

Ввод и вывод данных

Мы уже видели команду Console.WriteLine(). Она выводит текст и переводит курсор на новую строку. Есть еще команда Console.Write(), которая делает то же самое, но оставляет курсор на той же строке.

Но как получить данные от пользователя? Для этого используется команда Console.ReadLine().

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

Практика: Программа-анкета

Важный нюанс про числа и строки

Обратите внимание: Console.ReadLine() всегда возвращает текст (string). Даже если пользователь ввел цифры "25", для программы это просто текст, набор символов. Вы не можете прибавить к тексту число математически.

Если вы хотите выполнять математические операции с введенным возрастом (например, узнать год рождения), вам нужно преобразовать строку в число. Для этого используется метод Convert.ToInt32() или int.Parse().

Пример:

Правила именования переменных

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

Используйте camelCase: первая буква маленькая, каждое следующее слово с большой буквы.

Хорошо:* userName, playerScore, totalAmount. Плохо:* Username, player_score, TOTAL.

Имя должно быть осмысленным. Избегайте имен вроде a, b, x (если это не координаты).

C# чувствителен к регистру. age, Age и AGE — это три разные переменные.

Заключение

Сегодня вы сделали огромный шаг. Вы настроили среду, узнали структуру программы, научились создавать переменные разных типов и взаимодействовать с пользователем. Это фундамент, на котором строится всё программирование.

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

Управляющие конструкции: Условные операторы и циклы для управления потоком

Добро пожаловать во вторую статью курса «Основы программирования на C#: Практический курс». В прошлый раз мы научились создавать «коробки» для данных — переменные. Но пока наши программы похожи на поезд, который едет по прямым рельсам: от первой строчки кода до последней, без остановок и поворотов.

В реальной жизни (и в программировании) нам постоянно приходится принимать решения. «Если на улице дождь, я возьму зонт, иначе пойду в футболке». Или повторять действия: «Пока не помою всю посуду, я не уйду с кухни».

Сегодня мы научим нашу программу думать и выбирать путь. Мы изучим управляющие конструкции.

Арифметика и логика: Основа принятия решений

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

Базовая арифметика

Вы уже знаете, что int и double хранят числа. С ними можно производить стандартные операции:

* + (сложение) * - (вычитание) (умножение) * / (деление)

Однако в программировании есть еще одна крайне важная операция — остаток от деления (оператор %).

Представьте, что мы делим 10 яблок на 3 человек. Каждому достанется по 3 яблока, и 1 останется лишним. В математике это можно записать так:

где — делимое, — делитель, а — остаток от деления.

В C# это выглядит так:

Это часто используется, например, чтобы узнать, четное число или нет (остаток от деления на 2 равен 0).

Логические операции

Чтобы принять решение, программе нужно ответить на вопрос «Да» или «Нет». В C# за это отвечает тип данных bool, который может принимать только два значения: true (истина) и false (ложь).

Мы получаем эти значения с помощью операторов сравнения:

* == (равно). Внимание! Одно = — это присваивание, два == — это сравнение. * != (не равно). * > (больше) и < (меньше). * >= (больше или равно) и <= (меньше или равно).

Пример:

Иногда нужно проверить несколько условий сразу. Для этого есть логические операторы:

И (&&): Истина, только если оба условия верны.

ИЛИ (||): Истина, если хотя бы одно условие верно.

НЕ (!): Инверсия (меняет true на false и наоборот).

Условный оператор if-else

Самая популярная конструкция в программировании — это if (если). Она позволяет выполнить блок кода, только если условие истинно.

!Блок-схема работы условного оператора: программа выбирает путь в зависимости от истинности условия

Синтаксис

Давайте напишем программу, которая проверяет, можно ли пользователю играть в игру (рейтинг 18+).

Каскад условий (else if)

Что если вариантов больше двух? Например, выбор персонажа по классу. Мы используем else if.

Конструкция switch

Когда у вас есть одна переменная, которую нужно сравнить со множеством конкретных значений (как в примере выше), цепочка if-else if может выглядеть громоздко. Элегантнее использовать switch.

Обратите внимание на ключевое слово break. Оно обязательно в C# для выхода из switch. Если его забыть, компилятор выдаст ошибку. Блок default срабатывает, если ни один case не подошел.

Циклы: Повторение действий

Компьютеры превосходны в выполнении рутинных задач. Если вам нужно вывести фразу «Привет» 100 раз, глупо писать Console.WriteLine 100 раз. Для этого существуют циклы.

Цикл while (Пока)

Это самый простой цикл. Он работает до тех пор, пока условие истинно.

Важно: Если вы забудете изменить переменную внутри цикла (например, забудете apples--), условие всегда будет истинным, и программа зависнет в бесконечном цикле.

Цикл do-while

Похож на while, но с одним отличием: проверка условия происходит после выполнения тела цикла. Это гарантирует, что код внутри выполнится хотя бы один раз.

Цикл for (Для)

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

Инициализация: Создаем счетчик.

Условие: Проверяем, нужно ли продолжать.

Итерация: Изменяем счетчик.

!Структура цикла for: инициализация, условие и шаг итерации

Разберем int i = 0; i < 5; i++: * Мы создали переменную i равную 0. * Перед каждым шагом проверяем, меньше ли i пяти. * После каждого шага увеличиваем i на 1 (i++ — это то же самое, что i = i + 1).

Управление внутри циклов: break и continue

Иногда нужно вмешаться в работу цикла: * break — немедленно прерывает цикл и выходит из него. continue — пропускает оставшуюся часть текущей* итерации и переходит к следующей.

Пример: Вывод только нечетных чисел и остановка на 7.

Практика: Игра «Угадай число»

Давайте объединим всё изученное (переменные, ввод/вывод, преобразование типов, условия и циклы) в одной программе. Мы напишем игру, где компьютер загадывает число, а пользователь пытается его угадать.

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

Разбор логики игры

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

Цикл while идеально подходит здесь, так как мы не знаем заранее, сколько попыток понадобится игроку.

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

Конструкция if-else if-else помогает направить игрока к правильному ответу.

Математическое отступление: Сумма чисел

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

С помощью цикла это делается так:

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

где — сумма первых чисел, а — последнее число последовательности.

Если , то:

Код с формулой будет работать мгновенно даже для миллиарда, в то время как циклу придется сделать миллиард шагов. Это пример того, как правильный алгоритм важнее простого написания кода.

Заключение

Сегодня вы получили в свои руки мощные инструменты. Условные операторы if и switch позволяют вашей программе принимать решения, а циклы while и for — выполнять огромные объемы работы за доли секунды.

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

Методы и массивы: Структурирование кода и работа с коллекциями

Добро пожаловать на третью лекцию курса «Основы программирования на C#: Практический курс». В предыдущих статьях мы научились создавать переменные для хранения одиночных данных и управлять потоком выполнения программы с помощью циклов и условий.

Однако, по мере того как ваши программы будут становиться сложнее, вы столкнетесь с двумя проблемами:

Данных становится слишком много, и создавать для каждого значения отдельную переменную (student1, student2, student3...) неудобно.

Код начинает повторяться, превращаясь в «спагетти», в котором трудно разобраться.

Сегодня мы решим эти проблемы с помощью двух фундаментальных концепций: массивов и методов.

Массивы: Хранение множества данных

Представьте, что вы пишете программу для учета оценок в классе из 30 учеников. Создавать 30 переменных типа int — это утомительно и неэффективно. А если учеников станет 100? Здесь на помощь приходят массивы.

> Массив — это структура данных, которая хранит фиксированное количество элементов одного типа, расположенных в памяти последовательно.

Визуализация массива

Лучший способ понять массив — представить его как ряд пронумерованных почтовых ящиков или камер хранения.

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

У массива есть три ключевые характеристики:

Тип данных: Все элементы в массиве должны быть одного типа (например, только int или только string).

Имя: Одно общее имя для всего набора данных.

Индекс: Уникальный номер, по которому мы получаем доступ к конкретной «ячейке».

Важно: В C# (как и в большинстве языков) нумерация индексов начинается с нуля.

Создание и использование массивов

Чтобы объявить массив, мы используем квадратные скобки [] после типа данных.

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

Математика индексов

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

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

Где — это индекс элемента, а — общая длина массива (свойство .Length).

Перебор массива с помощью циклов

Массивы и циклы созданы друг для друга. Чтобы обработать все элементы массива, мы используем цикл for.

Существует также специальный цикл foreach, который упрощает чтение данных, если вам не нужен индекс:

foreach работает медленнее и не позволяет менять элементы массива, но он делает код чище и безопаснее при чтении данных.

Методы: Принцип DRY

В программировании есть золотое правило: DRY (Don't Repeat Yourself) — «Не повторяйся». Если вы копируете и вставляете один и тот же кусок кода в разные места программы — вы делаете что-то не так.

Для группировки кода в переиспользуемые блоки используются методы (в других языках их часто называют функциями).

> Метод — это именованный блок кода, который выполняет определенную задачу и может возвращать результат.

Мы уже использовали метод Main (точка входа) и Console.WriteLine. Теперь научимся писать свои.

Анатомия метода

Рассмотрим структуру метода на примере:

static: Модификатор (пока просто запомните, что он нужен для вызова из Main).

int (Тип возвращаемого значения): Указывает, какой тип данных метод вернет после работы. Если метод ничего не возвращает, используется ключевое слово void.

Sum (Имя метода): Глагол или действие, описывающее суть метода.

(int a, int b) (Параметры): Переменные, которые метод принимает на вход.

return: Команда, которая завершает метод и передает результат наружу.

!Схематическое изображение работы метода: входные данные, обработка, результат

Вызов метода

Чтобы заставить метод работать, его нужно вызвать в другом месте программы, передав ему аргументы.

Область видимости (Scope)

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

Практика: Объединяем массивы и методы

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

Математическая модель

Прежде чем писать код, вспомним формулу среднего арифметического:

Где: * — среднее значение (результат). * — знак суммы (сигма), означающий, что нужно сложить все элементы. * — элемент массива под индексом . * — количество элементов в массиве (длина массива). * и — границы суммирования (от первого до последнего индекса).

Реализация в коде

Обратите внимание: мы использовали тип double для суммы и результата, чтобы при делении получить дробное число (например, 4.33), а не целое (4).

Многомерные массивы (Краткий обзор)

Иногда данных в одну строку недостаточно. Например, для создания поля для игры «Морской бой» или таблицы Excel нужна сетка. В C# это называется двумерным массивом.

Мы не будем углубляться в них сейчас, но знайте, что массивы могут иметь 2, 3 и более измерений.

Заключение

Сегодня вы сделали огромный шаг к написанию профессионального кода.

Массивы позволили вам работать с наборами данных как с единым целым.

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

В следующей статье мы перейдем к одной из самых важных тем в современном программировании — Объектно-Ориентированному Программированию (ООП). Мы узнаем, как создавать свои собственные типы данных, описывающие объекты реального мира.

Основы ООП: Классы, объекты и принципы инкапсуляции

Добро пожаловать на четвертую статью курса «Основы программирования на C#: Практический курс».

До этого момента мы писали код в так называемом процедурном стиле. Мы создавали переменные, массивы и методы, которые лежали в одном файле (обычно в Program.cs) и выполнялись последовательно. Это отлично работает для простых задач, вроде калькулятора или угадывания чисел.

Но представьте, что мы создаем сложную RPG-игру. У нас есть Герой, Монстры, Торговцы, Инвентарь. У каждого из них есть свои характеристики (здоровье, сила, золото) и свои действия (атаковать, торговать, лечиться). Если мы будем хранить всё это в разрозненных массивах (heroHealth, monsterNames, itemPrices), наш код превратится в хаос, который невозможно поддерживать.

Сегодня мы переходим к Объектно-Ориентированному Программированию (ООП) — парадигме, которая позволяет моделировать в коде объекты реального мира.

Что такое ООП?

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

Данные (состояние) — переменные, описывающие объект.

Методы (поведение) — функции, описывающие, что объект умеет делать.

Класс и Объект: В чем разница?

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

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

!Слева — класс (чертеж), справа — объекты (конкретные дома), созданные по этому чертежу.

Пример из жизни: Класс:* «Автомобиль» (абстрактное понятие: у него есть колеса, двигатель, цвет). Объект:* Конкретный красный Ford Mustang вашего соседа.

Создание первого класса

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

Давайте создадим класс для робота.

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

Обратите внимание на ключевое слово new. Именно оно выделяет память под новый объект. Без него переменная bot1 была бы пустой ссылкой.

Инкапсуляция: Защита данных

Посмотрите на код выше. Мы использовали слово public перед переменными name и batteryLevel. Это означает, что кто угодно снаружи может изменить эти данные.

Что, если мы напишем так?

С точки зрения синтаксиса C# — это корректный код (int может быть отрицательным). С точки зрения логики программы — это абсурд. Батарея не может быть отрицательной.

Здесь вступает в игру первый принцип ООП — Инкапсуляция.

> Инкапсуляция — это механизм, который объединяет данные и код, манипулирующий ими, а также защищает данные от внешнего вмешательства и неправильного использования.

Модификаторы доступа

В C# мы управляем доступом с помощью ключевых слов: * public (публичный): доступно всем и отовсюду. private (приватный): доступно только* внутри этого же класса.

Хорошим тоном считается делать все поля (fields) приватными, а доступ к ним давать через специальные методы или свойства.

Свойства (Properties)

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

Перепишем наш класс Robot правильно:

Теперь, если кто-то попытается написать bot1.BatteryLevel = -500;, сработает наша проверка в блоке set, и некорректное значение не попадет в память объекта.

!Визуальная метафора инкапсуляции: данные защищены внутри объекта, доступ только через контролируемые свойства.

Автоматические свойства

Если вам не нужна особая логика проверки (например, для имени робота), C# позволяет писать сокращенно:

Компилятор сам создаст скрытое приватное поле за кулисами. Это стандарт де-факто в современном C#.

Конструкторы: Рождение объекта

Когда мы писали new Robot(), мы вызывали особый метод — конструктор. Его задача — подготовить объект к работе сразу после создания.

Сейчас нам приходится создавать робота, а потом отдельно задавать ему имя. Можно забыть это сделать, и робот останется безымянным. Лучше требовать имя сразу при создании.

Использование в Main:

Заключение

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

Мы изучили:

Классы и объекты: Класс — это чертеж, объект — это дом.

Инкапсуляцию: Данные нужно прятать (private) и защищать с помощью свойств.

Конструкторы: Способ гарантировать правильную инициализацию объекта.

В следующей статье мы разберем, как объекты могут наследовать свойства друг друга (Наследование) и как один метод может вести себя по-разному (Полиморфизм).

Итоговая работа: Написание и отладка консольного приложения для зачета

Поздравляю! Вы добрались до финала курса «Основы программирования на C#: Практический курс». Мы прошли долгий путь: от первой строчки Hello, World! и переменных до сложных циклов, массивов и создания собственных классов. Теперь у вас есть все необходимые инструменты, чтобы создать полноценное приложение.

В этой итоговой статье мы не будем изучать новый синтаксис. Вместо этого мы займемся тем, чем программисты занимаются 90% своего времени: проектированием архитектуры, написанием сложной логики и, самое главное, отладкой (debugging).

Наша цель сегодня — написать консольную игру «Битва Героев» и научиться находить в ней ошибки с помощью профессиональных инструментов Visual Studio.

Техническое задание: Игра «Битва Героев»

Прежде чем писать код, нужно понять, что мы строим. Хороший программист сначала думает, потом пишет.

Суть игры:

В игре участвуют два бойца.

У каждого бойца есть имя, здоровье, урон и броня.

Бой происходит пошагово (по очереди).

Каждый ход боец атакует противника. Урон рассчитывается с некоторой долей случайности и уменьшается за счет брони цели.

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

Победитель объявляется в консоли.

Этап 1: Проектирование класса Героя

Вспомним принципы ООП. Нам нужен чертеж для создания бойцов. Назовем этот класс Fighter.

Какие данные (свойства) ему нужны? * Name (строка) — имя бойца. * Health (целое число) — текущее здоровье. * Damage (целое число) — базовая сила удара. * Armor (целое число) — показатель защиты.

Какие действия (методы) он должен совершать? * Attack — атаковать другого бойца. * TakeDamage — получить урон и уменьшить здоровье.

!Схема структуры класса Fighter, показывающая его свойства и методы

Реализация класса

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

Этап 2: Математика боя

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

Формула снижения урона (как в Warcraft или League of Legends):

Где: * — множитель урона (число от 0 до 1). * — константа баланса. * — количество брони защищающегося.

Тогда итоговый урон рассчитывается так:

Где: * — итоговый урон, который вычитается из здоровья. * — «сырой» входящий урон до обработки броней. * — множитель, полученный из предыдущей формулы.

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

Этап 3: Игровой цикл и логика

Теперь перейдем в Program.cs и напишем метод Main. Нам нужно создать двух бойцов и заставить их сражаться, пока один не упадет.

Этап 4: Искусство отладки (Debugging)

Представьте, что вы запустили игру, и бой заканчивается мгновенно, или здоровье не отнимается, или программа «вылетает». Как найти ошибку? Читать код глазами полезно, но неэффективно.

Visual Studio предоставляет мощнейший инструмент — Отладчик (Debugger).

Точки останова (Breakpoints)

Это сигнал программе: «Остановись на этой строке, я хочу посмотреть, что происходит».

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

!Установка точки останова (Breakpoint) в Visual Studio

Пошаговое выполнение

Когда программа остановится на точке (строка станет желтой), вы можете управлять временем:

F10 (Step Over / Шаг с обходом): Выполнить текущую строку и перейти к следующей. Если в строке есть вызов метода, отладчик выполнит его мгновенно, не заходя внутрь.

F11 (Step Into / Шаг с заходом): Если в строке есть вызов метода, отладчик «зайдет» внутрь этого метода, чтобы вы могли проверить его работу построчно.

F5 (Continue / Продолжить): Снять паузу и продолжить выполнение программы до следующей точки останова.

Просмотр переменных

В режиме отладки вы можете навести курсор мыши на любую переменную (например, на hero1.Health), и всплывающее окно покажет её текущее значение.

Также внизу экрана есть вкладки: * Locals: Показывает все переменные, доступные в текущем методе. * Watch: Вы можете вручную добавить туда любую переменную или выражение (например, hero1.Health - 10), чтобы следить за изменениями.

> «Отладка — это как быть детективом в криминальном фильме, где ты одновременно и детектив, и убийца».

Практическое задание: Найди ошибку

Попробуйте специально допустить ошибку в коде. Например, в методе TakeDamage напишите Health += reducedDamage; (лечение вместо урона).

Запустите программу.

Вы увидите, что бой идет бесконечно, а здоровье растет.

Поставьте точку останова (F9) внутри метода Attack.

Запустите отладку (F5).

Используйте F11, чтобы зайти в метод TakeDamage.

Наведите курсор на Health до и после выполнения ошибочной строки.

Вы увидите, как значение увеличивается. Ошибка найдена!

Полный код проекта

Ниже приведен полный код файла Program.cs (если вы пишете все в одном файле). Скопируйте его, запустите и попробуйте изменить параметры бойцов.

Заключение курса

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

Что мы изучили за этот курс:

Переменные и типы: Как хранить данные.

Условия и циклы: Как управлять логикой.

Массивы и методы: Как структурировать код.

ООП: Как моделировать реальный мир.

Отладка: Как исправлять ошибки.

Дальнейший путь зависит от вас. Вы можете углубиться в создание игр на Unity, веб-разработку на ASP.NET Core или создание мобильных приложений на MAUI. Фундамент у вас уже есть. Удачи в коде!