Несерьезный шарпист

Наследование, абстрактные классы и интерфейсы

2024-07-05T09:56:48.656Z

Парадигма наследования

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

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

Базовый класс (родительский) - класс, от которого поля и методы наследуются другим классом.
Производный класс (дочерний) — класс, унаследованный от базового класса.

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

Пример наследования класса Car от базового класса Vehicle

public class Vehicle
{
    public int MaxSpeed { get; set; }
    public int YearOfIssue { get; set; }
     
    public void Move() 
    {
        Console.WriteLine("I'm moving")
    }
}

public class Car : Vehicle
{
    public int CountWeels { get; set; }
    public int HpEngine { get; set; }
}

public class Program
{
    public static void Main()
    {
        var bmw = new Car 
        {
            MaxSpeed = 500,
            HpEngine = 1000,
            YearOfIssue = 1,
            CountWeels = 4,
        };
        
        bmw.Move();
    }
}

Таким образом, используя наследование нам не нужно создавать один и тот же код в разных классах, мы используем уже написанное и не нарушаем принцип разработки ПО DRY (dont repeat yourself).

Многоуровневая цепочка наследования

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

Мы можем добавить в наш пример класс грузовика Truck, который бы наследовался от Car и имел некую грузоподъемность прицепа, это будет являться многоуровневым наследованием.

public class Vehicle
{
    public int MaxSpeed { get; set; }
    public int YearOfIssue { get; set; }
     
    public void Move() 
    {
        Console.WriteLine("I'm moving")
    }
}

public class Car : Vehicle
{
    public int CountWeels { get; set; }
    public int HpEngine { get; set; }
}

public class Truck : Car
{
    public int TrailerCapacity { get; set; }
}

Также стоит помнить, что все классы неявно наследуются от базового класса Object, от него все классы и наследуют базовые методы ToString(), GetHashCode(), GetType(), Equals().

Доступ к членам базового класса

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

Если кратко, то класс наследник может иметь доступ только к членам базового класса, которые определены с модификаторами public, protected, internal (доступ в любом месте кода той же сборки), private protected (доступ в базовом классе и классах наследниках в той же сборке), protected internal (доступ в той же сборке и в классах наследниках любой сборки). К членам со спецификатором private можно получить доступ только в том же классе, обратиться к ним из классов наследников не получится.

public class Robot
{
    private int beerCount;

    public void Drink() 
    {
        Console.WriteLine($"bimbimbambam, I can have a drink {beerCount} beer bottles");
    }
}

public class Bender : Robot
{
    public void SomeMethod()
    {
        // Доступ к private полю beerCount из производного класса запрещен
        // beerCount = 10; Error
        Drink();  // Вызов Drink из производного класса
    }
}

Вызов конструктора базового класса

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

В примере выше все ок, и при создании объекта класса Bender будет вызван его конструктор по умолчанию и конструктор по умолчанию базового класса Robot (при чем в порядке наследования, начиная от базового). Но давайте смоделируем ситуацию, когда у Robot нет конструктора по умолчанию.

public class Robot
{
    private int intelligenceLevel;
    
    public Robot(int intelligenceLevel)
    {
        this.intelligenceLevel = intelligenceLevel;
    }
}

public class Bender : Robot
{
    private int beerCount;
    
    public Bender(int intelligenceLevel, int beerCount)
        : base(intelligenceLevel)
    {
        this.beerCount = beerCount;
    }

    public void Drink() 
    {
        Console.WriteLine($"bimbimbambam, I can have a drink {beerCount} beer bottles");
    }
}

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

Порядок вызова конструкторов и финализаторов в цепочке наследования

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

public class Robot
{
    public Robot()
    {
        Console.WriteLine("Robot created");
    }
    
    ~Robot()
    {
        Console.WriteLine("Robot finalized");
    }
}

public class Bender : Robot
{
    public Bender()
    {
        Console.WriteLine("bimbimbambam, Bender created");
    }
    
    ~Bender()
    {
        Console.WriteLine("bambambimbim, Bender finalized");
    }
}

public class Program
{
    public static void Temp()
    {
        var bender = new Bender();
    }

    public static void Main()
    {

        Temp();
        GC.Collect();
    }
}

// Вывод:
// Robot created
// bimbimbambam, Bender created
// bambambimbim, Bender finalized
// Robot finalized

Запрет наследования

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

Для этих целей используется ключевое слово selead

// от класса робот наследование запрещено
public sealed class Robot
{
}

// ошибка компиляции 
public class Bender : Robot
{
}

Переопределение методов

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

Метод, который мы хотим сделать доступным для переопределения, в базовом классе помечаем ключевым словом virtual. А чтобы переопределить метод в классе наследнике, используем ключевое слово override. Андерстенд, ок?!

public class Robot
{
    public virtual void Drink()
    {
        Console.WriteLine("I'm an intelligent robot alcoholic");
    }
}

public class Bender : Robot
{
    private int beerCount;
    
    public Bender(int beerCount)
    {
        this.beerCount = beerCount;
    }

    public override void Drink() 
    {
        base.Drink(); // вызов метода базового класса
        Console.WriteLine($"bimbimbambam, I can have a drink {beerCount} beer bottles");
    }
}

public class Program
{
    public static void Main()
    {
        var bender = new Bender(10);
        bender.Drink();
    }
}

// Вывод:
// I'm an intelligent robot alcoholic
// bimbimbambam, I can have a drink 10 beer bottles

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

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

public class Robot
{
    public virtual void Drink()
    {
        Console.WriteLine("I'm an intelligent robot alcoholic");
    }
}

public class Bender : Robot
{
    private int beerCount;
    
    public Bender(int beerCount)
    {
        this.beerCount = beerCount;
    }

    public override sealed void Drink() 
    {
        base.Drink(); // вызов метода базового класса
        Console.WriteLine($"bimbimbambam, I can have a drink {beerCount} beer bottles");
    }
}

public class SuperBender : Bender
{
    public SuperBender(int beerCount)
        : base(beerCount)
    {
    }
    
    // Ошибка компиляции,переопределять этот метод нельзя
    public override void Drink()
    {
        Console.WriteLine("wabulabudabda");
    }
}

Абстрактные классы

Как уже говорилось ранее класс представляет собой некоторый план для построения определенных объектов (чертеж). Но мы можем выделить в абстракцию некоторые общие черты, свойственные нескольким категориям объектов. Например Троллейбусы и Машины имеют какую-то грузоподъемность, какой-то тип топлива, могут перемещаться, соответственно, можно выделить некоторую абстракцию Транспортное средство, которое само по себе ничего не представляет.

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

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

public abstract class Vehicle
{
    public int Carrying { get; set; }
    
    public abstract void Move();
}

Любой класс, который унаследован от абстрактного класса, должен реализовывать все его абстрактные члены.

public class Car : Vehicle
{
    public override void Move()
    {
        Console.WriteLine("Машина едет со скоростью n");
    }
}

public class Trolleybus
{
    public override void Move()
    {
        Console.WriteLine("Тролейбус едет со скоростью x");
    }
}

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

Интерфейсы

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

public interface IMovable
{
    void Move();
}

public class Car : IMovable
{
    public override void Move()
    {
        Console.WriteLine("Машина едет");
    }
}

public class Ship : IMovable
{
    public override void Move()
    {
        Console.WriteLine("Корабль идет");
    }
}

Начиная с C# 8, интерфейсы поддерживают реализацию методов по умолчанию, которая может переопределяться или не переопределяться в классе реализации. Помимо этого с C# 8 для интерфейсов стало доступно определение у членов спецификатора доступа (по умолчанию - public, в отличии от классов), константы, статические поля, статические методы и свойства, статические ивенты и индексаторы, статические конструкторы.

public interface IMovable
{
    void Move()
    {
        Console.WriteLine("Я могу перемещаться");
    }
}

public class Car : IMovable
{
    public override void Move()
    {
        Console.WriteLine("Машина едет");
    }
}

public class Bender : IMovable
{
}

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

Но важно знать, что интерфейс в отличии от абстрактного класса не позволяет полноценно переиспользовать уже написанный код. То есть если мы создадим объект класса Bender из примера выше и попытаемся вызвать метод Move, то получим ошибку, т.к. класс не определяет данный метод:) Но как же тогда реализация по умолчанию, зачем она нужна?! Это хорошо работает с полиморфизмом, о чем мы поговорим в следующей статье, пока просто можно принять тот факт, что ссылка на базовый класс может хранить объекты всей цепочки классов наследников, расширяющих данный базовый класс (такая же логика работает и со ссылкой на интерфейс).

public class Program
{
    public static void Main()
    {
        // Bender bender = new Bender();
        // bender.Move(); // ошибка компиляции!!!
        
        IMovable bender2 = new Bender();
        bender2.Move(); // Я могу перемещаться
    }
}

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

Множественное наследование

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

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

Таким образом, при создании объекта класса D по логике в памяти будет создано аж 2 объекта базового класса A, и в D будет унаследованы переопределения его методов и от B и от C, что является полной шизофренией.

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

public interface IMovable
{
    void Move()
    {
        Console.WriteLine("Я могу перемещаться");
    }
}

public interface IDrinker
{
    void Drink();
}

public class Bender : IMovable, IDrinker
{
    public override void Move()
    {
        Console.WriteLine("Я куда-то иду");
    }
    
    public override void Drink()
    {
        Console.WriteLine("бимбимбамбам, пива много не бывает");
    } 
}

Разница между абстрактными классами и интерфейсами

Давайте подведем итоги по основным отличиям абстрактных классов от интерфейсов и определим, когда что лучше использовать, потому что это не совсем очевидно, особенно после нововведений в C# 8 (нововведения... сейчас C# 12 уже, мда, в плюсах такой проблемы нет:))).

Отличия интерфейсов и абстрактных классов:

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

Таким образом, используем интерфейс, если:

Необходимо определить общий функционал (протокол) для различных классов объектов, которые слабо связаны между собой. (IClonable, IDisposable, IEnumerable, все эти базовые интерфейсы определяют некоторый функционал/контракт/протокол, которому соответствуют реализующие их классы)

Используем абстрактные классы, если:

Нам необходимо разработать общий функционал для родственных объектов, как некую абстрактную сущность (которую можно в отличие от интерфейса IClonable представить, например, Vehicle).
Классы наследники нуждаются в большом количестве общей функциональной логики или её предполагается часто менять. При этом достаточно изменить логику в классе родителе, чтобы она изменилась во всех классах наследниках.
Если класс сам по себе не является полноценной единицей, с которой можно взаимодействовать, то используем абстрактный класс, а не обычный.

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

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

Основы принципов ООП

2023-07-12T00:58:21.321Z

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

Подходы программирования, история ООП

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

В 1930-х годах перед математиками встала проблема разрешения, сформулированная Давидом Гильбертом. Суть её в том, что необходимо найти алгоритм, который бы за конечное число шагов находил ответ на утверждение, задаваемое на формальном языке, истинно или ложно. Задача была опровергнута с помощью двух подходов, разработанных математиками Алонзо Чёрчем и Аланом Тьюрингом. Они показали (первый — с помощью изобретённого им λ-исчисления, а второй — теории машины Тьюринга), что для арифметики такого алгоритма не существует в принципе, т.е. данная задача в общем случае неразрешима.

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

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

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

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

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

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

Лямбда-исчисление и машины Тьюринга функционально эквивалентны — что все, что можно вычислить с помощью машины Тьюринга, можно вычислить с помощью лямбда-исчисления, и наоборот, исходя из тезиса Чёрча-Тьюринга. То есть одну и ту же задачу можно выполнить разными подходами, но где-то нам данную задачу будет реализовать проще.

Одним из первых языков программирования, основанных на императивном подходе, был низкоуровневый язык ассемблера, появившийся в конце 40-х, дающий полный доступ к аппаратным средствам компьютера. Следующий шаг в развитии императивного подхода произошел к концу 50-х с появлением "высокоуровневых" языков, таких как Fortran, COBOL и ALGOL, которые стали предоставлять более абстрактные языковые конструкции для написания кода. И уже позднее в 60-х годах в результате развития императивного подхода берет свое начало ООП.

В 1961 году в Норвегии Оле-Йохан Даль и Кристен Найгаард начали совместную работу над созданием языка описание для компьютерного моделирования взрывающихся кораблей. Они поняли, что могут группировать корабли по разным категориям. У каждого типа корабля будет свой собственный класс, и класс будет иметь свое уникальное поведение и данные. Simula отвечала не только за введение концепции класса, но также за введение экземпляра класса.

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

Термин «объектно-ориентированное программирование» ввел Алан Кей при работе на компанию Xerox PARC над своим языком программирования Smalltalk. Этот термин использовался для обозначения процесса использования объектов в качестве основы для вычислений. Smalltalk был вдохновлен идеями, заложенными в Simula 67, но Smalltalk был разработан таким образом, чтобы он был динамичным. Объекты можно было изменять, создавать или удалять, и это отличалось от обычно используемых статических систем. А также Smalltalk был первым языком программирования, в котором была представлена концепция наследования.

Повсеместное распространение и всеобщее признание ООП получило с дальнейшей реализацией идей SIMULA в таких мастодонтах, как C++ и Java. Сейчас же ООП является наиболее важным подходом и в процентах 95 в продуктовой разработке используется именно он (и только всякие глупые олимпиадники пытаются протолкнуть свою фпшку, код которой будет работать на 0.00005 наносекунды быстрее🤡).

ООП

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

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

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

