Что такое многопоточность и библиотека TPL ?
Спросят с вероятностью 22%

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

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

Библиотека TPL (Task Parallel Library)

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

Основные возможности:

✅Параллельные циклы (`Parallel.For` и `Parallel.ForEach`): Позволяют выполнять итерации циклов в параллельном режиме, автоматически распределяя итерации по различным потокам.
✅Задачи (`Task`): Абстракция, представляющая асинхронную операцию. Task может быть использована для создания параллельных задач, которые могут выполняться асинхронно и независимо.
✅Блоки данных TPL (`Dataflow`): Позволяют создавать сложные многопоточные конвейеры и обрабатывать потоки данных асинхронно.
✅Планировщики задач (`TaskScheduler`): Предоставляют дополнительный контроль над тем, как задачи распределяются и выполняются в потоках.

using System;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        Task<int> task = Task.Run(() =>
        {
            return CalculateResult();
        });

        Console.WriteLine("Другие действия в главном потоке...");

        // Ожидание завершения задачи и получение результата
        int result = task.Result;
        Console.WriteLine($"Результат: {result}");
    }

    static int CalculateResult()
    {
        // Имитация сложной работы
        System.Threading.Thread.Sleep(2000);
        return 123;
    }
}

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Что такое Inversion of control и dependency injection ?
Спросят с вероятностью 78%

Inversion of Control (IoC) и Dependency Injection (DI) — это два тесно связанных принципа, используемых для уменьшения зависимостей между компонентами программного обеспечения, что упрощает управление этими зависимостями, их тестирование и поддержку.

Inversion of Control (Инверсия управления)

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

IoC часто реализуется с помощью таких паттернов, как Dependency Injection, Event, Strategy.

Dependency Injection (Внедрение зависимостей)

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

Пример:

public interface ILogger
{
    void Log(string message);
}

public class ConsoleLogger : ILogger
{
    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

public class Application
{
    private readonly ILogger _logger;

    // Внедрение зависимости через конструктор
    public Application(ILogger logger)
    {
        _logger = logger;
    }

    public void Run()
    {
        _logger.Log("Приложение запущено");
    }
}

// Где-то в другом месте приложения
ILogger logger = new ConsoleLogger();
Application app = new Application(logger);
app.Run();

В этом примере Application зависит от абстракции ILogger. Вместо того чтобы создавать конкретный экземпляр ConsoleLogger внутри Application, мы передаём его через конструктор, что позволяет легко заменить реализацию логгера без изменения кода класса Application.

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

В чём разница абстрактного класса и интерфейса ?
Спросят с вероятностью 89%

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

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

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

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

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

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

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

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

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

В чём разница между string и StringBuilder ?
Спросят с вероятностью 44%

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

1️⃣Иммутабельность (Неизменяемость)

✅string: Класс string представляет неизменяемые строки. Это значит, что после создания экземпляра строки его содержимое изменить нельзя. Каждый раз, когда вы выполняете операцию, которая кажется изменяющей строку (например, конкатенация), на самом деле создается новый экземпляр строки. Это может привести к значительным накладным расходам памяти при частой модификации строк.

string s = "Hello";
  s += ", World!"; // Создается новая строка "Hello, World!" и s теперь ссылается на неё




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

StringBuilder sb = new StringBuilder("Hello");
  sb.Append(", World!"); // Просто добавляет ", World!" к существующему буферу




2️⃣Производительность

✅string: Из-за неизменяемости строки не подходят для сценариев, где необходимо часто изменять или добавлять содержимое, особенно при больших объемах данных. Каждая операция модификации создает новый экземпляр строки, что приводит к временным затратам и использованию большего количества памяти.

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

3️⃣Когда использовать

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

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

Пример:

// Использование string в ситуации, когда StringBuilder был бы предпочтительнее
string result = "";
for (int i = 0; i < 10000; i++) {
    result += i;  // Очень неэффективно из-за создания новой строки на каждой итерации
}

// Использование StringBuilder
StringBuilder sbResult = new StringBuilder();
for (int i = 0; i < 10000; i++) {
    sbResult.Append(i);  // Эффективно, изменяет существующий буфер
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

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

Что такое Dispose ?
Спросят с вероятностью 22%

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

Неуправляемые и управляемые ресурсы

✅Неуправляемые ресурсы включают в себя ресурсы, которые не управляются средой CLR (Common Language Runtime), например, файловые дескрипторы, сетевые соединения или указатели на память, выделенную вне .NET среды.
✅Управляемые ресурсы — это объекты .NET, которые занимают память и потенциально удерживают ссылки на неуправляемые ресурсы.

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

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

Реализация IDisposable

public class ResourceHolder : IDisposable
{
    private bool disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                // Освобождение управляемых ресурсов
            }
            // Освобождение неуправляемых ресурсов
            disposed = true;
        }
    }

    ~ResourceHolder()
    {
        Dispose(false);
    }
}

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

