📌 Что такое сервис локатор?

💬 Спрашивают в 33% собеседований

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

🤔 Ключевые характеристики

1️⃣ Централизованный реестр сервисов:

Сервис локатор содержит реестр всех доступных сервисов. Каждый сервис ассоциируется с уникальным ключом или идентификатором.

2️⃣ Получение сервиса по требованию:

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

3️⃣ Управление зависимостями:

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

🤔 Пример:

public interface IService
{
    void Execute();
}

public class ServiceLocator
{
    private IDictionary<object, IService> services;

    public ServiceLocator()
    {
        services = new Dictionary<object, IService>();
    }

    public void RegisterService<T>(IService service)
    {
        services.Add(typeof(T), service);
    }

    public IService GetService<T>()
    {
        return services[typeof(T)];
    }
}

public class ConcreteService : IService
{
    public void Execute()
    {
        Console.WriteLine("Service Executed");
    }
}

class Program
{
    static void Main()
    {
        ServiceLocator locator = new ServiceLocator();
        locator.RegisterService<IService>(new ConcreteService());

        IService service = locator.GetService<IService>();
        service.Execute();  // Output: Service Executed
    }
}

🤔 Преимущества:

➕Гибкость:

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

➕Универсальность:

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

🤔 Недостатки:

➕ Скрытая связанность:

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

➕ Сложность управления:

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

🤔 Краткий ответ:

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое лямбда выражения в С#?

💬 Спрашивают в 56% собеседований

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

🤔 Основной синтаксис лямбда-выражения:

параметры => выражение

Где => называется лямбда оператором, который можно прочесть как "переходит к".

🤔 Пример без параметров:

() => Console.WriteLine("Привет, мир!");

🤔 Пример с одним параметром:

x => x * x; // Возвращает квадрат x

🤔 Пример с несколькими параметрами:

(x, y) => x + y; // Складывает x и y

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

Лямбда-выражения особенно полезны в LINQ (Language Integrated Query), где они используются для создания кратких и выразительных запросов к данным. Например, чтобы выбрать все положительные числа из списка, можно использовать лямбда-выражение следующим образом:

List<int> числа = new List<int> { -1, 0, 1, 2, 3, 4, 5 };
var положительныеЧисла = числа.Where(x => x > 0).ToList();

foreach (var число in положительныеЧисла)
{
    Console.WriteLine(число);
}

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

🤔 Краткий ответ:

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое middleware в ASP.NET core?

💬 Спрашивают в 67% собеседований

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

🤔 Как он работает?

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

Middleware конфигурируется в методе Configure класса Startup. Порядок, в котором компоненты middleware добавляются в конвейер с помощью метода Use..., определяет порядок их выполнения при обработке запроса и ответа.

🤔 Пример:

public class MyMiddleware
{
    private readonly RequestDelegate _next;

    public MyMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // До вызова следующего компонента в конвейере
        Console.WriteLine("Before");

        await _next(context); // Передача управления следующему middleware

        // После возвращения управления от следующих компонентов
        Console.WriteLine("After");
    }
}

// Регистрация middleware в Startup.cs
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseMiddleware<MyMiddleware>();
    // Другие компоненты middleware
}

Middleware часто используют для следующих задач:

➕Аутентификация и авторизация:

проверка пользовательских данных и определение прав доступа.

➕Логирование:

запись информации о запросах и ответах для последующего анализа.

➕Обработка ошибок:

централизованная обработка исключений и формирование соответствующих ответов клиенту.

➕Управление сессиями и куками:

поддержка пользовательских сессий и управление куками.

➕Статические файлы:

обработка запросов к статическим файлам, таким как HTML, CSS, изображения.

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

🤔 Краткий ответ:

Middleware в ASP.NET Core — это компоненты, которые работают с каждым запросом и ответом в приложении, формируя конвейер для обработки HTTP-сообщений. Они позволяют добавлять нужную функциональность, например, для логирования, аутентификации или обработки ошибок, делая приложение модульным и легко поддерживаемым.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое делегат?

💬 Спрашивают в 78% собеседований

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

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

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

🤔 Пример:

// Определение делегата
public delegate int Operation(int x, int y);

class Program
{
    static void Main(string[] args)
    {
        // Создание экземпляра делегата, ссылающегося на метод Add
        Operation op = Add;

        // Вызов метода через делегат
        int result = op(5, 5);
        Console.WriteLine(result); // Вывод: 10

        // Делегат теперь ссылается на метод Subtract
        op = Subtract;

        // Повторный вызов метода через делегат
        result = op(10, 5);
        Console.WriteLine(result); // Вывод: 5
    }

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