По тому, как устроена работа с классами в C# (создание объектов, очистка памяти, обращение к методам, статические классы, спецификаторы доступа и пр.), повторяться не будем, это все можно найти в предыдущих лекциях курса по основам. Если не читали и не понимаете о чем речь, прочитайте, там все подробно разложено. А сейчас сконцентрируемся на парадигмах ООП: абстракция, инкапсуляция, наследование и полиморфизм.

Абстракция

Абстракция - набор значимых характеристик определенной категории объектов. Абстрагирование - это выявление свойств, связей и зависимостей для объекта, с целью выделить определенные закономерности, отбросив незначимые характеристики и скрыв детали реализации. Результатом абстрагирования являются абстрактные понятия (абстракции).

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

Например, возьмем класс телефон. У него будет кнопка включения, метод для включения/выключения и метод, позволяющий кому-то звонить, есть телефон включен.

Инкапсуляция

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

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

Наследование

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

Например, пусть у нас будет базовый класс Transport, который будет иметь название и будет уметь перемещаться, а также класс наследник Car. Тогда данное отношение в C# можно записать через двоеточие у класса наследника следующим образом:

public class Transport
{
    public string Name { get; set; }
    
    public void Move()
    {
        Console.WriteLine($"{Name} move");
    }
}

public class Car : Transport
{
}

Таким образом, класс наследник Car будет иметь тот же набор полей и методов, которые доступны в соответствии со спецификаторами доступа (про них мы разгоняли тут)

По умолчанию все классы наследуются от базового Object, даже если мы явно не устанавливаем наследование. Поэтому определенные классы Transport и Car кроме своих собственных методов, также будут наследовать и методы класса Object: ToString(), Equals(), GetHashCode() и GetType().

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

public sealed class Car : Transport
{
}

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

public class Transport
{
    public Transport(string name)
    {
        Name = name;
    }

    public string Name { get; set; }
    
    public void Move()
    {
        Console.WriteLine($"{Name} move");
    }
}

public class Car : Transport
{
    public Car(string name, string model)
        : base(name)
    {
        Model = model;
    }
    
    public string Model { get; set; }
}

Полиморфизм

Полиморфизм - это способность объектов с одинаковой спецификацией иметь разную реализацию.

Если усе упрощать, то различают два типа полиморфизма: статический и динамический.

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

class Robot
{
    public void SaySomething(string words, int a)
    {
        Console.WriteLine(words);
        Console.WriteLine(a + 3);
    }

    public void SaySomething(string name, string words)
    {
        Console.WriteLine($"{name} - {words}");
    }
}

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

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

public class Transport
{
    public virtual void Move()
    {
        Console.WriteLine($"Move");
    }
}

public class Car : Transport
{
}

public class Ship : Transport
{
    public override void Move()
    {
        Console.WriteLine($"Swim");
    }
}

public class Program
{
    public static void Main()
    {
        SomeFunc(new Transport()); // Move
        SomeFunc(new Car());       // Move
        SomeFunc(new Ship());      // Swim
    }
    
    public static void SomeFunc(Transport transport)
    {
        transport.Move();
    }
}

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

Таким образом, компилятор не знает о переопределяемом методе и выбирает необходимый метод в рантайме по виртуальной таблице методов (но об этом я напишу уже в другой статье/посте, чтобы не затягивать эту:), и мы получаем ожидаемый результат, Сar выводит move, потому что метод не переопределялся, а для Ship вызывается переопределенный метод и выводится swim.

Также стоит отметить, что есть возможность отменить поведение механизма полиморфизма с помощью модификатора new.

public class Transport
{
    public virtual void Move()
    {
        Console.WriteLine($"Move");
    }
}

public class Ship : Transport
{
    public new void Move()
    {
        Console.WriteLine($"Swim");
    }
}

public class Program
{
    public static void Main()
    {
        SomeFunc(new Transport()); // Move
        SomeFunc(new Ship());      // Move
    }
    
    public static void SomeFunc(Transport transport)
    {
        transport.Move();
    }
}

А в этой лекции усе. С понятиями познакомились, базу узнали, фп от ооп различать научились... Могу пожелать здоровья психологического при освоении программирования, но это C#, а не C++, так что должно быть все в порядке, главное не сдаваться. В следующей статье поговорим о наследовании, абстрактных классах, интерфейсах, даааа... На канале сейчас возможно постить начну всякие полезности интересные, чтобы он не простаивал пока я большими материалами занимаюсь, так что подписывайтесь 👉https://t.me/serious_seesharp

Стек вызовов и исключения

2022-11-30T18:00:35.515Z

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

Стек

Стек — структура данных, работающая по принципу LIFO(last in first out - последний вошел - первым вышел). Добавление элементов в стек происходит с одного конца, вершины стека. Удаление из стека происходит также, начиная с вершины стека, то есть с последнего добавленного элемента по порядку.

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

В C# стек представлен в виде коллекции Stack из пространства имен System.Collections и универсальной версией Stack<T> из System.Collections.Generic.

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

Push - добавление нового элемента в вершину;
Pop - получение верхнего элемента при его удалении;
Peek - чтение верхнего элемента без удаления.

var stack = new Stack<int>();
stack.Push(1);
stack.Push(2);
stack.Push(3);

Console.WriteLine(stack.Peek()); //3

Console.WriteLine(stack.Pop());  //3
Console.WriteLine(stack.Peek()); //2

stack.Pop();
Console.WriteLine(stack.Peek()); //1

Программный стек

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

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

Таким образом, при каждом вызове метода .NET инициализирует стек-фрейм (кадр стека, можно условно ассоциировать с контейнером), где и хранится вся необходимая информация для выполнения метода: параметры, локальные переменные, служебная информация, которая используется вызванной функцией, чтобы в нужный момент возвратить управление вызвавшей функции. Каждый такой новый фрейм (контейнер вызваемого метода) помещается на вершину стека и удаляется после завершения выполнения метода. У программного стека также есть особенность, что он растет в адресном пространстве памяти не снизу вверх, а сверху вниз.

Пимер программы и упрощенное представление стека вызовов

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

StackTrace и StackFrame

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

В C# для получения информации о стеке существует класс StackTrace из пространства имен System.Diagnostics, а за кадр (фрейм) стека отвечает класс StackFrame.

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

using System.Diagnostics;

class Program
{
    public static void Method1()
    {
        Method2();
    }

    public static void Method2()
    {
        Method3();
    }

    public static void Method3()
    {
        StackTrace currentTrace = new StackTrace(true);
        Console.WriteLine($"Количество фреймов: {currentTrace.FrameCount}");

        for (int i = 0; i < currentTrace.FrameCount; i++)
        {
            StackFrame frame = currentTrace.GetFrame(i);

            Console.WriteLine();
            Console.WriteLine($"Метод {frame.GetMethod().Name} из файла {frame.GetFileName()} " +
                $"расположен на строчке {frame.GetFileLineNumber()}");
        }
    }

    public static void Main(string[] args)
    {
        Method1();
    }
}

В данном примере в методе Method3() мы создаем объект трассировки StackTrace, а затем получаем поочередно все фреймы стека, начиная с верхнего, нулевого, и заканчивая нижним фреймом метода Main. Таким нехитрым образом получается достать много полезной информации о нашем коде, в данном примере мы выводим имена цепочки вызывающих методов и их расположение, с помощью методов объекта фрейма GetFileName() и GetFileLineNumber().
Нужно отметить, что для того, чтобы объект класса StackTrace собрал дополнительную инфу о расположении методов в коде необходимо использовать конструктор с булевым параметром fNeedFileInfo и передать в него true, иначе он не соберет данную информацию и мы получим на выходе методов GetFileName() и GetFileLineNumber() значения по умолчанию (null и 0 соответственно).

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

Ошибки и исключения

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

При разработке программного обеспечения мы сталкиваемся с тремя основными типами ошибок:

Программные ошибки, баги (bug - жук:) — ошибки в коде, допущенные программистом, приводящие к некорректной работе программы. Например, при обращении к элементам массива в цикле происходит выход за его пределы. Баги могут быть как простые вроде приведенного примера, так и с нарушением более глобальной сложной логики программы, и должны исправляться в процессе отладки кода программы.
Пользовательские ошибки — ошибки, которые допускает конечный пользователь во время работы с программой. Например, некорректный пользовательский ввод в текстовое поле, в котором ожидался ввод почты пользователя, а получили набор цифр, что может привести к возможным ошибкам в дальнейшей работе с программой. Такие проблемы обычно решаются путем добавления валидации входных данных.
Исключения — ситуации, которые не предусмотрены стандартным поведением программы. Например, когда коде программы мы открываем несуществующий файл для чтения из него или пытаемся подключиться к web-ресурсу, который по какой-то причине недоступен (его забанило правительственное ведомство нашего государства, а у нас не включен vpn:). Такие случаи обычно не зависят от программиста, и при их возникновении, чтобы программа не "падала" от непонимания, что делать дальше, эти исключительные ситуации необходимо обрабатывать.

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

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

/* Пример обработки ошибок в С, с помощью кодов */
#define CONN_FAIL 400  //объявление кода ошибки

int ConnDatabase()
{
    //Здесь происходит какая-то логика по подключению к базе,
    //но по какой-то причине могла возникнуть ошибка подключения,
    //в результате чего возвращается следующее значение
    return CONN_FAIL;
}

int main()
{
    int res = ConnDatabase();
    if (res == CONN_FAIL)
    {
        printf("Fail connection to db");
    }
    
    return 0;
}

/* Пример обработки ошибок в С, с помощью булевого флага */
bool error;

double Div(double a, double b)
{
    if (b == 0)
    {
        error = true;
        return NULL;
    }
    
    return a / b;
}

int main()
{
    error = false;
    double res = Div(5, 0);
    if (error == true)
    {
        printf("Zero division error");
    }
    else
    {
        printf("Result: %f", res);
    }

    return 0;
}

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

Для недопущения этого безобразия, в C#, как в любом нормальном современном япе, есть стандартные средства для генерации и обработки исключений, что не может не радовать, а генерируемые исключения являются объектами, которые содержат в себе различную полезную информацию о том, что произошло и где, в отличие от непонятных числовых кодов (документация по которым в сделку проекта естественно не входила:)

Исключения в C#

Как уже было сказано ранее, исключение - ситуация, которая не предусмотрена стандартным поведением программы. В C# все исключения происходят от базового класса System.Exception, а все остальные классы исключений – это производные классы, которые позволяют конкретизировать тип возникшего исключения.

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

Message — свойство с текстовым описанием ошибки, использующееся только для чтения и устанавливающееся в конструкторе;
HelpLink — свойство для указания или получения URL-ссылки для доступа к веб-странице с подробным описанием ошибки;
Source — свойства служащее для указания названия сборки или объекта, в котором возникло исключение;
TasrgetSite — свойство, доступное только для чтения, в котором содержится различная информация о методе, в котором возникло исключение;
StackTrace — свойство, доступное только для чтения, которое содержит цепочку вызовов методов до возникновения исключения;
InnerException — свойство, доступное только для чтения, которое может использоваться для получения информации о предыдущих исключениях, которые послужили причиной возникновения текущего исключения. Запись предыдущих исключений осуществляется путем их передачи конструктору самого последнего сгенерированного исключения.

Генерация исключений

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

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

class Program
{
    public static int Div(int a, int b)
    {
        return a / b;
    }

    public static void Main()
    {
        Console.WriteLine(Div(5, 0));
        Console.WriteLine(Div(5, 1));
    }
}

Код выше будет падать из-за вызванного неперехваченного исключения в первом вызове метода Div() при делении в нем на 0. В результате в консоли мы получим сообщение с информацией об исключении и стектрейсе, из которого мы можем понять, что было вызвано исключение DevideByZeroException в строке 5 метода Div(), при его вызове из строки 10 в файле Program.cs. Умение читать такие сообщения со стектрейсом является важным навыком для поиска ошибок в коде.

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

//создаем объект исключения
var ex = new Exception("Wow, its exception message");

//генерируем(выбрасываем) исключение
throw ex;

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

throw new Exception("Wow, its exception message");

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

Давайте возьмем пример с делением и бросим подходящее исключение самостоятельно с каким-то логичным сообщением о произошедшем, опередив CLR:

class Program
{
    public static int Div(int a, int b)
    {
        if (b == 0)
            throw new DivideByZeroException("Division by 0 is not allowed!!!!");

        return a / b;
    }

    public static void Main()
    {
        Console.WriteLine(Div(5, 0));
    }
}

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

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

class Program
{
    public static void Hello(string name)
    {
        if (name == null)
            throw new ArgumentNullException(nameof(name), "Name must not be null or empty");

        Console.WriteLine($"Hello {name}");
    }

    public static void Main()
    {
        Hello(null);
    }
}

Ситуация с null действительно типовая и часто встречается в начале общедоступных методов для проверки на возможное нежелательное значение параметров. Из-за того, что таких параметров могло быть много и производилась куча проверок, загрязняя код, в .NET 6 классу ArgumentNullException был добавлен статический метод ThrowIfNull, который генерирует соответствующее исключение, если параметр равен null.

class Program
{
    public static void Hello(string name, string id)
    {
        ArgumentNullException.ThrowIfNull(name, nameof(name));
        ArgumentNullException.ThrowIfNull(id, nameof(id));

        Console.WriteLine($"Hello {name} with {id}");
    }

    public static void Main()
    {
        Hello("Artem", null);
    }
}

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

Обработка исключений

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

try
{
    // Блок с потенциально проблемным кодом, 
    // который может сгенерировать исключение
}
catch(Exception ex)
{
    // Блок перехвата исключения, 
    // если оно было сгенерировано
}
finally
{
    // Финальный блок для закрытия каких-либо ресурсов,
    // который выполняется всегда в независимости,
    // было вызвано исключение или нет
}

Алгоритм работы данной конструкции сводится к следующему:

