🤔 Что такое Swagger?

Swagger (теперь часть OpenAPI):
- Это инструмент для документирования REST API.
- Позволяет:
- описывать API в формате JSON/YAML;
- автоматически генерировать документацию;
- предоставлять интерактивный UI, где можно тестировать запросы.
- Интеграция с .NET происходит через Swashbuckle.AspNetCore или NSwag.

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

🤔 Что такое hashset?

HashSet<T> — это коллекция уникальных элементов, которая обеспечивает быстрый поиск, добавление и удаление. В основе HashSet<T> лежит хеш-таблица, что делает операции очень быстрыми (почти за O(1) в среднем случае).

🚩Создание и использование `HashSet<T>`

Простой пример

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

// Добавление элементов (дубликаты не добавляются)
numbers.Add(3);  // Уже есть в HashSet, не добавится
numbers.Add(6);  // Добавится

// Вывод всех элементов
foreach (int num in numbers)
{
    Console.Write(num + " ");
}

Вывод

1 2 3 4 5 6

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

Пример работы с Contains и Remove

if (numbers.Contains(3))
{
    numbers.Remove(3);
}

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

Вывод

1, 2, 4, 5, 6

🚩Операции над множествами

HashSet<T> поддерживает математические операции над множествами, такие как пересечение, объединение и разность.

Пересечение (IntersectWith)

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

set1.IntersectWith(set2); // Оставит только {3, 4}
Console.WriteLine(string.Join(", ", set1));

Вывод

3, 4

Объединение (UnionWith)

set1 = new HashSet<int> { 1, 2, 3 };
set2 = new HashSet<int> { 3, 4, 5 };

set1.UnionWith(set2); // set1 = {1, 2, 3, 4, 5}
Console.WriteLine(string.Join(", ", set1));

Вывод

1, 2, 3, 4, 5

Разность (ExceptWith)

set1 = new HashSet<int> { 1, 2, 3, 4, 5 };
set2 = new HashSet<int> { 3, 4 };

set1.ExceptWith(set2); // Удалит {3, 4}, останется {1, 2, 5}
Console.WriteLine(string.Join(", ", set1));

Вывод

1, 2, 5

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

🤔 Зачем нужны интерфейсы, если есть абстрактные классы?

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

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

🤔 Расскажи про конкурентные коллекции?

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

🟠ConcurrentDictionary<TKey, TValue>
Это словарь, который позволяет безопасно добавлять, удалять и изменять элементы из нескольких потоков одновременно. Он реализует интерфейс IDictionary<TKey, TValue>.

var concurrentDictionary = new ConcurrentDictionary<int, string>();
concurrentDictionary.TryAdd(1, "value1");
concurrentDictionary.TryAdd(2, "value2");

string value;
if (concurrentDictionary.TryGetValue(1, out value))
{
    Console.WriteLine(value);  // Output: value1
}

🟠ConcurrentQueue<T>
Это очередь, которая обеспечивает безопасное добавление элементов в конец и извлечение из начала в многопоточной среде. Она реализует интерфейс IProducerConsumerCollection<T>.

var concurrentQueue = new ConcurrentQueue<int>();
concurrentQueue.Enqueue(1);
concurrentQueue.Enqueue(2);

int result;
if (concurrentQueue.TryDequeue(out result))
{
    Console.WriteLine(result);  // Output: 1
}

🟠ConcurrentStack<T>
Это стек, который обеспечивает безопасное добавление и извлечение элементов в многопоточной среде. Он также реализует интерфейс IProducerConsumerCollection<T>.

var concurrentStack = new ConcurrentStack<int>();
concurrentStack.Push(1);
concurrentStack.Push(2);

int result;
if (concurrentStack.TryPop(out result))
{
    Console.WriteLine(result);  // Output: 2
}

🟠ConcurrentBag<T>
Это коллекция, которая позволяет безопасно добавлять и извлекать элементы в многопоточной среде. Она не гарантирует порядок элементов, поэтому используется в случаях, когда порядок не имеет значения.

var concurrentBag = new ConcurrentBag<int>();
concurrentBag.Add(1);
concurrentBag.Add(2);

int result;
if (concurrentBag.TryTake(out result))
{
    Console.WriteLine(result);  // Output: 1 или 2
}

🟠BlockingCollection<T>
Это коллекция, которая поддерживает ограниченную емкость и блокировку потоков при добавлении или извлечении элементов. Она особенно полезна для реализации паттернов продюсер-потребитель.

var blockingCollection = new BlockingCollection<int>(boundedCapacity: 5);
Task.Run(() =>
{
    for (int i = 0; i < 10; i++)
    {
        blockingCollection.Add(i);
        Console.WriteLine($"Added {i}");
    }
    blockingCollection.CompleteAdding();
});

foreach (var item in blockingCollection.GetConsumingEnumerable())
{
    Console.WriteLine($"Consumed {item}");
}

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

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