using (var resource = new ResourceHolder())
{
    // Использование ресурса
}
// Метод Dispose автоматически вызывается при выходе из блока using

Важность вызова

✅Предотвращение утечек ресурсов: Неуправляемые ресурсы не освобождаются сборщиком мусора, поэтому их необходимо явно освобождать, чтобы избежать утечек.
✅Улучшение производительности: Освобождение ресурсов, как только они становятся ненужными, помогает поддерживать оптимальное использование ресурсов и производительность приложения.
✅Контроль над временем жизни ресурсов: Dispose позволяет разработчикам контролировать, когда ресурсы должны быть освобождены, в отличие от неопределённости сборки мусора.

Использование Dispose и паттерна IDisposable является ключевым для создания надёжных, эффективных и высокопроизводительных приложений.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Когда можно использовать using ?
Спросят с вероятностью 22%

Ключевое слово using используется в двух основных контекстах: для управления областью видимости объектов, реализующих интерфейс IDisposable, и для включения пространств имён.

1️⃣Управление областью видимости объектов (IDisposable)

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

using (StreamWriter writer = new StreamWriter("example.txt"))
{
    writer.WriteLine("Hello, world!");
}
// Здесь объект writer уже автоматически закрыт и освобожден.

В этом примере StreamWriter автоматически закрывается и его ресурсы освобождаются после выхода из блока using. Это гарантирует, что файловый дескриптор не останется открытым, если в блоке кода произойдёт исключение.

2️⃣Включение пространств имён

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

using System;
using System.IO;
using System.Text;

// Теперь можно использовать классы из System, System.IO и System.Text без полного указания имени.

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