В блок try помещается код, который в ходе выполнения может привести к возникновению исключений.
Если в блоке try возникает исключение, то CLR останавливает выполнение инструкций в try и начинает искать подходящий блок catch, который предназначен для обработки данного исключения. Для блока catch мы указываем тип перехватываемого исключения, а внутри блока уже прописываем необходимые инструкции, которые необходимо выполнить для обработки исключения, например, зафиксировать каким-либо образом сообщение об ошибке: вывести в лог, отправить сообщение о проблеме на почту или в телегу.
Блок finally выполняется в конце всегда независимо, было вызвано исключение или нет, за исключением пары случаев, но о них позже.
Если при вызванном исключении оно было успешно "отловлено" с помощью catch, после блока finally выполнение переходит на следующую за данным блоком инструкцию.

Например, вот так мы можем отловить исключение при нашем делении на 0, и вывести сообщение об ошибке.

class Program
{
    public static int Div(int a, int b)
    {
        if (b == 0)
            throw new DivideByZeroException("Division by 0 is not allowed!!!!");

        return a / b;
    }

    public static void Main()
    {
        try
        {
            int res = Div(5, 0);
            Console.WriteLine($"Result: {res}");
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("End divide");
        }

        Console.WriteLine("End program");   
    }
}

Следует выделить несколько правил конструкции try catch finally:

При использовании try всегда должен использоваться как минимум один catch либо finally;
Блоков catch может быть много, либо ни одного, но они не могут существовать без блока try.
Блок finally не является обязательным при использовании try catch, но, если он используется, то он может быть только один.

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

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

try
{
    int res = Div(5, 0);
    Console.WriteLine($"Result: {res}");
}
catch (DivideByZeroException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Console.WriteLine("End program");

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

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

try
{
    Console.Write("Enter numerator: ");
    int a = int.Parse(Console.ReadLine());

    Console.Write("Enter denumerator: ");
    int b = int.Parse(Console.ReadLine());

    int res = Div(a, b);
    Console.WriteLine($"Result: {res}");
}
catch (DivideByZeroException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Теперь при вводе в консоле не чисел для числителя и знаменателя метод Parse() будет генерировать исключение FormatException, которое не будет перехвачено с помощью блока catch, т.к. он перехватывает в данном случае только DivideByZeroException, и программа аварийно завершится в таком случае. Чтобы этого избежать, необходимо добавить блок catch для обработки данных исключений:

try
{
    Console.Write("Enter numerator: ");
    int a = int.Parse(Console.ReadLine());

    Console.Write("Enter denumerator: ");
    int b = int.Parse(Console.ReadLine());

    int res = Div(a, b);
    Console.WriteLine($"Result: {res}");
}
catch (DivideByZeroException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
catch (FormatException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
    Console.WriteLine("You entered not a number!!!");
}
catch (Exception ex)
{
    Console.WriteLine($"Unreported error: {ex.Message}");
}

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

Исключения в стеке вызовов

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

Разберем на примере из 4-х методов, которые вызываются по цепочке, и в последнем возникает исключение:

class Program
{
    public static void Method1()
    {
        try
        {
            Method2();
        }
        catch(NotImplementedException ex)
        {
            Console.WriteLine(ex.Message);
            Console.WriteLine(ex.StackTrace);
            Console.WriteLine();
        }

        Console.WriteLine("Продолжаем выполнение");
    }

    public static void Method2()
    {
        Method3();
        Console.WriteLine("Это сообщение не напечатается");
    }

    public static void Method3()
    {
        try
        {
            throw new NotImplementedException("Исключение из метода 3");
        }
        catch(IOException ex)
        {
            Console.WriteLine("Тут не поймайется исключение");
        }
    }

    public static void Main()
    {
        Method1();
    }
}

Method3() находится на вершине стека вызовов, когда в нем возникает исключение NotImplementedException. CLR не найдет подходящего catch в Method3() и перейдет к следующему блоку try в стеке вызовов, предварительно удалив поочередно с вершины стека фреймы Method3 и Method2, добавляя информацию о них в стек трейс исключения. В Method1() найдется подходящий обработчик, поэтому выполнение продолжится с него.

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

Повторная генерация исключений

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

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

class Program
{
    public static void Method1()
    {
        try
        {
            Method2();
        }
        catch(NotImplementedException ex)
        {
            throw ex;
        }
    }

    public static void Method2()
    {
        Method3();
    }

    public static void Method3()
    {
        throw new NotImplementedException("Исключение из метода 3");
    }

    public static void Main()
    {
        try
        {
            Method1();
        }
        catch(Exception ex)
        {
            Console.WriteLine(ex.TargetSite);
            Console.WriteLine(ex.StackTrace);
        }   
    }
}

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

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

public static void Method1()
{
    try
    {
        Method2();
    }
    catch(NotImplementedException ex)
    {
        throw;
    }
}

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

public static void Method1()
{
    try
    {
        Method2();
    }
    catch(NotImplementedException ex)
    {
        throw new Exception("Rethrown", ex);
    }
}

В Main() изменил вывод на полный Console.WriteLine(ex)

Создание собственных классов исключений

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

Для создания собственного класса исключений необходимо и достаточно унаследовать свой класс от System.Exception или производного от него (о наследовании мы поговорим позже в лекциях об ООП:). Но есть четкая иерархия исключений, которой стоит придерживаться. System.Exception является базовым общим классом для всех создаваемых исключений, от него напрямую наследуются классы System.SystemException и System.ApplicationException. SystemException определяет исключения, генерируемые самой платформой .NET, а ApplicationException определяет исключения, порождаемые приложением.

Таким образом, Microsoft рекомендуют собственные классы исключений наследовать именно от ApplecationException. Как уже было сказано, чтобы создать класс исключения достаточно его просто унаследовать от Exception или от унаследуемого от него.

public class HouseOnFireException : ApplicationException
{
}

Но это не является хорошей практикой, т.к. мы не сможем передать даже никакое сообщение при генерации исключения. Для решения этой проблемы необходимо задать конструкторы, которые будут при создании объекта исключения обращаться к конструктору базового класса, с помощью base (о нем мы также подробнее поговорим уже в курсе лекций по ООП:)

public class HouseOnFireException : ApplicationException
{
    public HouseOnFireException()
    {
    }

    public HouseOnFireException(string message) 
        : base(message)
    {
    }

    public HouseOnFireException(string message, Exception innerException) 
        : base(message, innerException)
    {
    }
}

Все, теперь мы можем генерировать исключение нашего класса:)

Как-то так:) В следующей лекции поговорим еще раз про типизацию и разберем основы приведения типов, и наверно закончим с базой шарпа. А далее начнем курс лекций по ООП. Так что подписывайтесь на тг канал, ставьте лайки и вступайте в наш чат, там ничего нет.

Модификаторы параметров методов. Передача аргументов по значению и по ссылке

2022-11-14T17:27:44.225Z

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

Сигнатура метода, параметры и аргументы

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

Под сигнатурой метода понимают совокупность:

имени метода;
количества параметров;
типов параметров;
порядка типа параметров;
модификаторов параметров.

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

Например, следующие два метода являются перегруженными по сигнатуре:

class Robot
{
    public void SaySomething(string words, int a)
    {
        Console.WriteLine(words);
        Console.WriteLine(a + 3);
    }

    public void SaySomething(int a, string words)
    {
        Console.WriteLine(words);
        Console.WriteLine(a + 3);
    }
}

Сигнатура первого метода будет: SaySomething(string, int);
Сигнатура второго: SaySomething(string, int). Такой код является абсолютно валидным с точки зрения компилятора и он скомпилируется без ошибок.

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

типМетода ИмяМетода (типПараметра1 параметр1, типПараметра2 параметр2, ...)
{
    // действия метода
}

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

void PrintHello(string name)
{
    Console.WriteLine($"Hello, {name}");
} 

PrintHello("Artem");

В данном примере метод PrintHello принимает 1 параметр name типа string, при вызове PrintHello параметру name передается аргумент, в данном случае строка "Artem".

Передача по значению

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

public class SomeClass
{
    public static void Sum(int a)
    {
        a = a + 3;
    }
}

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

int a = 5;
SomeClass.Sum(a); // Ожидаем, что значение a увеличится на 3
Console.WriteLine(a); // Получаем иной результат, вывод: 5

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

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

class Robot
{
    public int Brain { get; set; }

    public static void Changer(Robot bot)
    {
        bot.Brain = 10;
    }
}

var bot = new Robot(); // Создаем объект класса Robot
bot.Brain = 3; // Присваиваем свойству значение 3
Robot.Changer(bot);
Console.WriteLine(bot.Brain); // Вывод: 10

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

class Robot
{
    public int Brain { get; set; }

    public static void Changer(Robot bot)
    {
        bot = new Robot();
        bot.Brain = 5;
    }
}

var bender = new Robot(); // Создаем объект класса Robot
bender.Brain = 3; // Присваиваем свойству значение 3
Robot.Changer(bender);
Console.WriteLine(bender.Brain); // Вывод: 3

В классе Robot имеем метод Changer, который принимает значение ссылки на экземпляр класса Robot в переменную bot и присваивает ей ссылку на новый экземпляр.
Здесь при копировании работает такая же логика как с типами значений: наш объект класса Robot хранится где-то в куче, переменная bender же на стеке хранит ссылку на этот объект, а при передаче переменной в качестве аргумента в методе работа будет происходить уже с переменной bot метода, которая содержит копию ссылки, поэтому изменение ссылки у данной переменной ни к каким изменениям объекта не приведет)

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

Передача по ссылке и модификаторы параметров

Для изменения стандартной передачи аргументов по значению используются модификаторы параметров методов, с помощью которых можно управлять способами передачи аргументов. Существует 4 модификатора: ref, out, in, params. Сейчас мы про каждый из них поговорим.

Ссылочные параметры, модификатор ref

Для передачи по ссылке можно использовать модификатор ref (от reference) перед типом параметра в сигнатуре метода, а также перед передаваемым аргументом при вызове метода:

public static void Swap(ref int a, ref int b)
{
    //вариант без создания 3-й переменной:)
    a = a + b;
    b = a - b;
    a = a - b;
}

int a = 1;
int b = 2;
Console.WriteLine($"a={a} b={b}"); //a=1 b=2
Swap(ref a, ref b);
Console.WriteLine($"a={a} b={b}"); //a=2 b=1

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

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

class Robot
{
    public int Brain { get; set; }

    public static void Changer(ref Robot bot)
    {
        bot = new Robot();
        bot.Brain = 5;
    }
}

var bender = new Robot(); // Создаем объект класса Robot
bender.Brain = 3;
Robot.Changer(ref bender); // передаем ссылочный тип по ссылке в метод, где будет изменена ссылка
Console.WriteLine(bender.Brain); // Вывод: 5

Выходные параметры, модификатор out

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

public static void Sum(int a, int b, out int sum)
{
    sum = a + b;
}

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

Sum(1, 2, out int result);
Console.WriteLine(result); // 3

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

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

void GetRectangleData(int width, int height, out int area, out int perimetr)
{
    area = width * height; 
    perimetr = (width + height) * 2;
} 

GetRectangleData(1, 2, out int area, out int perimetr); 
Console.WriteLine($"area = {area}, perimetr = {perimetr}"); // area = 2, perimetr = 6

Также преимуществом out является использование TryGet паттерна. Такой подход используется для получения некоторого значения в виде out параметра и возврата bool (если значение не было получено, вернется false, если получено - true).

Рассмотрим на примере методов Parse и TryParse у типа int. Метод int.Parse() используется для преобразования строки в число типа int. В случае, если число неудачи в преобразовании будет выброшено исключение (об исключениях мы уже скоро поговорим в следующей статье). Метод же TryParse не выбрасывает исключения в таком случае, а возвращает false и эту ситуацию можно обработать в условной конструкции. Это довольно упрощает код и не несет дополнительных расходов для обработки всех ситуаций.

int a = int.Parse("1"); // a = 1
a = int.Parse("aaa"); //FormatException

if (int.TryParse("15", out int b))
{
    Console.WriteLine($"b = {b}");
}
else
{
    Console.WriteLine("Wow, this is not number");
}

Входные параметры, модификатор in

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

public static int Sum(in int a, in int b)
{
    int sum = a + b;
    return sum;
}

int a = 5;
int b = 4;
int c = Sum(a, b);
Console.WriteLine(c);

При попытке изменить параметр с модификатором in мы получим ошибку.

Модификатор params

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

МодификаторДоступа ВозвращаемыйТип ИмяМетода(params ИмяТипа[] ИмяПеременной)
{
    тело метода
}

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

Стоит запомнить ряд требований:

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

Примеры методов с использованием данного ключевого слова:

class SomeClass
{
    public void DoSomething1(params int[] c)
    {
        for (int i = 0; i < c.Length; i++)
            Console.WriteLine(c[i]);
    }
    
    public void DoSomething2(int a, params int[] b)
    {
    }
    
    public void DoSomething3(string a, int b, params int[] c)
    {
    }
}

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

SomeClass a = new SomeClass(); // Создали экземпляр класса
int[] array = { 1, 2, 3 }; // Создали массив из трех элементов

a.DoSomething1(); // params может принимать 0 аргументов!
a.DoSomething1(1);
a.DoSomething1(1, 2, 3, 4, 5);
a.DoSomething1(5, 2);
a.DoSomething1(array);

a.DoSomething2(1); // В данном методе обязан быть хотя бы 1 целочисленный
                   // аргумент, поскольку помимо переменного числа
                   // аргументов указан обязательный целочисленый параметр
a.DoSomething2(2, array);
                   