Да, можно. В C# для ограничения (ограничений) обобщённых типов используется ключевое слово where.
Примеры ограничений:
- where T : class — только ссылочные типы.
- where T : struct — только значимые типы.
- where T : new() — должен иметь публичный конструктор без параметров.
- where T : BaseClass — должен быть наследником BaseClass.
- where T : interfaceName — должен реализовывать указанный интерфейс.

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

🤔 Что в себе может хранить делегат?

Делегат (delegate) — это указатель на метод(ы). Он может хранить:
1. Ссылку на один метод (одиночный делегат)
2. Ссылки на несколько методов (групповой делегат / multicast)
3. Анонимные методы и лямбда-выражения

🚩Делегат хранит ссылку на метод

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

public delegate void MyDelegate(string message); // Объявляем делегат

public class Program
{
    public static void ShowMessage(string msg) => Console.WriteLine($"Сообщение: {msg}");

    public static void Main()
    {
        MyDelegate del = ShowMessage; // Делегат хранит ссылку на метод
        del("Привет, делегаты!"); // Вызывает ShowMessage
    }
}

🚩Делегат может хранить несколько методов (Multicast)

Делегаты можно связывать с несколькими методами с помощью +=. Пример группового делегата

public delegate void MyDelegate(string message);

public class Program
{
    public static void Method1(string msg) => Console.WriteLine($"Метод 1: {msg}");
    public static void Method2(string msg) => Console.WriteLine($"Метод 2: {msg}");

    public static void Main()
    {
        MyDelegate del = Method1;
        del += Method2; // Добавляем второй метод

        del("Привет!"); 
        // Выведет:
        // Метод 1: Привет!
        // Метод 2: Привет!
    }
}

🚩Делегат может хранить анонимные методы и лямбды

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

MyDelegate del = delegate (string msg) 
{
    Console.WriteLine($"Анонимный метод: {msg}");
};
del("Привет!");

Пример с лямбда-выражением

MyDelegate del = msg => Console.WriteLine($"Лямбда: {msg}");
del("Привет!");

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

🤔 Какова цель ключевого слова lock?

lock используется для синхронизации доступа к разделяемым ресурсам в многопоточном коде. Он:
- Гарантирует, что только один поток войдёт в критическую секцию кода.
- Блокирует объект (монитор), пока другой поток не освободит его.
Это предотвращает состояние гонки и обеспечивает корректную работу с общей памятью.

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

🤔 Что такое инверсия зависимостей?

Инверсия зависимостей — это принцип SOLID, который говорит:
> Модули верхнего уровня не должны зависеть от модулей нижнего уровня. Оба должны зависеть от абстракций.

Это значит, что вместо жёстких зависимостей на конкретные классы, код должен работать через абстракции (interface или abstract class).

🚩Проблема без инверсии зависимостей
Допустим, у нас есть класс EmailSender, который отправляет письма:

public class EmailSender
{
    public void Send(string message)
    {
        Console.WriteLine($"Отправка email: {message}");
    }
}

public class NotificationService
{
    private EmailSender _emailSender = new EmailSender();

    public void Notify(string message)
    {
        _emailSender.Send(message);
    }
}

🚩Решение: Инверсия зависимостей

Чтобы избавиться от жёсткой зависимости, вводим абстракцию (IMessageSender):

public interface IMessageSender
{
    void Send(string message);
}

public class EmailSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine($"Отправка email: {message}");
    }
}

public class SmsSender : IMessageSender
{
    public void Send(string message)
    {
        Console.WriteLine($"Отправка SMS: {message}");
    }
}

Теперь NotificationService зависит не от конкретного класса, а от интерфейса:

public class NotificationService
{
    private readonly IMessageSender _messageSender;

    public NotificationService(IMessageSender messageSender)
    {
        _messageSender = messageSender;
    }

    public void Notify(string message)
    {
        _messageSender.Send(message);
    }
}

Теперь мы можем подставлять любую реализацию IMessageSender:

var emailNotifier = new NotificationService(new EmailSender());
emailNotifier.Notify("Привет через Email!");

var smsNotifier = new NotificationService(new SmsSender());
smsNotifier.Notify("Привет через SMS!");

Вывод

Отправка email: Привет через Email!
Отправка SMS: Привет через SMS!

🚩Преимущества инверсии зависимостей

Гибкость – можно легко заменять зависимости.
Тестируемость – можно подставить Mock-объект вместо EmailSender.
Меньше изменений в коде – можно добавить новые способы отправки сообщений без изменения NotificationService.

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

🔥 Записал видос "Как за 3 минуты настроить Автоотклики на вакансии HeadHunter" больше не придется заниматься этой унылой рутиной

📺 Видео: https://youtu.be/G_FOwEGPwlw

🤔 Что делать, если есть два интерфейса с одинаковым названием?

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

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