    static int Subtract(int x, int y)
    {
        return x - y;
    }
}

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

🤔 Краткий ответ:

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

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

💬 Спрашивают в 78% собеседований

🤔 Принципы SOLID — это набор из пяти основных принципов ООП и проектирования, направленных на повышение гибкости, поддерживаемости и масштабируемости программного обеспечения. Эти принципы помогают разработчикам предотвращать проблемы, связанные с плохим проектированием, такие как жесткая связанность компонентов, слабая коэзия и чрезмерная сложность системы. Они были введены Робертом Мартином и являются акронимом, образованным от первых букв названий этих принципов:

1️⃣ Single Responsibility Principle (Принцип единственной ответственности):

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

2️⃣ Open/Closed Principle (Принцип открытости/закрытости):

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

3️⃣ Liskov Substitution Principle (Принцип подстановки Барбары Лисков):

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

4️⃣ Interface Segregation Principle (Принцип разделения интерфейса):

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

5️⃣ Dependency Inversion Principle (Принцип инверсии зависимостей):

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

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

🤔 Краткий ответ:

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Какие бывают коллекции?

💬 Спрашивают в 11% собеседований

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

🤔 Основные категории коллекций

1️⃣ Коллекции общего назначения

2️⃣ Специализированные коллекции

3️⃣ Параллельные коллекции

🤔 Коллекции общего назначения

1️⃣ List<T>: Динамический массив, который автоматически изменяет свой размер по мере добавления элементов.

   List<int> numbers = new List<int> { 1, 2, 3, 4 };
   numbers.Add(5);
   

2️⃣ Dictionary<TKey, TValue>: Коллекция пар ключ-значение. Обеспечивает быстрый доступ к значению по ключу.

   Dictionary<string, int> ages = new Dictionary<string, int>
   {
       { "Alice", 30 },
       { "Bob", 25 }
   };
   int aliceAge = ages["Alice"];
   

3️⃣ HashSet<T>: Коллекция уникальных элементов. Используется для предотвращения дублирования.

   HashSet<string> fruits = new HashSet<string> { "Apple", "Banana" };
   fruits.Add("Apple"); // Не добавит дубликат
   

4️⃣ Queue<T>: Очередь, работающая по принципу FIFO (First In, First Out).

   Queue<string> queue = new Queue<string>();
   queue.Enqueue("first");
   queue.Enqueue("second");
   string item = queue.Dequeue(); // "first"
   

5️⃣ Stack<T>: Стек, работающий по принципу LIFO (Last In, First Out).

   Stack<string> stack = new Stack<string>();
   stack.Push("first");
   stack.Push("second");
   string item = stack.Pop(); // "second"
   

🤔 Специализированные коллекции

1️⃣ LinkedList<T>: Двусвязный список, позволяющий быстро вставлять и удалять элементы.

   LinkedList<int> linkedList = new LinkedList<int>();
   linkedList.AddLast(1);
   linkedList.AddLast(2);
   

2️⃣ SortedList<TKey, TValue>: Коллекция пар ключ-значение, отсортированная по ключам.

   SortedList<string, int> sortedList = new SortedList<string, int>
   {
       { "Alice", 30 },
       { "Bob", 25 }
   };
   

3️⃣ SortedDictionary<TKey, TValue>: Похож на SortedList, но использует бинарное дерево для хранения элементов.

   SortedDictionary<string, int> sortedDict = new SortedDictionary<string, int>
   {
       { "Alice", 30 },
       { "Bob", 25 }
   };
   

4️⃣ SortedSet<T>: Отсортированное множество уникальных элементов.

   SortedSet<int> sortedSet = new SortedSet<int> { 3, 1, 2 };
   

🤔 Параллельные коллекции

1️⃣ ConcurrentDictionary<TKey, TValue>: Параллельная версия Dictionary, предназначенная для безопасного использования в многопоточных приложениях.

   ConcurrentDictionary<string, int> concurrentDict = new ConcurrentDictionary<string, int>();
   concurrentDict.TryAdd("Alice", 30);
   

2️⃣ ConcurrentQueue<T>: Параллельная версия Queue.

   ConcurrentQueue<string> concurrentQueue = new ConcurrentQueue<string>();
   concurrentQueue.Enqueue("first");
   

3️⃣ ConcurrentStack<T>: Параллельная версия Stack.

   ConcurrentStack<string> concurrentStack = new ConcurrentStack<string>();
   concurrentStack.Push("first");
   