3️⃣using для статических классов (C# 6.0 и выше)

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

using static System.Console;
using static System.Math;

class Program
{
    static void Main()
    {
        WriteLine(Sqrt(144)); // Использование метода WriteLine и Sqrt без указания классов Console и Math
    }
}

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Что такое async и await ?
Спросят с вероятностью 44%

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

Принцип работы

✅async: Это модификатор, который применяется к методу, указывая, что метод является асинхронным и внутри него можно использовать await. Методы с модификатором async всегда возвращают void, Task или Task<T>, где T — тип возвращаемого значения. Методы, возвращающие Task или Task<T>, могут быть ожидаемыми с помощью await, что означает, что их выполнение можно приостановить, ожидая завершения асинхронной операции, не блокируя при этом поток.

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

public class Example
{
    // Определение асинхронного метода
    public async Task<int> GetCalculationAsync()
    {
        Console.WriteLine("Starting calculation...");
        
        // Асинхронно ожидаем завершения длительной операции
        var result = await Task.Run(() =>
        {
            Thread.Sleep(5000); // Имитация длительной операции
            return 42;
        });

        Console.WriteLine("Calculation completed.");
        return result;
    }

    public async Task ExecuteAsync()
    {
        int result = await GetCalculationAsync();
        Console.WriteLine($"Result: {result}");
    }
}

// В точке входа приложения вызываем асинхронный метод
static async Task Main(string[] args)
{
    Example example = new Example();
    await example.ExecuteAsync();
}

✅Разработка GUI: Использование async и await позволяет UI оставаться отзывчивым, пока выполняются длительные операции, такие как загрузка данных или обращение к файловой системе.
✅Web-разработка: В веб-приложениях асинхронное программирование используется для эффективной обработки веб-запросов, что особенно важно при обращении к внешним ресурсам, таким как базы данных или веб-сервисы.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

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

Что известно о LINQ ?
Спросят с вероятностью 44%

LINQ (Language Integrated Query) — это мощная функциональность языка C#, которая позволяет интегрированно и унифицированно выполнять запросы к различным источникам данных непосредственно из кода. Включает в себя набор методов расширения и синтаксис, который позволяет выполнять запросы к коллекциям объектов, базам данных, XML документам и любым другим формам данных, которые могут быть представлены как коллекции.

Основные особенности:

1️⃣Единообразие: Gозволяет использовать один и тот же синтаксический подход при работе с различными источниками данных, будь то коллекции объектов в памяти (LINQ to Objects), базы данных (LINQ to SQL, Entity Framework), XML документы (LINQ to XML) или даже удалённые данные (LINQ to Entities).

2️⃣Интеграция с языком: Nесно интегрирован с C#, что позволяет использовать все возможности языка, такие как интеллисенс, строгая типизация и компиляция запросов, что повышает безопасность и производительность.

3️⃣Читабельность и краткость: Запросы LINQ часто гораздо более читабельны и кратки, чем эквивалентные императивные подходы к обработке данных. Это упрощает написание, чтение и поддержку кода.

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

To Objects

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
var evenNumbers = from num in numbers
                  where num % 2 == 0
                  select num;

foreach (var num in evenNumbers)
{
    Console.WriteLine(num); // Выводит 2, 4, 6
}

To SQL

using (DataContext db = new DataContext())
{
    var query = from customer in db.Customers
                where customer.City == "London"
                select customer;

    foreach (var customer in query)
    {
        Console.WriteLine(customer.Name);
    }
}

To XML

XElement root = XElement.Load("customers.xml");
var customerNames = from customer in root.Elements("customer")
                     where (int)customer.Element("age") > 30
                     select customer.Element("name").Value;

foreach (var name in customerNames)
{
    Console.WriteLine(name);
}

Применение:

✅Обработка данных: Идеально подходит для фильтрации, сортировки и агрегации больших объёмов данных.
✅Подключение к базам данных: Может использоваться для создания запросов к базам данных, что упрощает код и делает его более безопасным благодаря строгой типизации.
✅Работа с XML: LINQ to XML предоставляет удобные инструменты для работы с XML, позволяя легко извлекать и изменять данные.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Какие есть делегаты ?
Спросят с вероятностью 44%

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

Встроенные типы

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

1️⃣Action: Это делегат, который может указывать на метод, который не принимает параметров и не возвращает значение. Action также может быть обобщённым, принимая от 0 до 16 параметров:

      Action<string> printAction = s => Console.WriteLine(s);
   printAction("Hello, Action!");
   

2️⃣Func: Этот делегат указывает на метод, который возвращает значение. Func делегаты могут принимать от 0 до 16 параметров, и последний тип в обобщении Func — это возвращаемый тип:
      Func<int, int, int> sumFunc = (x, y) => x + y;
   int result = sumFunc(5, 3);  // Вывод: 8
   

3️⃣Predicate: Это специализация делегата Func для ситуаций, когда нужно возвращать bool. Он всегда принимает один параметр и возвращает bool:
      Predicate<int> isPositive = x => x > 0;
   bool positive = isPositive(-1);  // Вывод: false
   

Вы можете определить собственные типы делегатов, если встроенные не соответствуют вашим требованиям. Для этого используется ключевое слово delegate:
public delegate void MyCustomDelegate(string message);

public class Program
{
    public static void ShowMessage(string message)
    {
        Console.WriteLine(message);
    }

    static void Main(string[] args)
    {
        MyCustomDelegate del = new MyCustomDelegate(ShowMessage);
        del("Hello, Custom Delegate!");
    }
}

Использование делегатов

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

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Что делать, если есть два разных интерфейса в одном классе и у них совпали имена ?
Спросят с вероятностью 22%

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

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

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

Рассмотрим следующий пример с двумя интерфейсами, которые содержат метод с одинаковым именем:

public interface IFirstInterface
{
    void DoSomething();
}

public interface ISecondInterface
{
    void DoSomething();
}

public class MyClass : IFirstInterface, ISecondInterface
{
    // Явная реализация метода из IFirstInterface
    void IFirstInterface.DoSomething()
    {
        Console.WriteLine("Doing something the FIRST way.");
    }

    // Явная реализация метода из ISecondInterface
    void ISecondInterface.DoSomething()
    {
        Console.WriteLine("Doing something the SECOND way.");
    }
}

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

MyClass myObj = new MyClass();
IFirstInterface first = myObj;
ISecondInterface second = myObj;

first.DoSomething();  // Выводит: "Doing something the FIRST way."
second.DoSomething(); // Выводит: "Doing something the SECOND way."

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

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Что умеет Action фильтр ?
Спросят с вероятностью 33%

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

Основные возможности:

1️⃣Исполнение кода до и после методов контроллера:
✅Action фильтры могут выполнить код непосредственно до (OnActionExecuting) и сразу после (OnActionExecuted) вызова действия контроллера. Это позволяет вам добавлять логику обработки, например, проверку или подготовку данных, логирование, обработку ошибок, изменение аргументов метода или результатов выполнения метода.

2️⃣Контроль над выполнением конвейера:
✅Внутри методов OnActionExecuting и OnActionExecuted можно управлять тем, как будут обрабатываться последующие фильтры или даже само выполнение действия. Например, можно прервать выполнение действия, установив результат действия в OnActionExecuting.

3️⃣Доступ к контексту HTTP:
✅Фильтры имеют доступ к контексту HTTP запроса, что позволяет анализировать входящие запросы и модифицировать исходящие ответы.

Пример:

public class MyActionFilter : IActionFilter
{
    public void OnActionExecuting(ActionExecutingContext context)
    {
        // Логика перед выполнением действия
        Console.WriteLine("Before the action executes");
        
        // Можно изменять входные параметры
        if (context.ActionArguments.ContainsKey("exampleParam"))
        {
            context.ActionArguments["exampleParam"] = "Modified";
        }
    }

    public void OnActionExecuted(ActionExecutedContext context)
    {
        // Логика после выполнения действия
        Console.WriteLine("After the action executes");

        // Можно проверить исключения или изменить результат выполнения
        if (context.Exception != null)
        {
            context.ExceptionHandled = true; // Обработка исключения
            context.Result = new StatusCodeResult(500); // Установка статус кода ответа
        }
    }
}

Как его использовать:

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

✅Применение на уровне метода:

    [MyActionFilter]
  public IActionResult MyAction()
  {
      return View();
  }
  
  
✅

Применение на уровне контроллера:

    [MyActionFilter]
  public class MyController : Controller
  {
      public IActionResult Index()
      {
          return View();
      }
  }
  

✅Глобальное применение:
В методе ConfigureServices в Startup.cs можно добавить фильтр ко всем контроллерам:

    services.AddControllersWithViews(options =>
  {
      options.Filters.Add(new MyActionFilter());
  });
  

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Что такое контекст синхронизации ?
Спросят с вероятностью 22%

"контекст синхронизации" (SynchronizationContext) — это класс, который предоставляет возможность управлять способом, которым операции переключаются обратно в основной поток или контекст для продолжения выполнения после асинхронной операции. Это важно для приложений с графическим пользовательским интерфейсом, таких как Windows Forms и WPF, где доступ к элементам пользовательского интерфейса разрешён только из основного потока.

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

Абстрагирует модель синхронизации для различных сред выполнения. Например, в приложениях Windows Forms и WPF управление элементами UI должно происходить в главном потоке. SynchronizationContext предоставляет методы для отправки (Send) и постановки (Post) задач, которые должны выполняться в правильном контексте.

✅Send — синхронно отправляет делегат на выполнение в контекст синхронизации.
✅Post — асинхронно отправляет делегат на выполнение в контекст синхронизации.

Применение SynchronizationContext

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

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        LoadDataAsync();
    }

    private async void LoadDataAsync()
    {
        string data = await GetDataAsync();
        // Асинхронно получаем данные и обновляем UI
        Dispatcher.Invoke(() => DisplayData(data));
    }

    private Task<string> GetDataAsync()
    {
        return Task.Run(() =>
        {
            // Имитация долгой операции
            Thread.Sleep(5000);
            return "Data loaded";
        });
    }

    private void DisplayData(string data)
    {
        MyTextBox.Text = data;
    }
}

