🤔 Все ли HTTP-методы идемпотентные?

Нет.
Вот классификация:
Идемпотентные:
- GET — многократный вызов не меняет состояние.
- PUT — задаёт конкретное состояние ресурса.
- DELETE — может быть вызван многократно с тем же результатом.
- HEAD, OPTIONS — тоже идемпотентны.
Неидемпотентные:
- POST — каждый вызов может создавать новый ресурс или изменять состояние (непредсказуемо).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое делегаты и зачем они нужны?

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

🚩Зачем они нужны?

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

🟠События
Являются основой системы событий. Они позволяют определять события и подписываться на них. Когда событие происходит, вызываются делегаты, связанные с этим событием, что позволяет реагировать на изменения или действия пользователя.

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

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

public delegate int Operation(int x, int y);

public class Calculator
{
    public int PerformOperation(int x, int y, Operation op)
    {
        return op(x, y);
    }
}

class Program
{
    static int Add(int x, int y)
    {
        return x + y;
    }

    static int Multiply(int x, int y)
    {
        return x * y;
    }

    static void Main()
    {
        Calculator calc = new Calculator();

        // Создание делегата для метода Add и вызов через метод PerformOperation
        Operation addOp = new Operation(Add);
        int result = calc.PerformOperation(5, 6, addOp);
        Console.WriteLine("Addition: " + result);

        // Создание делегата для метода Multiply и вызов через метод PerformOperation
        Operation mulOp = new Operation(Multiply);
        result = calc.PerformOperation(5, 6, mulOp);
        Console.WriteLine("Multiplication: " + result);
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Когда инициируется сборка мусора?

Сборка мусора в C# инициируется автоматически, когда система обнаруживает, что недостаточно доступной памяти или при достижении порогов работы сборщика. Также она может быть запущена вручную с помощью метода `GC.Collect()`. Garbage collector удаляет объекты, которые больше не используются программой, освобождая память. Сборка мусора помогает предотвратить утечки памяти и поддерживает эффективность приложения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какова концепция сборки мусора в С#?

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

🚩Основные концепции сборки мусора

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

🟠Корни (Roots)
Корни — это переменные и ссылки, которые являются начальными точками для сборки мусора. Они включают глобальные и статические переменные, локальные переменные в стеке, а также ссылки из регистров процессора.

🟠Алгоритм маркировки и сжатия (Mark-and-Compact)
GC использует алгоритм маркировки и сжатия для определения объектов, которые больше не используются. Сначала он помечает все доступные объекты (те, до которых можно добраться из корней), а затем удаляет все непомеченные объекты, освобождая их память.

🟠Поколения (Generations)
Память управляемой кучи разделена на три поколения: поколение 0, поколение 1 и поколение 2. Это позволяет оптимизировать процесс сборки мусора:
Поколение 0: Содержит новые объекты. Сборка мусора здесь происходит чаще всего, так как большинство объектов живут недолго.
Поколение 1: Содержит объекты, которые пережили одну сборку мусора.
Поколение 2: Содержит объекты, которые пережили несколько сборок мусора. Сборка мусора здесь происходит реже всего, так как такие объекты считаются долгоживущими.

🚩Этапы сборки мусора

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

🟠Маркировка (Mark)
GC проходит по всем корням и помечает все объекты, которые могут быть достигнуты.

🟠Удаление (Sweep)
После маркировки все непомеченные объекты считаются недоступными и могут быть удалены.

🟠Сжатие (Compact)
Для улучшения производительности и уменьшения фрагментации памяти, сборщик мусора может переместить оставшиеся объекты, чтобы освободить блоки памяти.

class Program
{
    static void Main()
    {
        for (int i = 0; i < 1000; i++)
        {
            CreateObject();
        }

        // Явный вызов сборщика мусора (не рекомендуется для обычного использования)
        GC.Collect();
    }

    static void CreateObject()
    {
        MyClass obj = new MyClass();
        // Объект obj будет собран сборщиком мусора, когда он больше не будет использоваться
    }
}

class MyClass
{
    // Поля и методы класса
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 В каком случае использовать интерфейс, в каком абстрактный класс?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как сейчас делается Singleton?

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

🟠Ленивый Singleton (Lazy Initialization)
Ленивый Singleton инициализируется при первом обращении. Это обеспечивает отложенную инициализацию объекта и гарантирует потокобезопасность.

public class Singleton
{
    private static readonly Lazy<Singleton> lazyInstance = new Lazy<Singleton>(() => new Singleton());

    public static Singleton Instance => lazyInstance.Value;

    private Singleton()
    {
        // Приватный конструктор
    }
}

🟠Потокобезопасный Singleton (Thread-safe)
Этот подход использует lock для обеспечения потокобезопасности при создании экземпляра.

public class Singleton
{
    private static Singleton instance;
    private static readonly object lockObj = new object();

    private Singleton()
    {
        // Приватный конструктор
    }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (lockObj)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

Eager Initialization (Инициализация при загрузке)
Экземпляр Singleton создается при загрузке класса. Это гарантирует потокобезопасность за счет особенностей инициализации статических переменных в .NET.

public class Singleton
{
    private static readonly Singleton instance = new Singleton();

    public static Singleton Instance => instance;

    private Singleton()
    {
        // Приватный конструктор
    }
}

🟠Static Constructor (Статический конструктор)
Использование статического конструктора для инициализации Singleton.

public class Singleton
{
    private static readonly Singleton instance;

    static Singleton()
    {
        instance = new Singleton();
    }

    public static Singleton Instance => instance;

    private Singleton()
    {
        // Приватный конструктор
    }
}

Singleton с внедрением зависимостей (Dependency Injection)
В современных приложениях, особенно с использованием ASP.NET Core, Singleton часто регистрируется в контейнере внедрения зависимостей.

public class SingletonService
{
    public void DoWork()
    {
        // Выполнение работы
    }
}

// Регистрация в контейнере служб
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton<SingletonService>();
}

// Использование в контроллере
public class MyController : ControllerBase
{
    private readonly SingletonService _singletonService;

    public MyController(SingletonService singletonService)
    {
        _singletonService = singletonService;
    }

    public IActionResult Index()
    {
        _singletonService.DoWork();
        return Ok();
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое принципы SOLID?

SOLID — это набор пяти принципов объектно-ориентированного программирования, которые помогают писать гибкий и поддерживаемый код. Принципы включают: Single Responsibility (одна ответственность), Open/Closed (открытость для расширения, закрытость для изменений), Liskov Substitution (подстановка Барбары Лисков), Interface Segregation (разделение интерфейсов) и Dependency Inversion (инверсия зависимостей). Эти принципы помогают избежать излишней сложности и улучшить структуру программного кода. Применение SOLID делает код более устойчивым к изменениям и легче в сопровождении.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое Rest?

REST (Representational State Transfer) — это архитектурный стиль разработки веб-сервисов, который стал основным методом создания веб-API. Этот стиль был введён Роем Филдингом в его докторской диссертации в 2000 году и основывается на принципах, используемых в протоколе HTTP.

🚩Основные принципы

🟠Client-Server
Архитектура строится на разделении клиента и сервера. Это разделение позволяет разрабатывать клиентскую и серверную части независимо друг от друга, что упрощает разработку и тестирование.

🟠Stateless
Каждый запрос от клиента к серверу должен содержать всю информацию, необходимую серверу для его понимания и выполнения. Сервер не должен хранить информацию о состоянии клиента между запросами. Если это необходимо, состояние следует хранить на клиенте.

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

🟠Uniform Interface
Важнейший из принципов REST — единый интерфейс, который упрощает и обобщает взаимодействие между клиентом и сервером. Этот интерфейс определяет стандартные методы и форматы обмена информацией, которые должны быть одинаковыми для всех ресурсов. Типичными методами являются GET, POST, PUT, DELETE.

🟠Layered System
Клиент не должен предполагать, что он напрямую соединён с сервером. Между ними может находиться несколько слоёв, таких как балансировщики нагрузки или кэширующие прокси.

🟠Code on Demand (optional)
Серверы могут временно расширять или настраивать функционал на клиентах, передавая им исполняемый код (например, JavaScript).

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем разница между асинхронностью и многопоточностью?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое builder паттерн?

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

🚩Основные цели и задачи паттерна

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

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

🟠Поддержка неизменяемых объектов
Может использоваться для создания неизменяемых объектов с большим количеством опций и параметров.

🚩Структура паттерна

🟠Builder
Определяет интерфейс для пошагового конструирования объекта.
🟠ConcreteBuilder
Реализует интерфейс Builder и создает конкретный продукт.
🟠Director
Управляет объектом Builder и задает алгоритм создания объекта.
🟠Product
Класс, представляющий создаваемый сложный объект.

🚩Пример использования паттерна Строитель

1⃣Определение продукта

public class House
{
    public string Walls { get; set; }
    public string Roof { get; set; }
    public string Foundation { get; set; }

    public override string ToString()
    {
        return $"House with {Walls}, {Roof} and {Foundation}";
    }
}

2⃣Определение интерфейса Builder

public interface IHouseBuilder
{
    void BuildFoundation();
    void BuildWalls();
    void BuildRoof();
    House GetHouse();
}

3⃣Реализация конкретного Builder

public class ConcreteHouseBuilder : IHouseBuilder
{
    private House _house = new House();

    public void BuildFoundation()
    {
        _house.Foundation = "Concrete Foundation";
    }

    public void BuildWalls()
    {
        _house.Walls = "Concrete Walls";
    }

    public void BuildRoof()
    {
        _house.Roof = "Concrete Roof";
    }

    public House GetHouse()
    {
        return _house;
    }
}

4⃣Определение Director

public class ConstructionDirector
{
    private readonly IHouseBuilder _builder;

    public ConstructionDirector(IHouseBuilder builder)
    {
        _builder = builder;
    }

    public void ConstructHouse()
    {
        _builder.BuildFoundation();
        _builder.BuildWalls();
        _builder.BuildRoof();
    }
}

5⃣Использование паттерна Строитель

public class Program
{
    public static void Main()
    {
        IHouseBuilder builder = new ConcreteHouseBuilder();
        ConstructionDirector director = new ConstructionDirector(builder);

        director.ConstructHouse();
        House house = builder.GetHouse();

        Console.WriteLine(house); // Output: House with Concrete Walls, Concrete Roof and Concrete Foundation
    }
}

🚩Плюсы

➕Контроль процесса создания
Позволяет контролировать процесс создания сложных объектов поэтапно.
➕Гибкость
Разделение конструирования и представления позволяет использовать один и тот же процесс для создания различных объектов.
➕Читаемость кода
Код становится более читаемым и поддерживаемым, так как процесс создания объекта инкапсулирован в отдельный класс.
➕Поддержка сложных объектов
Упрощает создание объектов с множеством параметров и сложной иерархией.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Может ли абстрактный метод быть вне абстрактного класса?

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 В чём разница абстрактного класса и интерфейса?

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

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

public abstract class Животное
{
    public abstract void Есть(); // Абстрактный метод, должен быть реализован в наследнике.

    public void Дышать() // Метод с реализацией, наследуется всеми наследниками.
    {
        Console.WriteLine("Дыхание");
    }
}

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

public interface IЖивотное
{
    void Есть(); // Метод, который должен быть реализован в классе.
}

🚩Основные различия

🟠Наследование
Класс может наследовать только от одного абстрактного класса (из-за ограничения одиночного наследования в C#), но может реализовывать множество интерфейсов.
🟠Члены
Абстрактные классы могут содержать реализацию методов и поля данных, в то время как интерфейсы могут содержать только объявления методов и свойств (без полей и реализации).
🟠Конструкторы и деструкторы
Абстрактные классы могут иметь конструкторы и деструкторы, в то время как интерфейсы - нет.
🟠Модификаторы доступа
В интерфейсах все члены по умолчанию являются public, и вы не можете указать другой модификатор доступа. В абстрактных классах вы можете использовать различные модификаторы доступа.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие API можно назвать REST-овыми?

REST API используют HTTP-методы (GET, POST, PUT, DELETE) и ресурсы, представленные через URL, с архитектурными принципами простоты и масштабируемости.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что делает new 'имя объекта'()?

Оператор new в C# создаёт новый экземпляр объекта и выделяет для него память в куче (Heap) или стеке (Stack), в зависимости от типа.

🚩Как работает `new`?

Для классов (class) – выделяет память в куче (Heap) и возвращает ссылку на объект.
Для структур (struct) – если структура создаётся без new, её поля остаются неинициализированными, но если использовать new, она получает значения по умолчанию.
Для массивов (T[]) – выделяет память в куче, даже если T – это struct.
Для делегатов – создаёт экземпляр делегата.

Пример: new с классом (class)

class Person
{
    public string Name;

    public Person(string name)
    {
        Name = name;
    }
}

class Program
{
    static void Main()
    {
        Person p1 = new Person("Alice"); // Создаём новый объект в куче
        Console.WriteLine(p1.Name); // Alice
    }
}

Пример: new со структурой (struct)

struct Point
{
    public int X;
    public int Y;

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
}

class Program
{
    static void Main()
    {
        Point p1 = new Point(5, 10); // Создаёт структуру в стеке
        Console.WriteLine(p1.X); // 5
    }
}

Пример: new с массивом

int[] numbers = new int[5]; // Создаёт массив в куче
numbers[0] = 10;
Console.WriteLine(numbers[0]); // 10

🚩Что делает `new` за кулисами?

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

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём заключается реализация паттерна абстрактной фабрики

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

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое исключения?

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

🚩Основные понятия

🟠Исключение (Exception)
Событие, которое прерывает нормальный поток выполнения программы.
🟠Блок try
Содержит код, который может вызвать исключение.
🟠Блок catch
Содержит код, который выполняется, если возникает исключение. В catch блок можно передать параметр — экземпляр исключения, которое произошло.
🟠Блок finally
Содержит код, который выполняется в любом случае, независимо от того, произошло исключение или нет. Обычно используется для освобождения ресурсов.
🟠Бросание исключения (throw)
Механизм для явного вызова исключения.

🚩Пример использования

Основные блоки

try
{
    // Код, который может вызвать исключение
    int divisor = 0;
    int result = 10 / divisor;
}
catch (DivideByZeroException ex)
{
    // Обработка исключения
    Console.WriteLine("Деление на ноль невозможно.");
}
finally
{
    // Код, который выполнится в любом случае
    Console.WriteLine("Блок finally выполнен.");
}

Создание и бросание собственного исключения

public class InvalidAgeException : Exception
{
    public InvalidAgeException(string message) : base(message) { }
}

public void SetAge(int age)
{
    if (age < 0)
    {
        throw new InvalidAgeException("Возраст не может быть отрицательным.");
    }
    // Логика установки возраста
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 Зачем нужны поколения для сборщика мусора?

В .NET сборщик мусора использует поколения для оптимизации управления памятью. Объекты классифицируются по поколениям (0, 1 и 2), где молодые объекты в поколении 0 собираются чаще. Объекты, которые переживают сборку, перемещаются в старшее поколение, что уменьшает количество проверок этих объектов и улучшает производительность приложения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

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

Ты говоришь про объекты в нулевом поколении (Generation 0) в сборщике мусора (Garbage Collector, GC) в .NET? Если да, то это очень хорошая тема!

🚩Что значит "жить в нулевом поколении"?

🟠Gen 0 (нулевое поколение)
самые молодые объекты. Это временные, краткоживущие данные, которые часто быстро удаляются.
🟠Gen 1 (первое поколение)
промежуточное поколение. Объекты, пережившие хотя бы одну очистку Gen 0.
🟠Gen 2 (второе поколение)
долгоживущие объекты. Обычно это крупные структуры данных, которые редко изменяются.

🚩Почему нулевое поколение важно?

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

Если объект долго живет, он "повышается" в следующее поколение (Gen 1, затем Gen 2). GC чаще очищает Gen 0, а Gen 2 – реже, так как там хранятся важные данные, которые не стоит часто перемещать.

🚩Надолго ли объект остается в Gen 0?

Очень недолго! Вся идея Gen 0 в том, чтобы быстро выделять и быстро освобождать память. Если объект не используется после первой очистки GC, он удаляется. Если объект нужен дальше – он переходит в Gen 1.

class Program
{
    static void Main()
    {
        for (int i = 0; i < 1000; i++)
        {
            var obj = new object(); // Создаем объект в Gen 0
        } // obj выходит из области видимости и уничтожается GC
    }
}

Здесь объекты быстро уничтожаются в Gen 0, так как они больше не нужны.

А если объект нужен долго:

class Program
{
    static object _longLivingObject = new object(); // Скорее всего, попадет в Gen 2

    static void Main()
    {
        Console.WriteLine("Объект долго живёт!");
    }
}

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чём разница в загрузке данных между жадной, ленивой и явной?

- Жадная (Eager) загрузка — данные загружаются вместе с основным объектом сразу, обычно через Include. Это снижает количество запросов, но может привести к избытку данных.
- Ленивая (Lazy) загрузка — связанные данные подгружаются только при первом доступе к ним. Это удобно, но требует осторожности (можно случайно вызвать лишние запросы).
- Явная (Explicit) загрузка — данные подгружаются вручную при необходимости, через отдельный вызов. Такой подход даёт полный контроль, но требует больше кода.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Если в двух переменных хранится одинаковое значение, то будут ли они равны?

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

🟠Примитивные типы (Value Types)
Для примитивных типов (например, int, float, char, bool) значение хранятся непосредственно в переменных, и их сравнение выполняется по значению.

int a = 5;
int b = 5;

bool areEqual = (a == b); // True

🟠Ссылочные типы (Reference Types)
Для ссылочных типов (например, классы, строки) переменные содержат ссылки на объекты в куче. Сравнение ссылочных типов по умолчанию выполняется по ссылке, а не по значению.

class Person
{
    public string Name { get; set; }
}

Person person1 = new Person { Name = "Alice" };
Person person2 = new Person { Name = "Alice" };

bool areEqual = (person1 == person2); // False, потому что сравниваются ссылки

🟠Строки (Strings)
Строки являются ссылочными типами, но переопределяют операторы сравнения == и Equals для сравнения по значению.

string str1 = "Hello";
string str2 = "Hello";

bool areEqual = (str1 == str2); // True, строки сравниваются по значению

🟠Кастомные классы
Для кастомных классов можно переопределить методы Equals и GetHashCode, чтобы сравнивать объекты по значению.

class Person
{
    public string Name { get; set; }

    public override bool Equals(object obj)
    {
        if (obj == null || GetType() != obj.GetType())
            return false;

        Person other = (Person)obj;
        return Name == other.Name;
    }

    public override int GetHashCode()
    {
        return Name.GetHashCode();
    }
}

Person person1 = new Person { Name = "Alice" };
Person person2 = new Person { Name = "Alice" };

bool areEqual = person1.Equals(person2); // True

Ставь 👍 и забирай 📚 Базу знаний