a.DoSomething3("hi", 1); // Аналогично методу DoSomething2                 
a.DoSomething3("bye", 2, 3, 4, 5, 6);
a.DoSomething3("hey!", 5, array);

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

public void FirstMethod(int[] array) // При вызове обязательно принимает
{                                    // аргумент – массив
}

public void SecondMethod(params int[] array) // При вызове может не
{                                            // принимать ничего
}

Необязательные параметры

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

И это просто замечательно, как эти жабисты существуют без параметров по умолчанию, я не понимаю:)

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

static void PrintRobotInfo(string msg, int age = 500, string name = "Bender")
{
    Console.WriteLine($"I'm {name}, {age} years");
    Console.WriteLine(msg);
}

PrintRobotInfo("Kill all humans", 100);
// I'm Bender, 100 years
// Kill all humans

Как-то так)

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

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

Структуры данных в C#: массивы и коллекции

2022-11-03T15:50:15.363Z

Привет! В этой статье речь пойдет о такой неотъемлемой вещи в программировании как структуры данных.

Структуры данных

Структура данных - это некий способ организации информации в памяти определенным образом для эффективного хранения этой информации и извлечения.

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

Типы структур:

Линейные - структуры данных, в которых элементы расположены последовательно, где каждый элемент прикреплен к своему предыдущему и следующему соседним элементам.
Линейные структуры бывают статическими и динамическими:
🞄 Статическая структура данных имеет фиксированный размер памяти (например, массивы);
🞄 В динамической структуре данных размер не фиксирован. Он может обновляться во время выполнения. (списки, очереди, стек)
Нелинейные - структуры данных, в которых элементы данных расположены не последовательно. В нелинейной структуре данных мы не можем обойти все элементы только за один проход. (графы, деревья)

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

Массивы

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

Тип[] имяПеременной;

Так, например, объявляется массив целых чисел:

int[] array;

Каждое отдельное значение набора обычно именуют элементом массива. Размером (или длиной) массива называют количество его элементов, это значение неизменяемо! Каждый элемент массива идентифицируется по индексу. Индекс – это целое число из заданного диапазона, начинающегося с нуля и заканчивающегося размером массива минус один, так как индексацию в C# также как и во многих других языках программирования принято начинать с 0.

Разберемся с каждым определением на примерах!

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

Тип[] имяПеременной = new Тип[размерМассива];

Например, объявим и проинициализируем массив целочисленных значений на 7 элементов:

int[] array = new int[7];

Но на данный момент у нас имеется массив элементов, которые мы никак не задавали (не проинициализировали). А как вы помните, все не проинициализированные элементы вручную инициализируются своими значениями по умолчанию, соответствующие типу, и с массивами это работает аналогично. Т.е. в данном случае мы получим набор из 7 элементов, равных 0.

Другим способом инициализации является использование инициализаторов объекта, о которых мы говорили в одной из прошлых статей:

int[] firstArray = new int[7] { 1, 2, 3, 4, 5, 6, 7 }; // массив из 7 элементов
int[] secondArray = new int[] { 1, 2, 3 }; // массив из 3 элементов
int[] thirdArray = new [] { 1, 2, 3, 4, 5 }; // массив из 5 элементов
int[] fourthArray = { 1, 2, 3, 4 }; // массив из 4 элементов

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

Для работы с элементами массива нам и понадобятся индексы! Массив – это линейная структура данных, все элементы набора расположены в памяти последовательно, каждый в своей ячейке памяти, и данная область памяти является непрерывной.

Использование индексов – это быстрый способ обратиться к конкретному элементу последовательности. Индексация массива начинается с 0, поэтому чтобы обратиться к первому элементу массива, нам необходимо использовать индекс 0, а для обращения к четвертому элементу – индекс 3. Для обращения к конкретному элементу необходимо после имени переменной массива в квадратных скобках указать индекс интересующего нас элемента:

int[] array = { 101, 3, 42, 5 }; // создали массив из 4 элементов
Console.WriteLine(array[0]); // Выводим первый элемент массива: 101
Console.WriteLine(array[1]); // Выводим второй элемент массива: 3

array[1] = 121;              // Заменяем значение второго элемента массива
Console.WriteLine(array[1]); // Выводим второй элемент массива: 121

Запомните! Обратиться мы можем только к существующим элементам, т.е. наш массив должен существовать, а индекс, по которому мы обращаемся, должен быть в пределах от нуля до размер массива минус 1 [0, n - 1]:

int[] firstArray;
Console.WriteLine(firstArray[0]); // Ошибка компиляции! Использование
                                  // неинициализированной переменной!
int[] secondArray = {1, 2, 3, 4};
Console.WriteLine(secondArray[4]); // Исключение во время работы программы!
                                   // Обращение к несуществующему элементу!

Операции с массивами

Массивы в C# представляют собой реальные объекты, а не просто адресуемые области непрерывной памяти (как это сделано в C++, например). Array является абстрактным базовым классом для всех типов массивов и содержит ряд методов и свойств для работы с массивами.

Например, с помощью свойства Length можно получить длину массива, обратившись к нему по имени массива:

int[] arr = { 21, 42, 53, 103 };
Console.WriteLine(arr.Length); // Вывод: 4

Класс Array также содержит множество статических методов (не зависящих от состояния массивов, от количества элементов в них) для работы с данными массивов:

метод Clear очищает массив, устанавливая всем элементам значения по умолчанию (в качестве аргументов принимает массив, начальный индекс диапазона, с которого происходит очистка, а также число элементов, подлежащих очистке);
Reverse располагает элементы в массиве в обратном порядке (в качестве аргумента принимает массив, который мы хотим развернуть);
IndexOf возвращает индекс переданного в качестве аргумента элемента, если он существует, или возвращающий -1, если такого элемента нет (в качестве аргументов принимает массив и элемент, индекс которого в данном массиве мы хотим узнать).
Sort сортирует элементы массива.

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

int[] arr = { 21, 42, 53, 103 };
Console.WriteLine(arr.Length); // Вывод: 4

Console.WriteLine(Array.IndexOf(arr, 42)); // Вывод: 1
Console.WriteLine(Array.IndexOf(arr, 103)); // Вывод: 3
Console.WriteLine(Array.IndexOf(arr, 2)); // Вывод: -1

Array.Reverse(arr);
Console.WriteLine(arr[0]); // Вывод: 103

Array.Clear(arr, 0, 4); // Очищаем значениями по умолчанию 4 элемента,
                        // начиная с первого (по индексу ноль)
Console.WriteLine(arr[0]); // Вывод: 0

Многомерные массивы

Размерность массива (ранг) – это количество индексов, необходимое для однозначного определения каждого элемента массива. Размерность массива можно определить с помощью свойства Rank, обратившись к нему через имя переменной массива и оператора точки:

int[] array = { 1, 2, 3 };
Console.WriteLine(array.Rank); // Вывод: 1

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

int[] array = new int[6] { 0, 1, 2, 3, 4, 5 };

Для обращения к элементу такого массива нам достаточного одного индекса.

Размерность массивов может быть больше 1. Для объявления таких массивов в квадратных скобках необходимо запятой как бы разделять измерения. Например, объявление и инициализация двумерного массива может выглядеть так:

int[,] array = new int[2, 3];
Console.WriteLine(array.Rank); //Вывод: 2

Таким нехитрым действием мы создали двумерный массив интов 2 на 3. (Грубо говоря, 2 массива по 3 элемента в каждом).

Инициализатор будет работать аналогичным образом:

int[,] firstArray= new int[2, 3] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] secondArray= new int[,] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] thirdArray = new [,] { { 0, 1, 2 }, { 3, 4, 5 } };
int[,] fourthArray = { { 0, 1, 2 }, { 3, 4, 5 } };

Такой двумерный массив можно представить в виде таблицы – сочетаний строк и столбцов:

int[,] array = { { 0, 1, 2 }, { 3, 4, 5 } };

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

Console.WriteLine(array[0, 0]); // Вывод: 0
Console.WriteLine(array[0, 1]); // Вывод: 1
Console.WriteLine(array[0, 2]); // Вывод: 2
Console.WriteLine(array[1, 0]); // Вывод: 3
Console.WriteLine(array[1, 1]); // Вывод: 4
Console.WriteLine(array[1, 2]); // Вывод: 5

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

Массивы массивов

Массив массивов – это массив, который в качестве своих элементов хранит ссылки на другие массивы:

int[][] array = new int[10][]; // объявление и инициализация массива
                               // из десяти массивов

В результате работы кода выше будет создан массив, содержащий ссылки на 10 массивов. Эти ссылки необходимо отдельно проинициализировать:

for(int i = 0; i < array.Length; i++)
{
    array[i] = new int[10];
}

С помощью цикла for мы проходимся по нашему массиву, инициализируя каждую ссылку массивом целочисленных значений размером 10.

Нередко массив массивов называют ступенчатым (или зубчатым) массивом. Связано это с тем, что при инициализации подмассивов мы можем задавать им различные размеры:

int[][] array = new int[3][]; // Создали массив из трех массивов
array[0] = new int[3]; // Инициализируем подмассивы
array[1] = new int[5];
array[2] = new int[2];

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

Коллекции в C#

Хотя базовые массивы могут быть удобными для управления небольшими объемами данных фиксированного размера, есть немало случаев, когда требуются более гибкие структуры данных, такие как динамически расширяющийся и сокращающийся контейнер, ассоциативные контейнеры с доступом к элементам по ключу и прочее)

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

Динамические массивы

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

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

Array.Resize(ref array, 7);
for (int i = 0; i < array.Length; i++)
    Console.Write($"{array[i]} "); //1 2 3 4 5 0 0

Array.Resize(ref array, 3);
for (int i = 0; i < array.Length; i++)
    Console.Write($"{array[i]} "); //1 2 3

о том, что такое ref, речь пойдет в следующей небольшой статье:)

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

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

Класс ArrayList из пространства имен System.Collections представляет собой коллекцию с массивом динамически изменяющегося размера.

using System.Collections;

ArrayList arr = new ArrayList();

Под капотом ArrayList имеет обычный массив, но в отличие от него в работе с динамическими массивами добавляется еще одно свойство – Capacity (вместимость). При создании динамического массива определенного размера, помимо самого размера определяется также значение вместимости, в соответствии с которым и выделяются необходимые объемы памяти под данную коллекцию.

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

Основные свойства и методы для работы с ArrayList:

Count – свойство, возвращающее количество элементов в массиве. Для обычных массивов это свойство называлось Length, в динамических коллекциях стандартной библиотеки его стали именовать Count для логического разделения со статическими;
Capacity – свойство, возвращающее текущую вместимость динамического массива. Количество элементов, под которое выделена память для текущего массива, после превышения которого память под массив будет перевыделяться и массив копироваться;
Add – метод, позволяющий добавить элемент в массив, в качестве аргумента принимает добавляемый элемент;
Remove – метод, позволяющий удалить первое вхождение элемента, переданного в качестве аргумента;
RemoveAt – метод, позволяющий удалить элемент по индексу.

При создании ArrayList без передачи в его конструктор размера, он не содержит никаких элементов и его Capacity и Count равны 0:

ArrayList arr = new ArrayList();
Console.WriteLine(arr.Count); // Вывод: 0 
Console.WriteLine(arr.Capacity); // Вывод: 0

Но мы можем сразу зарезервировать память под наш массив передав необходимый размер в конструктор. Таким образом размер массива по-прежнему будет равен 0, но уже будет зарегистрирована некоторая память для добавления новых элементов:

ArrayList arr = new ArrayList(7);
Console.WriteLine(arr.Count); // Вывод: 0 
Console.WriteLine(arr.Capacity); // Вывод: 7

При добавлении новых элементов мы можем отследить, как меняется размер и вместимость массива:

ArrayList someArray = new ArrayList(3);

someArray.Add(1);
Console.WriteLine(someArray.Count); // Вывод: 1
Console.WriteLine(someArray.Capacity); // Вывод: 3

someArray.Add(2);
someArray.Add(3);
Console.WriteLine(someArray.Count); // Вывод: 3
Console.WriteLine(someArray.Capacity); // Вывод: 3

someArray.Add(4);
Console.WriteLine(someArray.Count); // Вывод: 4
Console.WriteLine(someArray.Capacity); // Вывод: 6

someArray.Add(5);
someArray.Add(6);
Console.WriteLine(someArray.Count); // Вывод: 6
Console.WriteLine(someArray.Capacity); // Вывод: 6

someArray.Add(7);
Console.WriteLine(someArray.Count); // Вывод: 7
Console.WriteLine(someArray.Capacity); // Вывод: 12

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

ArrayList arr = new ArrayList();
arr.Add(2);
arr.Add("hey");
arr.Add('c');
arr.Add(3.5);

Универсальные коллекции

Хранить всё подряд в своей коллекции может быть полезно и здорово, но не безопасно и в большинстве случаев требуется точного ограничения того, что может содержаться в нашем наборе, строго типизировать его. Библиотека классов .NET предоставляет ряд универсальных классов коллекций в пространстве имен System.Collections.Generic, являющихся строго типизированными и обычно обеспечивают более высокую производительность.

Generics(обобщенные типы) – достаточно объемная и не самая простая тема, но для базового понимания работы коллекций сейчас в нее углубляться нам не надо. В нашем случае generic служит в качестве способа указания того, что будет храниться внутри коллекции.

Среди основных универсальных коллекций отметим:

List<T> – список, типизированный аналог неуневерсальной коллекции ArrayList;
Dictionary<K, T> – словарь, типизированный аналог неуневерсального Hashtable;
Queue<T> – очередь, типизированный аналог неуневерсального Queue;
Stack<T> – стек, типизированный аналог неуневерсального Stack;
HashSet<T> – хэшсет, коллекция, содержащая элементы без повторений, хранящая их в произвольном порядке;
и другие...