В этом примере Dispatcher.Invoke() используется для обновления текстового поля в главном потоке WPF, который является особым случаем SynchronizationContext.

Зачем он нужен

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Что такое dictionary ?
Спросят с вероятностью 22%

Dictionary<TKey,TValue> является обобщённым коллекционным типом, который хранит пары "ключ-значение". Он реализует интерфейс IDictionary<TKey, TValue> и предоставляет быстрый доступ к данным по ключу, используя хеш-таблицу для внутреннего хранения элементов.

Основные характеристики:

1️⃣Хранение пар ключ-значение: Каждый элемент в словаре состоит из пары ключа и значения. Ключи в словаре должны быть уникальными.

2️⃣Быстрый доступ: Доступ к элементам в словаре осуществляется по ключу. Благодаря внутреннему использованию хеш-таблицы, операции поиска, вставки и удаления выполняются с высокой производительностью, в среднем за время O(1).

3️⃣Обобщённость: Dictionary<TKey, TValue> является обобщённым типом, что позволяет использовать любые типы данных для ключей и значений, при условии, что тип ключа должен корректно реализовать GetHashCode() и Equals() для правильной работы хеш-таблицы.

4️⃣Изменяемость размера: Внутренняя структура Dictionary может автоматически увеличиваться по мере добавления новых элементов.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Создание словаря
        Dictionary<string, int> ageOfFriends = new Dictionary<string, int>();

        // Добавление элементов
        ageOfFriends.Add("Alice", 25);
        ageOfFriends.Add("Bob", 29);
        ageOfFriends.Add("Charlie", 31);

        // Доступ к элементу
        int ageOfBob = ageOfFriends["Bob"];
        Console.WriteLine($"Bob's age is {ageOfBob}.");

        // Перебор элементов
        foreach (KeyValuePair<string, int> kvp in ageOfFriends)
        {
            Console.WriteLine($"Name: {kvp.Key}, Age: {kvp.Value}");
        }

        // Проверка наличия ключа
        if (ageOfFriends.ContainsKey("Alice"))
        {
            Console.WriteLine("Alice is in the dictionary.");
        }

        // Обновление значения
        ageOfFriends["Alice"] = 26;

        // Удаление элемента
        ageOfFriends.Remove("Charlie");

        // Получение количества элементов
        int count = ageOfFriends.Count;
        Console.WriteLine($"Number of entries in dictionary: {count}.");
    }
}