4️⃣ BlockingCollection<T>: Коллекция, поддерживающая операции добавления и извлечения с блокировкой и ограничением по емкости.

   BlockingCollection<int> blockingCollection = new BlockingCollection<int>(5);
   blockingCollection.Add(1);
   

🤔 Краткий ответ

В C# есть множество коллекций для различных целей, включая List, Dictionary, HashSet, Queue, Stack, специализированные коллекции, такие как LinkedList, SortedList, и параллельные коллекции, такие как ConcurrentDictionary и BlockingCollection. Каждая коллекция имеет свои особенности и предназначена для определенных сценариев использования.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

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

💬 Спрашивают в 11% собеседований

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

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

1️⃣ Исключение (Exception): Событие, которое прерывает нормальный поток выполнения программы.

2️⃣ Блок try: Содержит код, который может вызвать исключение.

3️⃣ Блок catch: Содержит код, который выполняется, если возникает исключение. В catch блок можно передать параметр — экземпляр исключения, которое произошло.

4️⃣ Блок finally: Содержит код, который выполняется в любом случае, независимо от того, произошло исключение или нет. Обычно используется для освобождения ресурсов.

5️⃣ Бросание исключения (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("Возраст не может быть отрицательным.");
    }
    // Логика установки возраста
}

🤔 Краткий ответ

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое параллелизм?

💬 Спрашивают в 11% собеседований

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

🤔 Основные концепции параллелизма

1️⃣ Параллельное выполнение (Parallel Execution): Одновременное выполнение нескольких задач на разных процессорных ядрах.

2️⃣ Потоки (Threads): Наименьшие единицы выполнения, которые могут быть параллельно выполнены.

3️⃣ Задачи (Tasks): Абстракция над потоками, позволяющая проще управлять параллельными операциями.

4️⃣ Асинхронное программирование (Asynchronous Programming): Выполнение операций без блокировки основного потока, часто используется в сочетании с параллелизмом.

🤔 Пример использования параллелизма в C#

🤔 С использованием `Parallel.For`

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        Parallel.For(0, 10, i =>
        {
            Console.WriteLine($"Task {i} is running on thread {Task.CurrentId}");
        });
    }
}

🤔 С использованием `Task.Run`

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var task1 = Task.Run(() => DoWork("Task 1"));
        var task2 = Task.Run(() => DoWork("Task 2"));
        
        await Task.WhenAll(task1, task2);
    }

    static void DoWork(string taskName)
    {
        Console.WriteLine($"{taskName} is running on thread {Task.CurrentId}");
    }
}

🤔 Основные библиотеки и пространства имен в C#

1️⃣ System.Threading.Tasks: Основное пространство имен для работы с задачами (Task) и параллельным выполнением.

2️⃣ System.Threading: Предоставляет классы и интерфейсы для работы с потоками и задачами низкого уровня.

3️⃣ Parallel LINQ (PLINQ): Расширение LINQ для параллельного выполнения запросов.

🤔 Преимущества параллелизма

1️⃣ Ускорение выполнения задач: Позволяет значительно уменьшить время выполнения вычислительно интенсивных задач.

2️⃣ Эффективное использование ресурсов: Максимально использует мощности многоядерных процессоров.

3️⃣ Масштабируемость: Обеспечивает более плавную работу приложений при увеличении нагрузки.

🤔 Краткий ответ

Параллелизм — это метод одновременного выполнения нескольких задач для ускорения процессов и эффективного использования ресурсов компьютера. В C# это реализуется через Parallel и Task классы, позволяя выполнять задачи на разных процессорных ядрах одновременно.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое асинхронное программирование?

💬 Спрашивают в 11% собеседований

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

🤔 Основные концепции

1️⃣ Асинхронные методы: Методы, которые выполняются асинхронно, часто обозначаются ключевыми словами async и await в C#.

2️⃣ Task: Основная единица работы в асинхронном программировании в C#. Объект Task представляет собой операцию, которая может выполняться асинхронно.

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

4️⃣ I/O Bound: Операции, которые зависят от ввода-вывода и обычно требуют времени ожидания (например, сетевые запросы, чтение/запись файлов).

5️⃣ CPU Bound: Операции, которые требуют значительных вычислительных ресурсов процессора.

🤔 Преимущества асинхронного программирования

1️⃣ Повышенная производительность: Основной поток не блокируется при выполнении длительных операций.

2️⃣ Отзывчивость интерфейса: Приложения остаются отзывчивыми, даже при выполнении длительных операций.

3️⃣ Лучшее использование ресурсов: Асинхронные операции позволяют более эффективно использовать ресурсы системы.