Например посмотрим на пример ниже обобщенного списка значений типа int:

List<int> integerList = new List<int>();

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

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

List<int> firstList = new List<int>(); // Список целочисленных значений
List<string> secondList = new List<string>(); // Список строк
List<List<int>> thirdList = new List<List<int>>(); // Так тоже можно =)
                                           // Получаем список списков интов
                                           // подобно массиву массивов

Перебор коллекций

Мы уже знаем, что для обращения к какому-то конкретному индексу и для перебора индексируемых коллекций массивов/списков можно использовать обычный цикл for:

List<int> arr = new List<int>(){ 4, 3, 2, 1 };
for (int i = 0; i < arr.Count; i++)
    Console.WriteLine(arr[i]) // 4 3 2 1

Но как перебрать неиндексируемые коллекции, например Dictionary (о нем чуть ниже пойдет речь:)?!

Все коллекции, которые были и будут рассмотрены в данной статье, относятся к специальному типу коллекций – перечислимым (Enumerable). Для перебора элементов перечислимых коллекций существует специальная логика, за которую отвечает специальный объект - Enumerator. Для перебора любой перечисляемой коллекции необходимо сделать следующее:

List<int> someList = new List<int>() { 1, 2, 3, 4 };

List<int>.Enumerator it = someList.GetEnumerator(); // получаем Enumerator

while(it.MoveNext()) // Двигаемся по коллекции
{
    Console.WriteLine(it.Current); // Выводим значение
}

1) Получаем объект Enumerator, обращаясь к методу GetEnumerator() у экземпляра коллекции и сохраняя его в переменную it.

2) С помощью цикла while обращаемся к методу MoveNext() у полученного объекта, который двигает нас по коллекции.

3) Свойство Current возвращает текущее значение, на которое указывает Enumerator.

4) Метод MoveNext() возвращается false, когда элементы в коллекции заканчиваются.

Здесь важно запомнить, что Enumerator создается для текущего состояния коллекции! Это значит, что если изменить количество элементов в коллекции во время её перебора, то объект Enumerator перестанет существовать, что приведет к ошибке в программе.

Но, как мы уже говорили в одной из предыдущих статей про управляющие конструкции, в C# помимо циклов for, while и do while существует также еще foreach. По сути foreach является синтаксическим сахаром и разворачивается при компиляции ровно в ту конструкцию, что была показана в предыдущем примере, но при его использовании наш код будет гораздо компактнее и понятнее, что не может не радовать)

foreach(ТипЭлементаКоллекции имяПеременной in имяПеребираемойКоллекции)
{
    тело цикла
    (по имени переменной сможем обращаться к элементам коллекции)
}

Пример:

List<int> someList = new List<int>() { 1, 2, 3, 4 };

foreach(int i in someList)
{
    Console.WriteLine(i);
}
// Вывод построчно: 1 2 3 4

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

List<T>

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

Аналогично созданию массива, мы можем создавать списки – список элементов с динамически изменяемым размером. Хоть List<T> и называется списком, но под капотом построен с использованием массива, в связи с чем по сути является динамическим массивом, а не структурой данных связанным списком:) За связанные списки в C# отвечает коллекция LinkedList<T>.

string[] s = { "hey", "hi", "bye" };

List<string> list1 = new List<string>() { "yo", "c#" };

List<string> list2 = new List<string>(s); // содержит все элемнты массива s

List<string> list3 = new List<string>(list1); // содержит все элементы
                                              // листа list1

Методы добавления элементов:

Add() – добавляет переданный в качестве аргумента элемент в конец коллекции, тип передаваемого элемента должен совпадать с типом, которые хранит коллекция;
AddRange() – добавляет переданный в качестве аргумента диапазон значений в конец коллекции, типы также должны совпадать.

List<string> list1 = new List<string> { "yo", "c#" };
List<string> list2 = new List<string> { "oy" };

list2.Add("#c"); // Добавляем элемент в конец второго списка

list1.AddRange(list2); // Добавляем все элементы второго
                       // списка в конец первого
list1.AddRange(list1); // Добавляем элементы первого списка
                       // в конец самого себя
foreach (string item in list1)
{
    Console.WriteLine(item);
}
// Вывод построчно: "yo" "c#" "oy" "#c" "yo" "c#" "oy" "#c"

При расширении List<T> изменение размера Count и вместимости Capacity происходит аналогично ArrayList.

Методы вставки элементов:

Insert() – вставка элемента, в качестве аргументов принимает индекс, на место которого мы хотим произвести вставку, и вставляемый элемент;
InsertRange() – вставка диапазона значений, в качестве аргументов принимает индекс, на место которого мы хотим произвести вставку, и вставляемую коллекцию.

List<string> list1 = new List<string> { "yo", "c#" };
List<string> list2 = new List<string> { "oy" };

list1.Insert(0, "hello world"); // вставляем в список на место
                                // первого элемента
list1.Insert(list1.Count, ".NET"); // вставляем в конец списка

list2.InsertRange(list2.Count, list1); // вставляем все элементы первого
                                       // списка в конец второго
foreach (string item in list2)
{
    Console.WriteLine(item);
}
// Вывод построчно: "oy" "hello world" "yo" "c#" ".NET"

Методы удаления элементов:

Remove() – удаляет первое вхождение элемента, переданного в качестве аргумента, возвращает true, если элемент был успешно удален, в противном случае – false (например, при передаче несуществующего в коллекции элемента);
RemoveAt() – удаляет элемент по индексу, в качестве аргумента принимает индекс, выход за границы массива как обычно приводит к ошибке;
RemoveRange() – удаляет все элементы коллекции в указанном диапазоне: с указанного индекса удаляется число указываемых элементов, выходить за границы коллекции всё еще нельзя.

List<string> list1 = new List<string>{ "1", "2", "3", "3", "3", "4"};
List<string> list2 = new List<string>{ "1", "1", "1", "1", "1", "2", "3", "4" };

list1.Remove("3");

foreach (var item in list1)
{
    Console.WriteLine(item);
}
// Вывод построчно: "1" "2" "3" "3" "4"

list1.RemoveAt(2);

foreach (var item in list1)
{
    Console.WriteLine(item);
}
//Вывод построчно: "1" "2" "3" "4"

list2.RemoveRange(0, 4);

foreach (var item in list2)
{
    Console.WriteLine(item);
}
// Вывод построчно: "1" "2" "3" "4"

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

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

Методы поиска:

Contains() – возвращает true или false в зависимости от того, существует ли в коллекции переданный в качестве аргумента элемент;
Find() – возвращает первый элемент, удовлетворяющий условию, подробнее к этому мы обязательно вернемся в последующих статьях.

Прочие методы:

Reverse() – смена порядка элементов на обратный;
ToArray() – возвращает все элементы коллекции в виде массива соответствующего типа.

А также множество других методов, к которым мы будем обращаться по мере роста наших возможностей!

Хэш-функции

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

Хэш-функции используются при:

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

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

HashSet

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

HashSet<int> firstSet = new HashSet<int> { 1, 2, 2, 3, 4, 4, 4, 5, 6, 6 };

foreach (var item in firstSet)
{
    Console.WriteLine(item);
}
// Вывод построчно: 1 2 3 4 5 6

List<int> someList = new List<int>{ 6, 6, 7, 7, 8, 9, 10, 10 };
HashSet<int> secondSet = new HashSet<int>(someList);

foreach (var item in secondSet)
{
    Console.WriteLine(item);   
}
// Вывод построчно: 6 7 8 9 10

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

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

Добавлять новые элементы во множество можно с помощью метода Add(), при добавлении уже существующих элементов ничего не произойдет:

HashSet<int> someHashSet = new HashSet<int>(); // создали пустой HashSet

someHashSet.Add(1);
someHashSet.Add(1);

foreach(var item in someHashSet)
{
    Console.WriteLine(item);
}
// Вывод: 1

Удаление происходит аналогично списку с помощью метода Remove() и передачи значения элемента, который мы хотим удалить:

HashSet<int> someHashSet = new HashSet<int>() { 1, 2, 3, 4};

someHashSet.Remove(2);
someHashSet.Remove(10);

foreach(var item in someHashSet)
{
    Console.WriteLine(item);
}
// Вывод построчно: 1 3 4

Метод Contains() позволяет узнать существует ли переданный элемент в коллекции, в качестве аргумента принимает интересующее значение, а возвращает значение типа bool в соответствии с результатом работы:

HashSet<int> someHashSet = new HashSet<int>() { 1, 2, 3, 4};

if(someHashSet.Contains(1))
{
    Console.WriteLine("1 is in HashSet"); // Вывод: 1 is in HashSet
}

if(someHashSet.Contains(10))
{
    Console.WriteLine("10 is in HashSet"); // Сюда мы не зайдем т.к. 10 нет
}                                          // в нашем множестве

Dictionary

Dictionary (также именуемый словарём или мапой) – ассоциативный массив, позволяющий хранить элементы в виде пар "ключ-значение", например:

1 - "Котик"
2 - "Собачка"
3 - "Птичка"

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

Dictionary<int, string> someDict = new Dictionary<int, string>();

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

Dictionary<int, string> someDict = new Dictionary<int, string>()
{
    { 1, "Kotik" },
    { 2, "Soba4ka" },
    { 3, "Pti4ka" }
};

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

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

Dictionary<int, string> someDict = new Dictionary<int, string>();

someDict.Add(1, "Vanya"); // Добавили пару 1 - "Vanya"
someDict.Add(2, "Sanya"); // Добавили пару 2 - "Sanya"
someDict.Add(1, "Oleg"); // Олег все испортил - ошибка, по ключу 1 уже
                         // существует элемент

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

Dictionary<int, string> someDict = new Dictionary<int, string>();

someDict.Add(1, "Vanya"); // Добавили пару 1 - "Vanya"
someDict.Add(2, "Sanya"); // Добавили пару 2 - "Sanya"

if (!someDict.ContainsKey(1))
{
    someDict.Add(1, "Oleg"); // Добавляем Олега только если нет элемента
}                            // с ключом 1

Или можно использовать специальный безопасный метод TryAdd():

Dictionary<int, string> someDict = new Dictionary<int, string>();

someDict.TryAdd(1, "Vanya"); // Добавили пару 1 - "Vanya"
someDict.TryAdd(2, "Sanya"); // Добавили пару 2 - "Sanya"
someDict.TryAdd(1, "Oleg"); // Мы остановили Олега, ничего не произойдет,
                            // элемент добавлен не будет

Удаление элемента из коллекции также происходит по ключу:

Dictionary<int, string> someDict = new Dictionary<int, string>()
{
    { 1, "Kotik" },
    { 2, "Soba4ka" },
    { 3, "Pti4ka" }
};

someDict.Remove(3); // Удалили пару 3 - "Pti4ka"

Для перебора элементов Dictionary также удобно использовать foreach:

Dictionary<int, string> someDict = new Dictionary<int, string>()
{
    { 1, "Kotik" },
    { 2, "Soba4ka" },
    { 3, "Pti4ka" }
};

foreach (KeyValuePair<int, string> item in someDict)
{
    Console.WriteLine($"{item.Key} - {item.Value}");
}
// Вывод:
// 1 - Kotik
// 2 - Soba4ka
// 3 - Pti4ka

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

Console.WriteLine(someDict["first"]); // Вывод: Kotik
Console.WriteLine(someDict["second"]); // Вывод: Soba4ka
Console.WriteLine(someDict["third"]); // Вывод: Pti4ka

При этом обращение к несуществующему ключу приведет к ошибке:

Console.WriteLine(someDict["fourth"]); // ОШИБКА!

Пока по структурам данных все, но мы обязательно вернемся к этой теме еще не раз, так как еще оооочень много чего следует дорасказать, и это была лишь ознакомительная статья о том, с чем предстоит в дальнейшем постоянно сталкиваться) Далее на канале выйдет небольшой пост о синтаксическом сахаре var и не большая статья о передаче объектов по значению и по ссылке, и будем начинать выкладывать различные задачки для практики и отработки материала. Так что подписывайтесь на тг-канал ставьте лайки и вот этого всего можно побольше!)

Классы и объекты

2022-10-25T12:39:11.940Z

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

Шаблоны проектирования

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

Методы доступа к данным класса

Одним из общепринятых подходов организации механизмов чтения и записи полей является реализация методов доступа, часто именуемых аксессорами (от access – доступ):

getter (get – получать) – общее именование методов доступа, позволяющих получать данные;
setter (set – задавать) – общее именование методов доступа, позволяющих задавать данные.

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

class Human 
{ 
    private string name;
    private int age; 
    
    public string GetName() 
    { 
        return name; 
    } 
    
    public void SetName(string nameToSet) 
    { 
        name = nameToSet; 
    } 
    
    public int GetAge() 
    { 
        return age; 
    } 
    
    public void SetAge(int ageToSet) 
    { 
        age = ageToSet; 
    } 
}

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

Свойства классов

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

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

Общий шаблон объявления свойств выглядит следующим образом:

[модификатор доступа] [тип] ИмяСвойства
{
    get { инструкции, выполняемые для возвращения значения }
    set { инструкции, выполняемые для установки значения }
}

Разберемся на примере:

class Human 
{ 
    private string name; 
    private int age; 
    
    public string Name 
    { 
        get { return name; } 
        set { name = value; } 
    } 
    
    public int Age 
    { 
        get { return age; }  
        set { age = value; } 
    }
}

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

