C# с нуля: от основ синтаксиса до принципов ООП

Введение в платформу .NET, переменные и типы данных

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

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

Что такое C# и платформа .NET?

Многие новички путают понятия C# (язык) и .NET (платформа). Давайте разберем это на простой аналогии.

Представьте, что вы — шеф-повар (программист).

C# — это язык, на котором написан рецепт (код). Он понятен вам, он строгий и структурированный.

.NET — это полностью оборудованная кухня, на которой вы готовите. Здесь есть плита, ножи, кастрюли, холодильник и даже помощники, которые моют посуду (сборщик мусора).

Вы не можете приготовить блюдо, имея только рецепт (C#) в чистом поле. Вам нужна кухня (.NET), которая предоставит инструменты для выполнения этого рецепта.

Как работает запуск программы?

Компьютер не понимает C# напрямую. Процессор понимает только машинный код (нули и единицы). Чтобы ваш красивый код превратился в работающую программу, происходит процесс компиляции.

!Схема превращения кода C# в машинные инструкции через промежуточный язык IL и среду CLR.

Исходный код (Source Code): То, что вы пишете на C#.

Компиляция: Специальная программа переводит ваш код в промежуточный язык — IL (Intermediate Language). Это универсальный формат для всех языков .NET.

CLR (Common Language Runtime): Это «сердце» .NET. Виртуальная машина, которая берет IL-код и прямо во время запуска программы переводит его в машинный код, понятный конкретному процессору. Этот процесс называется JIT-компиляция (Just-In-Time — точно в срок).

Благодаря этой архитектуре, программы на C# могут работать на Windows, macOS и Linux (с помощью .NET Core и современных версий .NET).

Структура простейшей программы

Традиционно изучение любого языка начинается с программы «Hello, World!». В C# она выглядит так:

Разберем каждую строку, чтобы не осталось магии:

using System; — мы подключаем библиотеку (набор инструментов) под названием System. Именно в ней лежит инструмент для работы с консолью.

namespace HelloWorldApp — Пространство имен. Это как фамилия для вашего кода. Оно помогает группировать классы и избегать конфликтов имен.

class Program — Класс. В C# весь код должен жить внутри классов. Пока воспринимайте класс как контейнер для вашей логики.

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

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

Переменные: Коробки для данных

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

> Переменная — это именованная область памяти, в которой хранится значение определенного типа.

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

!Визуализация переменных как коробок с именами и содержимым.

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

Синтаксис:

Пример:

Можно сделать это в одну строку (инициализация):

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

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

Хорошо: userAge, totalCount, fileName.

Плохо: UserAge (это стиль для классов), user_age (это стиль Python), x (непонятно, что это).

Типы данных

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

Рассмотрим основные (базовые) типы данных.

1. Целые числа (Integer)

Самый популярный тип для чисел без дробной части.

int: Стандартное целое число. Занимает 4 байта памяти. Диапазон примерно от -2 миллиардов до +2 миллиардов.

long: Большое целое число. Занимает 8 байт. Используется, если int не хватает.

2. Дробные числа (Floating Point)

Используются для чисел с запятой.

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

float: Менее точный, занимает меньше памяти. Требует суффикс f.

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

3. Текст и символы

char: Один единственный символ. Обязательно заключается в одинарные кавычки.

string: Строка текста. Заключается в двойные кавычки.

4. Логический тип (Boolean)

bool: Имеет всего два возможных значения: true (истина) или false (ложь). Используется для принятия решений.

Таблица основных типов данных

| Тип C# | Описание | Пример значения | | :--- | :--- | :--- | | int | Целое число | 42 | | double | Дробное число | 3.14 | | decimal| Денежный формат | 100.50m | | string | Текст | "Hello" | | char | Символ | 'X' | | bool | Логика | true |

Консольный ввод и вывод

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

Вывод данных

Мы уже видели Console.WriteLine(). Есть еще Console.Write().

WriteLine: пишет текст и переводит курсор на новую строку.

Write: пишет текст и оставляет курсор на той же строке.

Ввод данных

Для чтения текста, который ввел пользователь, используется команда Console.ReadLine(). Она всегда возвращает результат в виде типа string.

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

Склеивать строки через + неудобно. В современном C# используют интерполяцию. Ставим знак "Имя: {name}, Возраст: {age}"); csharp var number = 10; // Компилятор видит 10 и понимает: это int var text = "Hello"; // Компилятор видит кавычки и понимает: это string `

Важно: var — это не отсутствие типа! Переменная number всё равно будет строго int. Вы не сможете потом записать в неё текст. Использовать var стоит только тогда, когда тип очевиден.

Заключение

Сегодня мы заложили фундамент вашего обучения. Мы узнали:

Что C# работает поверх платформы .NET.

Программа начинается с метода Main.

Переменные — это именованные ячейки памяти со строгим типом.

Основные типы: int, double, string, bool.

В следующей статье мы научимся управлять ходом программы: заставим компьютер принимать решения с помощью условных операторов if и else`.

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

Логика программы: условные конструкции, циклы и массивы

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

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

Условные конструкции (как научить программу говорить «Нет»).

Циклы (как заставить программу работать, пока мы отдыхаем).

Массивы (как хранить вагоны данных, а не отдельные коробки).

---

Условные конструкции: Искусство выбора

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

!Блок-схема работы условного оператора if-else.

Оператор if и else

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

Код внутри фигурных скобок {} после if выполнится только в том случае, если условие в круглых скобках () истинно (true). Если условие ложно (false), выполнится код внутри блока else.

Операторы сравнения

Чтобы задать условие, нам часто нужно сравнивать значения. В C# используются следующие операторы:

* == — равно (не путать с = — присваиванием!) * != — не равно * > — больше * < — меньше * >= — больше или равно * <= — меньше или равно

Пример:

Логические операторы

Иногда нужно проверить сразу несколько условий. Здесь нам поможет булева алгебра. Рассмотрим формулу логического умножения:

Где — итоговый результат, — первое условие, — второе условие, а символ обозначает логическое И.

В C# это записывается так:

* && (Логическое И) — истина, только если оба условия истинны. * || (Логическое ИЛИ) — истина, если хотя бы одно условие истинно. * ! (Логическое НЕ) — меняет true на false и наоборот.

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

Если у вас много вариантов выбора (например, меню в игре), использовать кучу if неудобно. Элегантнее использовать switch:

Обратите внимание на break — он обязателен, чтобы выйти из конструкции после выполнения нужного блока.

---

Циклы: Автоматизация рутины

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

Цикл while (Пока)

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

Цикл состоит из трех частей, разделенных точкой с запятой:

Инициализация (int i = 0): Создаем счетчик, обычно называют i (от index).

Условие (i < 5): Цикл работает, пока это верно.

Итератор (i++): Что делать после каждого шага (увеличить i на 1).

!Визуализация жизненного цикла for: инициализация, проверка, действие, обновление счетчика.

---

Массивы: Поезд с данными

До сих пор мы хранили данные в отдельных переменных. Но что, если нам нужно сохранить оценки 30 учеников? Создавать score1, score2 ... score30 — это кошмар.

На помощь приходят массивы.

> Массив — это структура данных, хранящая набор значений одного типа под одним именем.

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

Создание массива

Доступ к элементам

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

Нумерация в массивах начинается с НУЛЯ!

Если в массиве 3 элемента, их индексы: 0, 1, 2.

Если вы попытаетесь обратиться к fruits[3], программа выдаст ошибку IndexOutOfRangeException, так как элемента с индексом 3 не существует (их всего три: 0, 1, 2).

Перебор массива (Цикл foreach)

Чтобы пройтись по всем элементам массива, можно использовать for, но есть более удобный способ — foreach (для каждого).

Заключение

Поздравляю! Вы освоили фундаментальные концепции программирования. Теперь вы можете:

Заставлять программу выбирать путь с помощью if и else.

Повторять действия с помощью циклов for и while.

Хранить наборы данных в массивах.

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

А пока — проверьте свои знания в тесте ниже!

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

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

В реальном мире не существует просто «переменных». Существуют объекты: конкретный автомобиль, конкретный клиент банка, конкретный кот. У каждого из них есть свои характеристики (цвет, имя, баланс) и свое поведение (ехать, внести деньги, мяукать).

Именно здесь на сцену выходит ООП — Объектно-Ориентированное Программирование. Это не просто набор новых команд, это совершенно иной способ мышления.

Классы и объекты: Чертеж и Результат

Два самых главных понятия в ООП — это Класс и Объект. Новички часто их путают, поэтому давайте разберем их на примере архитектуры.

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

Класс (Class) — это чертеж или схема. На бумаге вы описываете: «У робота должны быть две руки, лазер в глазах и серийный номер». Сам чертеж ничего не делает. Он просто описывает, каким может быть робот.

Объект (Object) — это конкретный робот, собранный на заводе по этому чертежу. Вы можете собрать тысячи роботов по одному чертежу. Один будет покрашен в красный, другой в синий, но конструктивно они одинаковы.

!Чертеж (Класс) описывает структуру, а роботы (Объекты) являются конкретными воплощениями этого чертежа.

В C# класс — это пользовательский тип данных. Вы сами придумываете его структуру.

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

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

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

Представьте, что кто-то написал такой код:

С точки зрения синтаксиса C# — это верно, ведь speed это int. Но с точки зрения логики — это бред. Скорость не может быть отрицательной. Если мы оставим поля public (публичными), любой программист сможет сломать логику нашего объекта, записав туда некорректные данные.

Здесь вступает в силу Инкапсуляция.

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

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

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

В C# есть специальные слова, регулирующие видимость:

* public (публичный) — доступно всем и отовсюду. * private (частный) — доступно только внутри самого класса. Из метода Main или другого класса эти данные не видны.

Правильный подход в ООП: Скрывай поля, открывай методы.

Давайте перепишем класс Car, защитив скорость.

Теперь никто не сможет установить скорость -100. Метод SetSpeed просто не позволит это сделать.

Свойства (Properties)

Писать методы Get... и Set... каждый раз утомительно. В C# придумали элегантное решение — Свойства. Свойство выглядит как поле, но работает как пара методов.

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

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

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

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

Конструктор всегда называется так же, как и класс, и не имеет типа возвращаемого значения (даже void).

Теперь мы не можем создать машину просто так. Мы обязаны указать модель и год сразу:

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

Иногда имена параметров совпадают с именами полей класса. Чтобы компилятор понял, где что, используют this. this — это ссылка на текущий объект.

Заключение

Сегодня мы сделали огромный шаг вперед. Мы перешли от написания скриптов к проектированию систем. Мы узнали:

Класс — это шаблон, Объект — это экземпляр шаблона.

Поля хранят состояние, Методы определяют поведение.

Инкапсуляция защищает данные с помощью private и свойств.

Конструкторы позволяют правильно инициализировать объекты в момент создания.

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

А теперь проверьте, как вы усвоили материал, выполнив задания ниже!

Глубокое погружение в ООП: наследование, полиморфизм и абстракция

Рад видеть вас в четвертой части курса «C# с нуля: от основ синтаксиса до принципов ООП». В прошлой статье мы познакомились с классами и объектами, научились скрывать данные с помощью инкапсуляции и создали свой первый класс Car.

Но ООП — это не просто создание одиночных объектов. Это построение иерархий и связей между ними. Сегодня мы разберем три мощнейших инструмента, которые превращают разрозненный код в стройную систему:

Наследование — как не писать один и тот же код дважды.

Полиморфизм — как работать с разными объектами одинаково.

Абстракция — как выделить главное и отбросить лишнее.

Наследование: Семейные узы кода

Представьте, что мы пишем игру. У нас есть персонажи: Warrior (Воин), Mage (Маг) и Archer (Лучник). У всех них есть общие черты: имя, уровень здоровья, скорость бега. И есть различия: воин бьет мечом, маг кидает фаерболы.

Без наследования нам пришлось бы копировать поля Name и Health в каждый класс. Это нарушает главный принцип программирования — DRY (Don't Repeat Yourself — Не повторяйся).

Наследование позволяет создать общий класс (родитель) и унаследовать от него другие классы (потомки).

!Схема наследования: общие свойства находятся в родительском классе, а уникальные — в дочерних.

Синтаксис наследования

В C# наследование обозначается двоеточием :. Создадим общий класс Unit.

Теперь класс Mage автоматически имеет доступ к Name, Health и методу Move(), хотя мы их внутри него не писали.

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

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

Полиморфизм: Один интерфейс, множество форм

Слово «Полиморфизм» греческого происхождения и означает «много форм». Это, пожалуй, самая сложная концепция для новичков, но и самая важная.

Суть полиморфизма: мы можем работать с объектами разных типов так, как будто это один и тот же тип, и при этом каждый объект будет вести себя по-своему.

Представьте пульт от телевизора. Кнопка «Вкл» работает одинаково для вас (вы нажимаете её), но телевизор Sony запускает одну прошивку, а Samsung — другую. Интерфейс один (кнопка), а реализация разная.

Виртуальные методы (virtual и override)

Чтобы полиморфизм заработал, нам нужны два ключевых слова:

virtual — в родительском классе. Означает: «Этот метод можно переписать в наследниках».

override — в дочернем классе. Означает: «Я переписываю этот метод по-своему».

Давайте рассмотрим классический пример с геометрическими фигурами. Нам нужно вычислить площадь разных фигур.

Вспомним математику. Площадь круга вычисляется по формуле:

Где — площадь круга, — математическая константа (примерно 3.14), а — радиус круга.

А площадь прямоугольника:

Где — площадь, — длина, — ширина.

Реализуем это в коде:

Магия полиморфизма в действии

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

Это и есть полиморфизм. Мы не проверяем через if, круг это или квадрат. Мы просто говорим: «Дай мне площадь», и каждый объект вычисляет её по своей формуле.

!Иллюстрация принципа полиморфизма: один вызов метода приводит к разным действиям в зависимости от объекта.

Абстракция: Только суть

Посмотрите на класс Figure в примере выше. Его метод GetArea возвращает 0. Это странно. Какая площадь у «просто фигуры»? Никакая. В реальности не существует «просто фигуры» или «просто животного». Всегда есть конкретика: круг, квадрат, тигр, воробей.

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

Абстрактные классы и методы

Если мы добавим слово abstract перед class, мы не сможем создать экземпляр этого класса через new.

Если мы добавим abstract перед методом, то у метода не будет тела (фигурных скобок). Мы просто говорим: «Наследники обязаны реализовать этот метод».

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

Теперь:

Figure f = new Figure(); — Ошибка! Нельзя создать абстрактную фигуру.

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

Итоги: Три кита ООП

Давайте соберем всё вместе. ООП держится на трех столпах:

Инкапсуляция (из прошлой статьи): Скрываем внутренности (private), даем доступ через методы или свойства (public). Защищаем объект от поломки.

Наследование: Создаем иерархию. Общее выносим в родительский класс, частное оставляем в наследниках. Экономим код.

Полиморфизм: Работаем с разными типами через единый интерфейс. Делаем код гибким и расширяемым.

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

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

А пока — закрепите материал на задачах!

Работа с интерфейсами, делегатами и обработка исключений

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

Например, как сделать так, чтобы класс «Робот» и класс «Собака» могли выполнять команду «Голос», если у них совершенно разные родители? Или как передать один метод внутрь другого метода в качестве параметра? И, наконец, что делать, если программа внезапно попытается поделить на ноль?

Сегодня мы закроем эти вопросы, изучив три важнейшие темы: Интерфейсы, Делегаты и Обработку исключений.

Интерфейсы: Контракт на поведение

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

Если наследование классов отвечает на вопрос «Кто это?» (это Животное, это Транспорт), то интерфейс отвечает на вопрос «Что это умеет делать?» (это умеет летать, это умеет сохраняться в файл).

> Интерфейс — это контракт. Он содержит только список методов и свойств, но не их реализацию. Если класс подписывает этот контракт (реализует интерфейс), он обязан выполнить все описанные в нем действия.

!Иллюстрация того, как разные объекты объединяются общим поведением через интерфейс.

Синтаксис интерфейсов

В C# принято называть интерфейсы с заглавной буквы I (от Interface). Это помогает мгновенно отличать их от классов.

Теперь применим этот интерфейс к разным классам:

Множественная реализация

Главная суперсила интерфейсов: в C# класс может наследовать только от одного родителя, но реализовывать сколько угодно интерфейсов.

Представьте смартфон. Это и IPhone (телефон), и ICamera (камера), и IMusicPlayer (плеер).

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

Делегаты: Метод как переменная

Эта тема часто пугает новичков, но давайте разберем её просто. Обычно мы передаем в методы данные: числа, строки, объекты. А что, если мы хотим передать в метод... другой метод?

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

> Делегат — это тип данных, который хранит ссылку на метод. Это «обертка» для функции.

Объявление и использование

Сначала мы объявляем сигнатуру делегата (какие методы он может хранить).

Теперь создадим методы и используем делегат:

Зачем это нужно?

Делегаты лежат в основе событий (Events) и LINQ (мощного инструмента работы с данными, который мы изучим позже). Они позволяют писать код, который не знает заранее, какую именно логику ему придется выполнять, доверяя это решение внешнему коду.

В современном C# часто используют уже готовые делегаты Action (для методов без возвращаемого значения) и Func (для методов с возвратом), чтобы не объявлять свои собственные типы delegate.

Обработка исключений: Когда всё идет не по плану

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

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

Конструкция try-catch

Мы окружаем опасный код «защитным куполом».

!Визуализация механизма перехвата ошибок, предотвращающего падение приложения.

Блок finally

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

Иерархия исключений

Все ошибки в C# — это классы, наследуемые от базового класса Exception. Вот некоторые популярные:

* IndexOutOfRangeException — попытка обратиться к несуществующему индексу массива. * NullReferenceException — попытка обратиться к объекту, который равен null (пустой). * FileNotFoundException — файл не найден.

Хорошим тоном считается ловить конкретные ошибки (как DivideByZeroException), а не просто общий Exception, чтобы точно знать, что пошло не так.

Заключение

Сегодня мы сделали наш код профессиональнее:

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

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

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

Эти темы — мостик к профессиональной разработке. В следующей статье мы погрузимся в мир Коллекций, узнаем, почему массивы — это прошлый век, и научимся работать со списками List и словарями Dictionary.

Выполните задания ниже, чтобы закрепить материал!