🤔 Пример асинхронного программирования в C#

🤔 Асинхронный метод

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string url = "https://api.example.com/data";
        string result = await FetchDataAsync(url);
        Console.WriteLine(result);
    }

    static async Task<string> FetchDataAsync(string url)
    {
        using (HttpClient client = new HttpClient())
        {
            HttpResponseMessage response = await client.GetAsync(url);
            response.EnsureSuccessStatusCode();
            string responseBody = await response.Content.ReadAsStringAsync();
            return responseBody;
        }
    }
}

🤔 Объяснение кода

1️⃣ async: Ключевое слово, которое указывает, что метод является асинхронным. Методы Main и FetchDataAsync объявлены с async.

2️⃣ await: Оператор, который приостанавливает выполнение метода до завершения асинхронной операции. В методе FetchDataAsync await используется для ожидания завершения операций GetAsync и ReadAsStringAsync.

3️⃣ Task: Возвращаемый тип метода FetchDataAsync, представляющий асинхронную операцию, которая возвращает строку.

🤔 Асинхронное программирование с Task и Task<T>

🤔 Пример с Task

static async Task Main(string[] args)
{
    await Task.Run(() => DoWork());
}

static void DoWork()
{
    // Выполнение длительной операции
    Console.WriteLine("Работа выполнена.");
}

🤔 Асинхронное программирование с I/O Bound операциями

🤔 Пример с чтением файла

using System;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string filePath = "example.txt";
        string content = await ReadFileAsync(filePath);
        Console.WriteLine(content);
    }

    static async Task<string> ReadFileAsync(string filePath)
    {
        using (StreamReader reader = new StreamReader(filePath))
        {
            return await reader.ReadToEndAsync();
        }
    }
}

🤔 Краткий ответ

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

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых

📌 Что такое паттерны проектирования?

💬 Спрашивают в 11% собеседований

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

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

1️⃣ Порождающие паттерны (Creational Patterns): Эти паттерны связаны с созданием объектов, что позволяет скрыть сложность создания объектов и повысить гибкость системы.

➕ Примеры: Singleton, Factory Method, Abstract Factory, Builder, Prototype.

2️⃣ Структурные паттерны (Structural Patterns): Эти паттерны описывают, как классы и объекты могут быть объединены для формирования больших структур.

➕ Примеры: Adapter, Composite, Proxy, Flyweight, Facade, Bridge, Decorator.

🤔 Примеры паттернов проектирования

🤔 Singleton (Порождающий паттерн)

Обеспечивает создание единственного экземпляра класса и предоставляет глобальную точку доступа к этому экземпляру.

public class Singleton
{
    private static Singleton instance;

    private Singleton() { }

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

🤔 Factory Method (Порождающий паттерн)

Определяет интерфейс для создания объекта, но позволяет подклассам изменить тип создаваемого объекта.

public abstract class Product { }

public class ConcreteProductA : Product { }

public class ConcreteProductB : Product { }

public abstract class Creator
{
    public abstract Product FactoryMethod();
}

public class ConcreteCreatorA : Creator
{
    public override Product FactoryMethod()
    {
        return new ConcreteProductA();
    }
}

public class ConcreteCreatorB : Creator
{
    public override Product FactoryMethod()
    {
        return new ConcreteProductB();
    }
}

🤔 Adapter (Структурный паттерн)

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

public interface ITarget
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Specific request");
    }
}

public class Adapter : ITarget
{
    private readonly Adaptee _adaptee;

    public Adapter(Adaptee adaptee)
    {
        _adaptee = adaptee;
    }

    public void Request()
    {
        _adaptee.SpecificRequest();
    }
}

🤔 Observer (Поведенческий паттерн)

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

public interface IObserver
{
    void Update();
}

public class ConcreteObserver : IObserver
{
    public void Update()
    {
        Console.WriteLine("Observer updated");
    }
}

public class Subject
{
    private readonly List<IObserver> observers = new List<IObserver>();

    public void Attach(IObserver observer)
    {
        observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in observers)
        {
            observer.Update();
        }
    }
}

🤔 Краткий ответ

Паттерны проектирования — это проверенные решения общих проблем в разработке программного обеспечения. Они делятся на три категории: порождающие (Singleton, Factory Method), структурные (Adapter, Composite) и поведенческие (Observer, Strategy). Использование паттернов улучшает структуру кода, делает его более читаемым и гибким.

🔥 ТОП ВОПРОСОВ С СОБЕСОВ

🔒 База собесов | 🔒 База тестовых