в блоке get определяем действия для получения значения свойства, с помощью оператора return возвращаем какое-то значение (тип возвращаемого значения должен совпадать с типом свойства);
в блоке set устанавливаем значение свойства, с помощью параметра value обозначается переданное свойству значение (т.е. данным ключевым словом обозначается параметр, значение которого передается при присваивании свойству).

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

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

Human human = new Human(); 
human.Name = "Vasya";    // присваиваем значение свойству 
human.Age = 23;          // и здесь

Console.WriteLine(human.Name); // Vasya 
Console.WriteLine(human.Age);  // 23

Присваивание значения свойству приводит к вызову аксессора set, значение передается через value. Возвращение свойства приводит к вызову аксессора get и возврату значения с помощью return.

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

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

class Human 
{ 
    public string Name { get; set; } 
    public int Age { get; set; } 
}

При использовании таких свойств не нужно прописывать поля, с которыми будет работать свойства и описывать базовую логику присваивания и возврата в теле set и get. Компилятор на этапе компиляции создаст из свойства соответствующие приватные поля и методы для обращения к этим полям, а наш код маленьким и приятным для глаза)

Конструкторы классов

В статье "Классы, поля и методы", обсуждая способ создания классов и работу оператора new, было отмечено, что завершающим действием данного оператора является вызов конструктора экземпляра. Так что же такое конструктор?

Конструктор – это специальный метод, вызываемый при создании объекта класса. Он используется для инициализации полей некоторыми значениями, выполнения какой-либо логики при создании объекта. Конструктор позволяет создавать 100% пригодный экземпляр класса, чтобы мы не имели чемодан без ручки. Конструктор имеет название, совпадающее с именем класса, и не имеет типа:

[модификатор доступа] ИмяКласса 
{ 
    необходимые инструкции 
}

Существует два типа конструкторов: конструктор по умолчанию и параметризованный конструктор.

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

class Human
{
    public Human()
    {
    
    }
}

Конструктор по умолчанию не генерируется в случае объявления собственных конструкторов.

Под параметризованным конструктором понимают конструктор, имеющий как минимум один параметр:

class Human
{
    public Human(string name, int age)
    {
    
    }
}

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

class Human 
{ 
    public Human() // корректный конструктор 
    { 
    } 
    
    public Human(string name) // корректный конструктор 
    { 
    } 
    
    public Human(int age, string name) // корректный конструктор 
    { 
    } 
    
    public Human(string name, int age) // корректный конструктор 
    { 
    } 
    
    public Human(int age)    // Ошибка! 
    {                        // Порядок типов параметров данных 
    }                        // конструкторов совпадает
    public Human(int height) // Это два одинаковых конструктора! 
    { 
    } 
}

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

class Human 
{ 
    public string Name { get; set; } 
    public int Age { get; set; } 
    
    public Human() 
    { 
        Name = "Default guy"; 
        Age = 20; 
        Console.WriteLine("Default guy is created"); 
    } 
    
    public Human(string name, int age) 
    { 
        Name = name; 
        Age = age; 
        Console.WriteLine("Human is created"); 
    } 
}

Human defaultHuman = new Human(); // вывод: "Default guy is created"
Console.WriteLine(defaultHuman.Name); // вывод: "Default guy"
Console.WriteLine(defaultHuman.Age); // вывод: 20

Human human = new Human("Vasya", 50); // вывод: "Human is created"
Console.WriteLine(human.Name); // вывод: "Vasya"
Console.WriteLine(human.Age); // вывод: 50

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

Жизненный цикл объекта, сборка мусора и деструктор

Процесс создания объекта называют инстанцированием (instance – экземпляр). После создания, объект располагается где-то в куче, в оперативной памяти. В общем виде принято считать, что объект жив, пока хотя бы какая-нибудь переменная хранит адрес этого объекта, ссылается на него. Т.е. пока мы имеем возможность взаимодействовать с объектом – объект жив. Как только теряются все ссылки на объект, он становится недостижим для нас. Этот объект попрежнему существует, занимает какое-то место в памяти, но он бесполезен. Проще говоря данный объект является мусором, он лишь занимает наше драгоценное место в памяти. Именно поэтому все объекты, затерянные в виртуальной машине, помечаются как мусор.

Human human1 = new Human("Oleg");
human1 = null;

Human human2 = new Human("Vanya");

Human human3 = new Human("Sanya");
human3 = human2;

Рассмотрим поподробнее пример выше. Мы создали 3 объекта класса человека, получили трех приличных членов общества: Олега, Ваню и Саню. Ссылку на Олега хранит лишь одна переменная – human1. Сразу после инстанцирования Олега, мы занулили ссылку, указывающую на него, отрезав таким образом для себя связь с ним. Press F Олегу, нам больше до него не добраться:( Ссылок, указывающих на него больше нет, именно поэтому бедолага будет помечен как мусор. Затем после создания объектов Ваня и Саня, мы присваиваем ссылке human3 значение ссылки human2. Таким образом, мы получаем две ссылки (human2 и human3), ссылающиеся на один объект – Ваню. На Саню же теперь не указывает ни одна ссылка, он тоже становится бесполезен и помечается как мусор.

Все бесполезные объекты, помеченные как мусор, рано или поздно удаляются. Здесь в дело вступает сборщик мусора или garbage collector. Сборщик мусора – специальный механизм, который отвечает за процесс управления памятью виртуальной машины CLR. Периодически запускаемый процесс сборки мусора удаляет бесполезные неиспользуемые объекты, освобождая таким образом место для новых. Сборщик мусора запускается НЕ сразу после потери всех ссылок на объект, такие мусорные объекты будут продолжать занимать память, а CLR сама определит когда их необходимо удалить, например, когда будет подходить к концу свободное место.

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

~ИмяКласса() 
{ 
    тело деструктора 
}

Так, например, экземпляры нашего класса Human, могут прощаться с нами при уничтожении:

~Human()
{
    Console.WriteLine("Bye bye");
}

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

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

Статические классы

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

[Модификатор доступа] static class Имя_класса
{
    тело класса
}

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

Особенности статического класса:

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

Обращение к элементам статического класса происходит через имя класса и оператор точки:

Console.WriteLine();

В данном примере мы обратились к статическому классу Console и вызвали статический метод WriteLine().

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

Статические конструкторы

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

static ИмяКласса() // статический конструктор
{

}

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

Важные замечания:

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

Типы перечислений

Тип перечисления – это тип значений, который определяется набором именованных констант целочисленного типа. Объявление перечисления происходит с помощью ключевого слова enum и перечня значений:

[Модификатор доступа] enum ИмяПеречисления
{
    значение1,
    значение2,
    значение3,
    ...
    значениеN
}

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

public enum Day
{
     Monday,
     Tuesday,
     Wednesday,
     Thursday,
     Friday,
     Saturday,
     Sunday
}

Мы определили свой первый тип перечислений, состоящий из 7 значений – 7 дней недели. Обращение к значениям перечисления осуществляется с помощью оператора точки, подобно обращению к полям класса. Поскольку перечисления являются типом данных (хоть и примитивным), мы можем создавать и использовать переменные их типа, присваивать им соответствующие значения, а также передавать их в качестве аргументов при вызове конструкторов, методов и других элементов C#.

Day someDay = Day.Monday; // переменная типа перечислений Day содержит
                          // значение Monday
if(someDay == Day.Monday)
{
    Console.WriteLine("Today is Monday");
}

Внимательный читатель заметил в определении типа перечислений упоминание о том, что значения являются именованными константами целочисленного типа. Это означает, что каждая константа перечисления сопоставляется с некоторым целочисленным числом. Если мы явным образом ничего не указываем, то по умолчанию используется тип int, первому значению сопоставляется число 0, а каждому последующему значению сопоставляется число с шагом 1 (т.е. для второго значения: 1, для третьего значения: 2, для n-го значения: n - 1). Желанный целочисленный тип можно указывать явно с помощью двоеточия после имени перечисления (именно целочисленный тип!), а желанное целочисленное число, сопоставляемое со значением, с помощью оператора присваивания после конкретного значения:

 public enum Day : long // явно указали тип long
 {
     Monday,        // Monday сопоставляется с 0 по умолчанию
     Tuesday,       // Tuesday сопоставляется с 1 по умолчанию      
     Wednesday = 5, // Wednesday сопоставляется с 5 из-за явного указания
     Thursday,      // Thursday сопоставляется с 6 по умолчанию
     Friday = 103,  // Friday сопоставляется с 103 из-за явного указания
     Saturday,      // Saturday сопоставляется с 104 по умолчанию
     Sunday         // Sunday сопоставляется с 105 по умолчанию
 }

Каждому элементу перечисления можно задать значения, эти значения могут повторяться и даже являться другими элементами перечисления:

public enum Day
{
     Monday = 1,         // Monday сопоставляется с 1
     Tuesday = 43,       // Tuesday сопоставляется с 43
     Wednesday = Monday, // Wednesday сопоставляется с 1
     Thursday,           // Thursday сопоставляется с 2
     Friday = 23,        // Friday сопоставляется с 23
     Saturday = 23,      // Saturday сопоставляется с 23
     Sunday              // Sunday сопоставляется с 24
}

Чтобы использовать целочисленное значения элемента перечисления, мы можем использовать операцию явного приведения:

Console.WriteLine((int)Day.Tuesday); // для последнего примера Day
                                     // значение будет 43

Здесь стоит отметить, что константа сопоставляется с каким-то целочисленным значением, но мы не можем присвоить ей числовое значение:

Day monday = 1; // Ошибка!

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

public void SayHello(Day currentDay)
{
    switch (currentDay)
    {
        case Day.Monday:
            Console.WriteLine("Hi! Today is Monday.");
            break;
        case Day.Tuesday:
            Console.WriteLine("Hi! Today is Tuesday.");
            break;
        case Day.Wednesday:
            Console.WriteLine("Hi! Today is Wednesday.");
            break;
        case Day.Thursday:
            Console.WriteLine("Hi! Today is Thursday.");
            break;
        case Day.Friday:
            Console.WriteLine("Hi! Today is Friday.");
            break;
        case Day.Saturday:
            Console.WriteLine("Hi! Today is Saturday.");
            break;
        case Day.Sunday:
            Console.WriteLine("Hi! Today is Sunday.");
            break;
        default:
            break;
    }
}

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

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

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

2022-10-19T19:48:12.637Z

Привет! Мы продолжаем нашу серию статей по основам C#. Сегодня разберемся с приоритетом операций и управляющими конструкциями. Чего-то сильно уникального относительно других языков вы вряд ли для себя найдете, если C# для вас не первый язык, но можете обратить внимание на оператор switch, он действительно устроен немного по-другому.

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

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

Итак, основной код программы на C# состоит из инструкций/команд(statements), операторов(operators) и выражений(expressions).

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

//пример простой инструкции объявления переменной
int a = 5;

Инструкции состоят из выражений, а те, в свою очередь – из операндов и операторов. Каждая инструкция заканчивается ;.

Операция - это некоторое действие, производимое над операндами. А оператор определяет суть данного действия, которое будет произведено над операндами (например, оператор + определяет действие сложения).

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

//инструкции объявления переменных
int a;
int b = 1; //правая часть rvalue является константным выражением

//инструкция выражения, сохраняющая значение выражение в переменной a
a = 1 + b + 2;
//1 + b + 2 - выражение
//1, b, 2 - операнды
//+ = - операторы

Операторы в C# делятся на унарные, бинарные и тернарные в зависимости от количества операндов, с которыми они работают.

При вычислении выражения, в котором содержится несколько операторов, операции выполняются в порядке приоритета операторов.

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

int a = 5 + 4 * 3;
// 5 + (4 * 3) = 17

Если в выражении операции имеют одинаковые приоритеты, то порядок их выполнения определяется ассоциативностью. Операторы делятся на левоассоциативные и правоассоциативные.

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

1 + 2 + 3 //((1 + 2) + 3) = 3 + 3 = 6

Правоассоциативные операции выполняются справа налево. Правоасоциативными являются операторы присваивания, объединения с null, лямбда-выражения и тернарный оператор?:.

int a = 5;
int b, c;
b = c = a; //b = (c = a)

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

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

условные конструкции (if else)
конструкция выбора (switch)
конструкции цикла (while, do while, for, foreach)
условный оператор (?:)
выражение (switch)

Вообще в документации и в оригинальной литературе конструкции if else, switch, for, while, break, continue выделяются от operators именно как инструкции statements, но во всех переводах мы увидим заветное слово "оператор" в независимости + это или if. Не знаю, только у меня такая шиза или еще кого-то от этих понятий триггерит. Наверно нужно это принять...

Условная конструкция if else

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

if (условие)
{
    блок выполнения, если условие истинно
}
else
{
    блок выполнения, если условие ложно
}

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

int a = 1;
int b = 5;

if (a > b)
{
    Console.WriteLine($"First number {a} is greater {b}");
}
else
{
    Console.WriteLine($"First number {a} is not greater {b}");
}

Часть else является необязательной, и при ее отсутствии будет выполняться только блок if, если условие истинно.

int a = 20;
int b = 20;

if (a == b)
{
    Console.WriteLine($"Numbers are equal");
}

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

int a = 1;
int b = 5;

/*if (a > b)
{
    Console.WriteLine($"First number {a} is greater {b}");
}
else
{
    if (a == b)
    {
        Console.WriteLine($"Numbers are equal");
    }
    else
    {
        Console.WriteLine($"First number {a} is less {b}");
    }
}*/

if (a > b)
{
    Console.WriteLine($"First number {a} is greater {b}");
}
else if (a == b)
{
    Console.WriteLine($"Numbers are equal");
}
else
{
    Console.WriteLine($"First number {a} is less {b}");
}

И, да, когда в блоке конструкции одна команда, можно опустить скобки {}, они необходимы, когда в блоке содержится более одной команды.

if (a > b)
    Console.WriteLine($"First number {a} is greater {b}");

Сравнение ссылочных типов

Как мы уже знаем, для сравнения двух значений на равенство используется оператор ==. И это действительно справедливо для типов значений, операнды типов значений равны, если равны их значения.

int a = 5;
int b = 5;

Console.WriteLine(a == b); //true

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

class Cat
{
    public int id;
}

Cat cat1 = new Cat{ id=1 };
Cat cat2 = new Cat{ id=1 };
Cat cat3 = cat1;

Console.WriteLine(cat1 == cat2); //false
Console.WriteLine(cat1 == cat3); //true

Для определения условия сравнения объектов у ссылочного типа используется метод Equals(), который возвращает значение типа bool и наследуется от базового класса Object.

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

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

class Cat
{
    public int id;
    
    public bool Equals(Cat otherCat)
    {
        return id == otherCat.id;
    }
}

Cat cat1 = new Cat{ id=1 };
Cat cat2 = new Cat{ id=1 };
Cat cat3 = cat1;

Console.WriteLine(cat1 == cat2); //false
Console.WriteLine(cat1 == cat3); //true
Console.WriteLine(cat1.Equals(cat2)); //true
Console.WriteLine(cat1.Equals(cat3)); //true

У вас сразу же может возникнуть вопрос. Раз String - это класс и он, соответственно, является ссылочным типом, то почему же строки нормально сравниваются по значению также и через оператор == ?! А все просто, для строк == также перегружен для их сравнения не по ссылке. О перегрузке операторов мы также уже скоро поговорим)