Dictionary<TKey, TValue> предоставляет эффективный способ работы с данными, организованными в форме ключ-значение. Он идеально подходит для ситуаций, когда требуется быстрый поиск, добавление и удаление элементов по уникальным ключам. Словари широко используются в различных приложениях, включая кэширование, обработку данных, настройки конфигурации и многие другие задачи, где важна производительность доступа к данным.

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Чем отличается IQuerable от IEnumerable ?
Спросят с вероятностью 33%

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

IEnumerable

Это интерфейс, который определяет один метод GetEnumerator, который возвращает IEnumerator, позволяющий перебирать элементы коллекции. Используется в LINQ to Objects для работы с коллекциями, которые находятся в памяти.

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

    List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
  IEnumerable<int> evenNumbers = numbers.Where(n => n % 2 == 0);
  foreach (int number in evenNumbers)
  {
      Console.WriteLine(number); // Выведет 2 и 4
  }
  

IQueryable

Расширяет IEnumerable и предназначен для работы с данными, которые могут быть не загружены в память (например, данные из базы данных). Позволяет запросам быть переведенными в оптимизированные запросы к источнику данных, таким как SQL запросы к базе данных.

✅Особенности использования:
✅Идеально подходит для запросов к базам данных, так как позволяет конвертировать выражения LINQ в оптимизированные запросы SQL на стороне сервера.
✅Может значительно улучшить производительность, минимизируя количество данных, передаваемых из базы данных.
✅Позволяет ленивую загрузку данных, загружая данные только при необходимости.

    IQueryable<Customer> customers = dbContext.Customers.Where(c => c.City == "London");
  foreach (Customer customer in customers)
  {
      Console.WriteLine(customer.Name); // Запрос к базе данных выполнится здесь
  }
  

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

1️⃣Выполнение запросов:
✅IEnumerable выполняет запросы в памяти и применяет операции после загрузки данных.
✅IQueryable формирует выражение запроса, которое может быть выполнено источником данных, оптимизируя и минимизируя объем передаваемых данных.

2️⃣Место выполнения:
✅IEnumerable обрабатывает данные в клиентском приложении.
✅IQueryable позволяет обработку данных производить на сервере (например, на SQL сервере).

3️⃣Типы операций:
✅IEnumerable поддерживает любые операции LINQ, но все они выполняются в памяти.
✅IQueryable поддерживает создание выражений, которые могут быть преобразованы в код запроса для выполнения на сервере.

Использование IQueryable может быть более предпочтительным при работе с большими объемами данных или при необходимости выполнения запросов к базам данных, тогда как

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

В чём разница между ReadOnly и Const ?
Спросят с вероятностью 22%

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

Const

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

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

public class MathConstants
{
    public const double PI = 3.14159;
}

Здесь PI является константой и его значение не может быть изменено после компиляции.

ReadOnly

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

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

Пример `readonly`:

public class Config
{
    public readonly string ConfigurationName;

    public Config(string name)
    {
        ConfigurationName = name;
    }
}

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

Использование зависит от контекста:
✅Используйте const, когда значение известно до запуска программы и не изменится никогда. Это удобно для определения значений, которые являются фундаментальными и неизменными, например числовые константы, такие как число π.
✅Используйте readonly, когда значение должно быть установлено во время выполнения (например, в конструкторе), но после этого не должно изменяться. Это удобно для конфигурационных значений или зависимостей, устанавливаемых во время создания объекта.

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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

Зачем нужны интерфейсы, если есть абстрактные классы ?
Спросят с вероятностью 33%

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

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

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

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

2️⃣Спецификация контракта

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

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

3️⃣Прозрачность использования

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

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

4️⃣Эволюция API

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

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

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

👉 Можно посмотреть Примеры как отвечают люди на этот вопрос, или перейти К списку 466 вопроса на C# разработчика. Ставь 👍 если нравится контент

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