Тернарный оператор

Условный оператор (тернарный) вычисляет логическое выражение и в зависимости от полученного значения true или false возвращает результат одного из двух соответствующих выражений. Он имеет следующий синтаксис:

[условие] ? [выражение при истинном условии] : [выражение при ложном условии]

В зависимости от значения логического(условного) выражения true или false, будет выполняться первое или второе выражение тернарного оператора.

int a = 1;
int b = 5; 

int c = a < b ? a + b : a - b;
Console.WriteLine(c); //6

Циклы

Циклы являются управляющими конструкциями, позволяющими выполнять набор инструкций множество раз. В C# 4 типа циклов: for, foreach, while, do while. В этой статье пойдет речь только о 3 штуках. О foreach мы поговорим, когда будем разбирать коллекции.

Цикл for

Цикл for имеет следующее формальное определение:

for ([действия_до_выполнения_цикла]; [условие]; [действия_после_выполнения])
{
    // блок команд
}

Объявление цикла for состоит из трех частей. Первая часть объявления цикла - некоторые действия, которые выполняются один раз до выполнения цикла. Обычно здесь определяются переменные, которые будут использоваться в цикле.

Вторая часть - условие, при котором будет выполняться цикл. Цикл будет выполняться, пока условие не станет равно false.

И третья часть - некоторые действия, которые выполняются после завершения блока цикла. Эти действия выполняются каждый раз при завершении блока цикла.

Но при этом все эти 3 части являются необязательными и их при надобности можно опустить)

int sum = 0;
for (int i = 0; i < 5; i++)
{
    sum += i;
}

Console.WriteLine(sum); //10

for (int i = 1, int j = 2; i < 10; i++, j++)
{
    int mult = i * j;
    Console.WriteLine($"{mult}");
}

int i = 1;
for (; ;) //этот цикл будет бесконечным, что не гуд, нужно делать точку выхода из цикла
{
    Console.WriteLine($"i = {i}");
    i++;
}

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

Циклы while и do while

Цикл while выполняет блок команд, пока определенное логическое выражение равно значению true. Так как это выражение оценивается перед каждым выполнением цикла, цикл while выполняется ноль или несколько раз. Это основное отличие от цикла do while с постусловием, у которого будет выполнена хотябы одна итерация, после чего будет произведена проверка условия.

int i = 10;
while (i > 0)
{
     Console.WriteLine(i);
     i--;
}

do
{
    Console.WriteLine(i);
    i--;
} while(i > 0)

Цикл do while почти никогда не используют, так как почти всегда есть возможность заменить его на while. На практике у меня возникала одна ситуация, когда мне потребовался именно цикл do while, и не было возможности заменить его обычным while, и то я эту ситуацию уже даже не помню))

Инструкции перехода: continue и break

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

int i = 10;
while (true)
{
     if (i < 0)
         break;
         
     Console.WriteLine(i);
     i--;
}

А для досрочного перехода к следующей итерации цикла без его завершения используется инструкция continue.

for (int i = 0; i < 9; i++)
{
    if (i == 5)
        continue;
        
    Console.WriteLine(i);
}

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

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

switch (выражение)
{
    case значение1:
        набор команд, выполняемых, если выражение имеет значение1
        break;
    case значение2:
        набор команд
        break;
   case значениеN:
        набор команд
        break;
   default:
        набор команд, который выполняется, если выражение не подходит ни под одно значение выше
        break;
}

После ключевого слова switch в скобках идет сравниваемое выражение. Значение этого выражения последовательно сравнивается со значениями, помещенными после оператора сase. И если совпадение будет найдено, то будет выполняться определенный блок сase. Если значение выражения не подходит ни под одно условие, будет выполнен блок default, но он в конструкции необязателен.

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

switch в C# способен сопоставлять все базовые типы данных char, string, bool, int, long, float, double, decimal и enum.

int x = 4;

switch (x)
{ 
     case 1: 
         Console.WriteLine("one"); 
         break; 
     case 2: 
         Console.WriteLine ("two"); 
         break; 
     case 3: 
         Console.WriteLine ("three"); 
         break; 
     case 4: 
         Console.WriteLine ("four"); 
         break;
     default:
         Console.Writeline("Wow, king in the castle");
         break;
}

До выхода версии C# 7 сопоставляющие выражения в операторах switch ограничивались сравнением переменной с константными значениями. Начиная с C# 7 появилась возможность указывать диапазон значений, с помощью ключевого слова when.

int x = 6;

switch (x)
{
    case < 5:
        Console.WriteLine("< 6");
        break;
    case int i when i > 5 && i < 6:
        Console.WriteLine("5 < x < 6");
        break;
    case int i when i > 5 || i == 4:
        Console.WriteLine("> 5 || 4");
        break;
    case 6:
        Console.WriteLine("6");
        break;
}

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

На этом вроде все) Не стал писать здесь про весьма приятное выражение switch, о нем вероятно напишу в отдельном посте. И не стал писать про go to, прости господи. Не используйте недоразумение в своем коде, тех, кто использует это недоразумение, бьют палками!!! Нет таких ситуаций, когда нельзя было бы не обойтись без go to.

В следующей статье снова поговорим о классах. Рассмотрим свойства, конструкторы и деструкторы классов, жизненный цикл объекта класса и немного поговорим про garbage collector и возможно еще о чем-нибудь)
Подписывайтесь на наш тг-канал, чтобы ничего не пропустить.

Классы, поля и методы

2022-10-12T16:16:34.628Z

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

Классы и объекты

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

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

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

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

Таким образом, класс — это описание того, какими свойствами и поведением будет обладать объект. А объекты — это экземпляры класса с собственным состоянием (т.е. все экземпляры имеют одинаковый набор свойств, но их значения могут быть разными).

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

class ИмяКласса
{
    //тело класса
}

Типы значений и ссылочные типы

В .NET память делится на два основных типа: стек и куча. Стек представляет собой структуру данных, которая растет снизу вверх: каждый новый добавляемый элемент помещается поверх предыдущего, а физически - это зарезервированная для программы, при ее запуске, область памяти. Кучей же (heap'ом) является остальное адресное пространство памяти, доступное процессору.

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

Типы значений - примитивы, можно описать как "неделимые" типы данных, располагающиеся в памяти в зависимости от контекста, обычно на стеке. К типам значений относятся: byte, sbyte, short, ushort, int, uint, long, ulong, float, double, decimal, bool, char. Также к типам значений относятся struct и enum, но о них мы поговорим немного позже:)

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

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

У типов значений и ссылочных типов есть еще ряд отличий, но перечисленной информации пока достаточно для понимания рассматриваемого материала. А это нам и надо, чтобы все было по полочкам). Так что, пока стоит запомнить, что:

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

Создание объектов класса

При объявлении переменных, если не проинициализировать их, то они будут иметь определенные дефолтные значения. Для типов значений дефолтными значениями являются: целочисленные и типы с плавающей точкой - 0, bool - false, char - '\0'. Ссылочные типы имеют в качестве значения по умолчанию пустую ссылку null (напомню, их переменные на стеке хранят именно ссылку на область в памяти, а так как объект не был создан, то и в памяти объекта еще нет).

int a;              //0
bool cond;          //false
ExampleRobot robot; //null

class ExampleRobot {}

Для создания нового экземпляра класса используется оператор new, который выполняет следующие действия:

Вычисление необходимого количества памяти;
Выделение памяти для объекта;
Инициализация указателя на объект;
Вызов конструктора экземпляра. (про конструкторы, деструкторы и жизненный цикл объектов будет материал далее, все идет своим чередом:)

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

ExampleRobot robot = new ExampleRobot();

Поля и методы класса

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

class Robot
{
    public int id;
    public string model;
    public string name = "fuckhead";
}

Как говорилось выше для задания поведения для объектов класса используются методы. Метод - это блок кода, объединяющий набор команд, которые выполняются при его вызове. Методы могут возвращать либо не возвращать значение. Методы, которые ничего не возвращают имеют тип возвращаемого значения void. Для возврата значения используется оператор return.

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

class Robot
{
    public int id;
    public string model;
    public string name = "fuckhead";
    
    public void Dance()
    {
        Console.WriteLine($"I'm {name} robot, I will dance");
    }
    
    public int MultiplyWithId(int a, int b)
    {
        int c = a * b * id;
        return c;
    }
}

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

Robot ironMan = new Robot();

ironMan.Dance(); //I'm fuckhead robot, I will dance

int c = ironMan.MultiplyWithId(1, 2); //0
ironMan.id = 5;
c = ironMan.MultiplyWithId(1, 2); //10

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

Robot ironMan = new Robot{ id=1, model="T1000", name="arnold" }

Статические поля и методы

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

class Robot
{
    public int id;
    public static string model = "T1000";
    public static string name = "fuckhead";
    
    public static string GetInfo()
    {
        return $"Model {model} is {name}";
    }
    
    public void Dance()
    {
        Console.WriteLine($"I'm {name} robot with id={id}, " +
            $"I will dance");
    }
}

Статические переменные инициализируются при первом обращении к классу. Для обращения к статическим членам используется имя класса, а не имена объектов.

Robot.name = "Bender";
Console.WriteLine(Robot.GetInfo()); //Model T1000 is Bender

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

Области видимости и спецификаторы доступа

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

Можно выделить следующие контексты:

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

class Car
{
    public string model;
    
    public void Drive()
    {
        Console.WriteLine($"{model} say tr tr tr");
    }
}

class Person
{
    public static string name = "Sanya";

    public static void DriveOnCar()
    {
        /*Поле model объекта класса Car существует в рамках контекста Car
        *и будет существовать в методе DriveOnCar 
        *пока существует данный объект класса.
        */
        Car car = new Car(){ mdoel="bmw" };
        car.Drive();
    }
    
    public static void Dance()
    {
        {
            /*Какой-то блок кода с локальной перменной a,
            *которая не будет доступна вне данного блока.
            *Т.е. вне этих скобочек в методе Dance мы уже
            *не сможем к ней обратиться.
            *Написал данное чисто для примера, 
            *не смог придумать ничего лучше.
            */
            int a = 1; 
        }
        
        /*От сюда мы не можем обратиться к a, ее здесь уже не существует)
        *И из данного метода мы не можем обратиться к объекту класса Car,
        *который создается в методе DriveOnCar, он существует в контексте 
        *только того метода.
        *
        *Но есть доступ к переменной name, которая находится 
        *в контексте класса Person.
        */
        
        Console.WriteLine($"{name} dick suck, and now dance")
    }
}

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

class Robot
{
    public string name = "fuckhed";
    
    public void Dance()
    {
        string name = "NewName";
        Console.WriteLine($"I'm {name} robot with id={id}, " +
                $"I will dance");
    }
    
    public void OldDancer()
    {
        Console.WriteLine($"I'm {name} robot with id={id}, " +
                $"I will dance");
    }
}

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

Существуют следующие спецификаторы:

public - элемент доступен из любого места программы;
private - доступен только внутри класса;
protected - доступен в самом классе и в классах наследниках;
internal - доступ возможен из любого кода в той же сборке; (Сборкой можно называть отдельно работающую программу (исполняемый файл exe) либо библиотеку(dll));
private protected - доступ к члену класса возможен внутри класса и в объявляющей сборке для классов-наследников.
protected internal - доступ к члену класса возможен только из его объявляющей сборки и из классов-наследников в любой сборке.

Если спецификатор не указать вручную, то будет присвоен спецификатор по умолчанию:

Для всех классов модификатором доступа по умолчанию является internal;
Для всех элементов класса модификатором доступа по умолчанию является private.

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

На этом пока все. В следующей статье разберем управляющие конструкции и далее будем углубляться в работу с классами, разбирая все более крутые фишки языка C#. Берегите себя, пока!)

Первая программа

2022-10-07T11:02:40.129Z

Привет! В этой статье разберем правила построения программы на C#, структуру проекта, немного поговорим о переменных и основных операциях с ними, а также соберем и запустим первую программу. Летс го)

Понятие программы

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

Дональд Кнут в первом тому своем труда "Искусство программирования" ооооочень подробно описал историю происхождения термина алгоритма и дал хорошее определение:

Алгоритм — это конечный набор правил, который определяет последовательность операций для решения конкретного множества задач и обладает пятью важными чертами: конечность, определённость, ввод, вывод, эффективность

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

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

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

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

Базовые принципы построение программы на языке C#

Код каждой программы на языке C# должен отвечать 4-м основным принципам для его успешной компиляции и выполнения:

В С# каждая команда начинается с новой строки и заканчивается точкой с запятой;
Команда не может существовать сама по себе. Совокупность команд и различных управляющих конструкций, реализующих определенную логику или функциональную возможность, называется методом.
Программы в С# состоят из классов. Класс - это некоторый шаблон, описывающий некоторую группу объектов(сущностей) с помощью набора переменных (данных) и методов для работы с ними. Каждый класс следует описывать в отдельном файле, имя которого следует называть именем класса.
Выполнение программы начинается с метода Main. Минимальная исполняемая программа в С# всегда имеет метод Main.

Первая программа

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

Сначала хочу показать, как это все делается, используя минимальные средства, далее установим и настроим IDE. Но перед началом необходимо установить .NET с сайта Microsoft для своей операционки, ничего сложного там нет качаете инсталятор и устанавлаиваете, тыкая "далее", либо с помощью средств командной строки, там подробно все расписано.

Итак, для начала создаем отдельную папочку для проекта, в моем примере это FirstProgram, открываем блокнот и пишем простейший класс Robot с одним методом Main, сохраняем файл класса с расширением .cs.

А вы думали, я вам код текстом дам?! Нет, переписывайте, набивайте руку)))

Для сборки проекта .NET также необходим файл .csproj с неким "описанием проекта", как он будет собираться. Создаем его FirstProgram.csproj)))

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net6.0</TargetFramework>
  </PropertyGroup>
</Project>

В нем сейчас указан выходной тип сборки, исполняемый файл exe(т.к. у меня шиндовс), и версия .NET 6.

Теперь открываем открываем папочку с нашим проектом и прописываем команду dotnet build для сборки проекта, с помощью драйвера .NET.

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

Компоненты простейшей программы

Теперь поговорим о том, что мы вообще написали.

Пространство имен и директива using

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

В качестве примера можем взять проект из двух файлов Robot1.cs и Robot2.cs, при чем оба класса мы "нечаянно" назвали Robot, а в методе Main мы обращаемся к методу Say() нашего робота. При компоновке возникнет, соответственно неоднозначность. Компилятор не сможет понять, какой именно класс мы хотим использовать.

Классы, которые не помещенны в какое-то собственное пространство имен, лежат в глобальном пространстве имен

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

Пространство имен определяется с помощью ключевого слова namespace следующим образом:

namespace Имя
{ 
    Определение типов 
}

Хорошим тоном для выбора пространства имен считается: Компания.Проект.ИмяПрограммы

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

ИмяПространстваИмен.ИмяКласса.Метод

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

Мы находимся в том же самом пространстве имен. То есть, если класс объявлен внутри фигурных скобок пространства имен и используется в них же;
Пространство имен подключено с помощью директивы using.

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

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

Переменные и их представление в памяти

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

Так вот, память можно себе представить как некоторую сетку с множеством ячеек с уникальными номерами, каждая из которых хранит (в основном) по 1 байту (8 бит) информации. После загрузки некоторых данных (например целого числа) в оперативную память, эти данные будут располагаться там последовательно, начиная с ячейки с неким адресом n, а заканчивая ячейкой n + size, где size - размер данных.

Мы можем обращаться по адресу памяти, читать от туда данные и менять их, но, согласитесь, человеку было бы не удобно работать с такими адресами напрямую 0x7ffda41c5fac)) Для этого были придуманы переменные и константы.

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

тип имяПеременной;

Мы можем задать любое имя переменной, удовлетворяющее следующим правилам:

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

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

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

int a = 5;
Console.WriteLine(a); //5
a = 4;
Console.WriteLine(a); //4

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

const int someSize = 10;
Console.WriteLine(someSize);

Типы данных

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

Тип данных однозначно определяет:

внутреннее представление данных, а следовательно, и множество их возможных значений;
допустимые действия над данными (операции и методы).

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

Целочисленные типы

Числа с плавающей точкой

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

Сложение +

int a = 10;
int b = a + 5; //15
double c = 10 + 15.156; //25.156

Вычитание -

int a = 15;
int b = a - 5; //10

Умножение *

int a = 15;
int b = a * 5; //75

Деление /

int a = 5 / 2; //2

double b = 5 / 2; //2

doubcle c = 5.0 / 2; //2.5

double d = 10;
double e = 3;
double g = d / e; //3.333333

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

Остаток от деления %

double d = 10;
double e = 3;
double g = d % e; //1

Унарный минус

int a = 1;
a = -a; //-1

Операции инкремента и декремента

Данные операции прибавляют и убавляют значение числа на 1, соответственно. Бывает префиксная и постфиксная формы. Префиксная форма инкремента++x - сначала значение переменной x увеличивается на 1, а потом ее значение возвращается в качестве результата операции. Постфиксная форма инкремента x++ - сначала значение переменной x возвращается в качестве результата операции, а затем к нему прибавляется 1.

int a = 5;
a++; // a=6
int b = a++; // a=7 b=6

int c = 8;
int d = ++c; // c=9 d=9

int n = 16;
n--; // 15
int t = --n; // t=14 n=14

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

Помимо простой операции присваивания = в C# определены составные операции присваивания. Как и операция =, они все приводят к присваиванию значения той переменной, которая находится в их левой части, при выполнении с ней операции с выражением, находящимся в правой части.

int a = 5;
int b = 6;
a += b; // a=11
a -= b - 4 // a=1

Булевый тип

Данные тиа bool обычно используют для проверки тех или иных условий. Литералы булевского типа – это ключевые слова true и false.

int a = 5;
int b = 5;
int c = 10;

bool d = a == b; //true
d = a == c; // false
d = a < c; // true

Важно отметить, что в языке C# не разрешено преобразование булевого типа в числовые значения, true в 1 и false в 0, как это реализуется в других языках, например в C++.

Символьный тип

Значение символьного типа может хранить одиночный символ либо числовой код в кодировке Unicode, заключенным в одинарные кавычки.
Unicode – это набор символов, включающий символы латинского алфавита, символы национальных алфавитов, цифры, знаки препинания и специальные символы. Каждый символ набора Unicode имеет код из диапазона от 0 до 65535. Первые 128 символов Unicode совпадают с символами стандарной части таблицы ASCII.

char a = 'a';
char b = '\u0420';

String

Тип string является структурой данных, хранящей набор символов типа char. Этот тип немного отличается от всех остальных, мы о нем еще успеем много поговорить)
Строки указываются в двойных кавычках и обладают рядом свойств. Для сложения, конкатенации, строк можно использовать оператор +.

string h = "Hallo";
string w = "World" + h; // "Hallo World"

В строках можно указывать управляющие последовательности, например \n \t .

string a = "Hallo\nWorld";
/*
*Hallo
*World
*/

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

string path = @"C:\Users\artem\notSeriousSeeSharp\FirstProgram"

string name = "\"cool\" story"

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

Если по простому, то это штука, которая позволяет удобно форматировать строки и подставлять внутрь переменные и вычисляемые значения, которые в рантайме будут вычисляться и подставляться в строку)

Для определения строкового литерала в качестве интерполированной строки используется символ $ в начале строки.

Тут мы подставляем переменные name и years в последнюю строкку

Установка IDE

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

В связи с этим стоит использовать IDE (Integrated development environment) интегрированную среду разработки, которая бы включала в себя набор средств для автоматизации задачи сборки и компиляции кода, подсвечивала бы синтаксис, показывала бы возможные ошибки и предупреждения и прочие ништяки, ускоряющие процесс разработки.

Для написания кода на C# я использую Visual Studio от Microsoft и всем советую. Еще есть довольно популярная среда ReSharper от JetBrains, но лично мне не зашло и многие вещи в нем казались избыточными и отвлекающими, а подсказки от Intelsense в Visual Studio 2022 вполне сопоставимы с тем, что предлагает Rider в ReSharper. Поэтому покажу, как установить на Windows мою любимую визуалочку🥰 и создать первый проект.

Переходим на официальный сайт макрософт и качаем инсталятор с версией Community Edition.

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

Жмякаете по кнопке установить в нижнем правом углу и у вас начнется загрузка. После установки, при запуске Visual Studio откроется окно для выбора открытия проекта или его создания. Создаем!

Откроется окно для выбора типа проекта с возможностью отфильтровать ненужное. Выставляем С# и консольное приложение, останется два типа проекта. Помним, что .Net Framework ныне не поддерживается и оно тянется легасем, и там старая версия язык C# 8, что нам не нравится и поэтому выбираем модное .NET Core приложение.

Прописываем название проекта и каталог.

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

После этого Visual Studio создаст и откроет для нас проект

Слева находится "обозреватель решений", в котором находится структура проекта, через который мы можем добавить новые его составляющие, клацнув пкм по имени проекта. Для запуска проекта можно воспользоваться комбинацией клавиш ctrl + f5

И у вас наверняка сразу возникает вопрос, а что за фигня, где все то, про что ты нам втирал, где там эти намспайсы, классы методы?! Вон же, просто вывод в консоль, все запускается и работает! Это что получается, ты нас обманывал?!

На самом деле, нет) Для .NET 5 и более ранних версий шаблон приложения должен обязательно выглядеть как показывал я, с классом и точкой входа, функцией Main. А начиная с версии .NET 6 с C# 10, оба варианта допустимы.

При использовании .NET 6 необходимо только написать код метода Main, а компилятор самостоятельно сгенерирует класс Program с методом Main и поместит все команды верхнего уровня из Program.cs в этот Main метод. То есть все, что было сказано про обязательное наличие точки входа, метода Main, остается в силе)

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

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

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

Подписывайтесь на наш несерьезный тг-канал, ставьте ваши импортозамещенные славные классы)

Введение

2022-10-04T02:02:42.732Z

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

Машинный код, ассемблер

Каждый компьютер работает только со своим набором команд, машинным языком, определяемым его аппаратной архитектурой. Машинные языки обычно состоят из чисел, которые в конечном итоге представляются в виде последовательности цифр: 0 и 1. Люди привыкли обозначать выполняемые операции знаками и словами, поэтому числовые версии данных операций в машинном языке стали называться кодом. В наше время понятие программного кода используется в более широком смысле, сейчас им именуются программные инструкции в языках любого уровня хоть в высокоуровневых языках и используются обозначений команд знаки и слова.

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

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

Высокоуровневые языки

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

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

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

C# и .NET

В 2000 году компания Microsoft представила общественности язык программирования C# вместе с концепцией платформы .NET - концепция использования Интернета и веб-технологий в разработке, производстве, распространении и использовании программных продуктов. .NET по сути стал являться ультимативной платформой с большим разнообразием технологий для разработки различного рода приложений. .NET также позволяет создавать приложения на любом .NЕТ-совместимом языке (таком, как С#, Visual Basic, Visual С++).

Основой для исполнения программ платформы .NET является виртуальная машина CLR (Common Language Runtime). При компиляции код программы компилируется в сборку на промежуточном языке CIL (Common Intermediate Language), после чего подается для исполнения в CLR, а далее при запуске на выполнение подобного приложения происходит JIT-компиляция (Just-In-Time) в машинный код, который затем выполняется. Такое устройство .NET позволяет обеспечить перенос программы с одной платформы на другую при наличии на них данной виртуальной машины.

Также благодаря данной трансляции .NET не привязывает программистов к какому-то конкретному языку, а позволяет разрабатывать приложения на любом языке, совместимым с .NET (C#, VB.NET, Delphi.NET, F#). .NET содержит огромную общую для всех поддерживаемых языков библиотеку классов, которая используется в также предоставляемых ей ряде технологий, разрабатываемых Microsoft. Данные технологии предоставляют разработчикам-пользователям api-интерфейсы для работы с десктопными приложениями (WPF, UWP), веб-приложениями (ASP.NET), для разработки мобильных и кроссплатформенных решений (Xamarin, MAUI), для работы с базами данных (Entity Framework)...

Microsoft долгое время развивало платформу .NET исключительно под Windows без всякой кроссплатформенности под названием .NET Framework. В 2019 была выпущена последняя версия этой платформы - .NET Framework 4.8, и ее поддержка ныне прекращена. Все это потому, что в 2014-м году они начали развивать альтернативную платформу .NET Core, ориентированную уже на кроссплатформенность (ничего нового... Microsoft:). Последовательно были выпущены версии .NET Core 1, .NET Core 2, .NET Core 3, .NET 5. Последней текущей версией платформы является .NET 6 с версией языка C# 10.

Таким образом у Microsoft параллельно развивалось две версии платформы .Net Framework и .Net Core. При этом на .Net Framework у многих уже успело накопиться в проектах довольно жирный кусок легаси, который надо как-то перетаскивать на .Net Core, но платформы были сделаны несовместимыми друг с другом:) По этой причине Microsoft пришлось разработать .Net Standart - это интерфейс/спецификация всего того, что реализуют все платформы .Net, благодаря чему можно подключить библиотеку с .Net Framework к Core.

Вроде бы рассказал все основные моменты касательно того, что из себя в общих чертах представляет .NET и C#. Полную историю языка можете почитать на msdn. Ожидаем релиза .NET 7 c C# 11. В следующей статье распишу все про среду разработки, напишем первую программу и расскажу об основных ее компонентах. Подписывайтесь на наш телеграм-канал, а меня ждут санитары, всем пока!)