Вопросы на собеседовании по .NET Core

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseKestrel(options =>
            {
                // Здесь можно настроить Kestrel
                options.Limits.MaxRequestBodySize = 10 * 1024 * 1024; // 10 MB
            });
            webBuilder.UseStartup<Startup>();
        });

public class DatabaseOptions
{
    public string ConnectionString { get; set; }
    public int Timeout { get; set; }
}
 
// В методе ConfigureServices
services.Configure<DatabaseOptions>(Configuration.GetSection("Database"));
 
// В сервисе, где нужен доступ к настройкам
public class DataService
{
    private readonly DatabaseOptions _options;
 
    public DataService(IOptions<DatabaseOptions> options)
    {
        _options = options.Value;
    }
}

// Плохой пример
public class UserService
{
    public void RegisterUser(User user) { /* ... */ }
    public void SendEmail(string to, string subject) { /* ... */ }
    public void GeneratePdf(User user) { /* ... */ }
}
 
// Хороший пример
public class UserService
{
    private readonly EmailService _emailService;
    private readonly PdfGenerator _pdfGenerator;
 
    public UserService(EmailService emailService, PdfGenerator pdfGenerator)
    {
        _emailService = emailService;
        _pdfGenerator = pdfGenerator;
    }
 
    public void RegisterUser(User user) { /* ... */ }
}

// Вместо этого:
public decimal CalculateDiscount(Order order)
{
    decimal totalDiscount = 0;
    foreach (var item in order.Items)
    {
        if (item.Product.IsPromotional)
        {
            totalDiscount += item.Price * 0.1m;
        }
    }
    return totalDiscount;
}
 
public decimal CalculateTax(Order order)
{
    decimal totalTax = 0;
    // Тот же цикл, что и выше, но с другой логикой
    foreach (var item in order.Items)
    {
        totalTax += item.Price * 0.2m;
    }
    return totalTax;
}
 
// Лучше сделать так:
public decimal ProcessOrderItems(Order order, Func<OrderItem, decimal> processor)
{
    return order.Items.Sum(processor);
}
 
// И использовать:
var discount = ProcessOrderItems(order, item => item.Product.IsPromotional ? item.Price * 0.1m : 0);
var tax = ProcessOrderItems(order, item => item.Price * 0.2m);

public class SimpleMiddleware
{
    private readonly RequestDelegate _next;
 
    public SimpleMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Код, выполняемый до вызова следующего middleware
        Console.WriteLine($"Request: {context.Request.Path}");
 
        // Вызов следующего middleware в конвейере
        await _next(context);
 
        // Код, выполняемый после вызова следующего middleware
        Console.WriteLine($"Response status: {context.Response.StatusCode}");
    }
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Middleware для обработки исключений
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Error");
    }
 
    // Middleware для статических файлов
    app.UseStaticFiles();
 
    // Middleware для маршрутизации
    app.UseRouting();
 
    // Middleware для аутентификации и авторизации
    app.UseAuthentication();
    app.UseAuthorization();
 
    // Middleware для конечных точек
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
        endpoints.MapRazorPages();
    });
}

// Use позволяет продолжить выполнение конвейера
app.Use(async (context, next) =>
{
    Console.WriteLine("Перед следующим middleware");
    await next(); // Вызов следующего middleware
    Console.WriteLine("После следующего middleware");
});
 
// Run завершает конвейер
app.Run(async context =>
{
    await context.Response.WriteAsync("Конец конвейера");
});

[Authorize]
public class AdminController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
 
    [AllowAnonymous] // Исключение из правила авторизации
    public IActionResult Login()
    {
        return View();
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // Регистрация сервисов
    services.AddTransient<IEmailSender, SmtpEmailSender>();
    services.AddScoped<IUserRepository, UserRepository>();
    services.AddSingleton<ICacheService, MemoryCacheService>();
}

[HttpGet]
public async Task<IActionResult> GetUserDataAsync(int userId)
{
    // Асинхронный запрос к базе данных
    var user = await _userRepository.GetByIdAsync(userId);
    
    if (user == null)
        return NotFound();
    
    // Асинхронный запрос к другому сервису
    var orders = await _orderService.GetOrdersForUserAsync(userId);
    
    var viewModel = new UserViewModel
    {
        User = user,
        Orders = orders
    };
    
    return View(viewModel);
}

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options) { }
    
    public DbSet<User> Users { get; set; }
    public DbSet<Order> Orders { get; set; }
    
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Конфигурация модели с использованием Fluent API
        modelBuilder.Entity<User>()
            .HasMany(u => u.Orders)
            .WithOne(o => o.User)
            .HasForeignKey(o => o.UserId);
    }
}
 
// В методе ConfigureServices
services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

public async Task<IEnumerable<User>> GetUsersAsync()
{
    using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();
    
    return await connection.QueryAsync<User>("SELECT * FROM Users");
}
 
public async Task<User> GetUserWithOrdersAsync(int userId)
{
    using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();
    
    var sql = @"
        SELECT u.*, o.* 
        FROM Users u 
        LEFT JOIN Orders o ON u.Id = o.UserId 
        WHERE u.Id = @UserId";
        
    User user = null;
    var orders = new List<Order>();
    
    await connection.QueryAsync<User, Order, User>(
        sql,
        (u, o) => 
        {
            if (user == null)
                user = u;
                
            if (o != null)
                orders.Add(o);
                
            return user;
        },
        new { UserId = userId },
        splitOn: "Id");
        
    if (user != null)
        user.Orders = orders;
        
    return user;
}

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
 
// Определение маршрута с обработчиком
app.MapGet("/hello", () => "Hello, World!");
 
// Определение маршрута с параметром
app.MapGet("/users/{id}", (int id) => $"User ID: {id}");
 
// Обработка POST-запроса
app.MapPost("/users", async (User user, IUserRepository repository) => 
{
    await repository.AddAsync(user);
    return Results.Created($"/users/{user.Id}", user);
});
 
app.Run();

// Пример Razor Page модели
public class IndexModel : PageModel
{
    private readonly IProductService _productService;
 
    public IndexModel(IProductService productService)
    {
        _productService = productService;
    }
 
    public IList<Product> Products { get; set; }
 
    public async Task OnGetAsync()
    {
        Products = await _productService.GetProductsAsync();
    }
}

public class ProductDetailsViewModel
{
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Description { get; set; }
    public string CategoryName { get; set; }
    public List<string> Tags { get; set; }
    // Заметьте, что здесь нет полей модели Product вроде CreatedDate,
    // InternalCode и других, которые не нужны представлению
}

public IActionResult UploadProfilePhoto(IFormFile file)
{
    if (file == null || file.Length == 0)
        return BadRequest("Файл не загружен");
 
    var uploadsFolder = Path.Combine(_environment.WebRootPath, "uploads");
    var uniqueFileName = Guid.NewGuid().ToString() + "_" + file.FileName;
    var filePath = Path.Combine(uploadsFolder, uniqueFileName);
 
    using (var stream = new FileStream(filePath, FileMode.Create))
    {
        file.CopyTo(stream);
    }
 
    // Сохраняем путь к файлу в базе данных
    _userService.UpdateProfilePhoto(User.Identity.Name, uniqueFileName);
 
    return RedirectToAction("Profile");
}

// В ConfigureServices
services.AddHealthChecks()
    .AddDbContextCheck<ApplicationDbContext>()
    .AddCheck<CustomHealthCheck>("Custom");
 
// В Configure
app.UseEndpoints(endpoints =>
{
    endpoints.MapHealthChecks("/health", new HealthCheckOptions
    {
        ResponseWriter = WriteResponse
    });
    // другие маршруты...
});
 
// Метод для форматирования ответа
private static Task WriteResponse(HttpContext context, HealthReport result)
{
    context.Response.ContentType = "application/json";
 
    var response = new
    {
        status = result.Status.ToString(),
        checks = result.Entries.Select(x => new
        {
            component = x.Key,
            status = x.Value.Status.ToString(),
            description = x.Value.Description
        })
    };
 
    return context.Response.WriteAsync(JsonSerializer.Serialize(response));
}

public class UserService
{
    private readonly ILogger<UserService> _logger;
 
    public UserService(ILogger<UserService> logger)
    {
        _logger = logger;
    }
 
    public async Task<User> GetUserByIdAsync(int id)
    {
        try
        {
            _logger.LogInformation("Получение пользователя с ID: {UserId}", id);
            var user = await _userRepository.GetByIdAsync(id);
            
            if (user == null)
            {
                _logger.LogWarning("Пользователь с ID {UserId} не найден", id);
                return null;
            }
            
            return user;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении пользователя с ID {UserId}", id);
            throw;
        }
    }
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
{
    // Настройка логирования
    loggerFactory.AddConsole();
    loggerFactory.AddDebug();
    
    // Также можно использовать популярные библиотеки, такие как NLog или Serilog
}

[ApiController]
[Route("api/products")]
public class ProductsController : ControllerBase
{
  private readonly IProductRepository _repository;
  
  public ProductsController(IProductRepository repository)
  {
      _repository = repository;
  }
  
  [HttpGet]
  public async Task<ActionResult<IEnumerable<ProductDto>>> GetAll()
  {
      var products = await _repository.GetAllAsync();
      return Ok(products.Select(p => new ProductDto(p)));
  }
  
  [HttpGet("{id}")]
  public async Task<ActionResult<ProductDto>> GetById(int id)
  {
      var product = await _repository.GetByIdAsync(id);
      if (product == null)
          return NotFound();
          
      return Ok(new ProductDto(product));
  }
}

// В Startup.ConfigureServices
services.AddHangfire(config =>
{
  config.UseSqlServerStorage(Configuration.GetConnectionString("HangfireConnection"));
});
services.AddHangfireServer();
 
// В Startup.Configure
app.UseHangfireDashboard();
 
// Планирование задач
BackgroundJob.Enqueue(() => Console.WriteLine("Fire-and-forget!"));
BackgroundJob.Schedule(() => Console.WriteLine("Delayed!"), TimeSpan.FromDays(1));
RecurringJob.AddOrUpdate("myrecurringjob", () => Console.WriteLine("Recurring!"), Cron.Daily);

public class TimedHostedService : IHostedService, IDisposable
{
  private Timer _timer;
  private readonly ILogger<TimedHostedService> _logger;
 
  public TimedHostedService(ILogger<TimedHostedService> logger)
  {
      _logger = logger;
  }
 
  public Task StartAsync(CancellationToken cancellationToken)
  {
      _logger.LogInformation("Timed Hosted Service запущен.");
 
      _timer = new Timer(DoWork, null, TimeSpan.Zero, 
          TimeSpan.FromSeconds(5));
 
      return Task.CompletedTask;
  }
 
  private void DoWork(object state)
  {
      _logger.LogInformation($"Выполняется в фоне: {DateTime.Now}");
  }
 
  public Task StopAsync(CancellationToken cancellationToken)
  {
      _logger.LogInformation("Timed Hosted Service остановлен.");
 
      _timer?.Change(Timeout.Infinite, 0);
 
      return Task.CompletedTask;
  }
 
  public void Dispose()
  {
      _timer?.Dispose();
  }
}
 
// Регистрация в Startup.ConfigureServices
services.AddHostedService<TimedHostedService>();

public async Task<IActionResult> ProcessData()
{
  // Запуск длительной операции в фоне
  _ = Task.Run(async () =>
  {
      try
      {
          await ProcessLongRunningTask();
      }
      catch (Exception ex)
      {
          _logger.LogError(ex, "Ошибка в фоновой задаче");
      }
  });
 
  return Ok("Обработка начата");
}

public class ProductService
{
  private readonly IMemoryCache _cache;
  private readonly IProductRepository _repository;
  
  public ProductService(IMemoryCache cache, IProductRepository repository)
  {
      _cache = cache;
      _repository = repository;
  }
  
  public async Task<Product> GetProductByIdAsync(int id)
  {
      string cacheKey = $"product_{id}";
      
      if (!_cache.TryGetValue(cacheKey, out Product product))
      {
          product = await _repository.GetByIdAsync(id);
          
          if (product != null)
          {
              var cacheOptions = new MemoryCacheEntryOptions()
                  .SetAbsoluteExpiration(TimeSpan.FromMinutes(10))
                  .SetSlidingExpiration(TimeSpan.FromMinutes(2));
                  
              _cache.Set(cacheKey, product, cacheOptions);
          }
      }
      
      return product;
  }
}

// В Startup.ConfigureServices
services.AddStackExchangeRedisCache(options =>
{
  options.Configuration = Configuration.GetConnectionString("Redis");
  options.InstanceName = "SampleInstance_";
});
 
// Использование
public class ProductService
{
  private readonly IDistributedCache _cache;
  private readonly IProductRepository _repository;
  
  // ... конструктор ...
  
  public async Task<Product> GetProductByIdAsync(int id)
  {
      string cacheKey = $"product_{id}";
      Product product = null;
      
      var cachedData = await _cache.GetStringAsync(cacheKey);
      if (cachedData != null)
      {
          product = JsonSerializer.Deserialize<Product>(cachedData);
      }
      else
      {
          product = await _repository.GetByIdAsync(id);
          if (product != null)
          {
              var options = new DistributedCacheEntryOptions()
                  .SetAbsoluteExpiration(TimeSpan.FromMinutes(10));
                  
              await _cache.SetStringAsync(
                  cacheKey, 
                  JsonSerializer.Serialize(product),
                  options);
          }
      }
      
      return product;
  }
}

// В форме
@Html.AntiForgeryToken()
 
// В контроллере
[ValidateAntiForgeryToken]
public async Task<IActionResult> Update(ProductViewModel model)
{
  // Обновление продукта...
  return RedirectToAction("Index");
}

public class DatabaseService : IDisposable
{
    private SqlConnection _connection;
    private bool _disposed = false;
 
    public DatabaseService(string connectionString)
    {
        _connection = new SqlConnection(connectionString);
        _connection.Open();
    }
 
    protected virtual void Dispose(bool disposing)
    {
        if (!_disposed)
        {
            if (disposing)
            {
                // Освобождаем управляемые ресурсы
                _connection?.Close();
            }
            
            // Освобождаем неуправляемые ресурсы
            _connection = null;
            _disposed = true;
        }
    }
 
    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
 
    ~DatabaseService()
    {
        Dispose(false);
    }
}

// Пример контроллера, демонстрирующего различные типы результатов
public class DemoController : Controller
{
    public IActionResult Index()
    {
        return View(); // ViewResult
    }
    
    public IActionResult GetText()
    {
        return Content("Привет, мир!"); // ContentResult
    }
    
    public IActionResult GetJson()
    {
        var data = new { Name = "Иван", Age = 30 };
        return Json(data); // JsonResult
    }
    
    public IActionResult GetFile()
    {
        byte[] fileBytes = System.IO.File.ReadAllBytes("sample.pdf");
        return File(fileBytes, "application/pdf", "sample.pdf"); // FileResult
    }
    
    public IActionResult RedirectToGoogle()
    {
        return Redirect("https://www.google.com"); // RedirectResult
    }
    
    public IActionResult RedirectToIndex()
    {
        return RedirectToAction("Index"); // RedirectToActionResult
    }
    
    public IActionResult NotFound()
    {
        return StatusCode(404); // StatusCodeResult
    }
    
    public IActionResult GetObject()
    {
        var user = new User { Id = 1, Name = "Иван" };
        return new ObjectResult(user); // ObjectResult
    }
    
    public IActionResult DoNothing()
    {
        return new EmptyResult(); // EmptyResult
    }
}

// Использование Json
public IActionResult GetUserJson()
{
    var user = new User { Id = 1, Name = "Иван" };
    return Json(user); // Автоматически сериализует и устанавливает Content-Type: application/json
}
 
// Эквивалентно, но более многословно:
public IActionResult GetUserContent()
{
    var user = new User { Id = 1, Name = "Иван" };
    var json = JsonSerializer.Serialize(user);
    return Content(json, "application/json");
}

// Пример нарушения принципа подстановки Лисков
public class Rectangle
{
    public virtual int Width { get; set; }
    public virtual int Height { get; set; }
    
    public int GetArea()
    {
        return Width * Height;
    }
}
 
public class Square : Rectangle
{
    private int _size;
    
    public override int Width
    {
        get { return _size; }
        set { _size = value; }
    }
    
    public override int Height
    {
        get { return _size; }
        set { _size = value; }
    }
}
 
// Это нарушает принцип подстановки Лисков:
Rectangle rect = new Square();
rect.Width = 5;
rect.Height = 10;
// Ожидаем 50, но получаем 100, так как Square изменил оба свойства
int area = rect.GetArea();

// Пример правильного использования async/await для I/O-операций
public async Task<string> DownloadContentAsync(string url)
{
    using var httpClient = new HttpClient();
    return await httpClient.GetStringAsync(url);
}
 
// Пример правильного использования Parallel для CPU-операций
public void ProcessImages(List<Image> images)
{
    Parallel.ForEach(images, image =>
    {
        // Интенсивная обработка картинки
        ApplyFilters(image);
        ResizeImage(image);
    });
}

// Плохой пример - уязвим для SQL-инъекций
public User GetUserByUsername(string username)
{
    using var connection = new SqlConnection(_connectionString);
    connection.Open();
    
    var command = new SqlCommand($"SELECT * FROM Users WHERE Username = '{username}'", connection);
    var reader = command.ExecuteReader();
    
    // Чтение данных...
}
 
// Хороший пример - защищён от SQL-инъекций
public User GetUserByUsername(string username)
{
    using var connection = new SqlConnection(_connectionString);
    connection.Open();
    
    var command = new SqlCommand("SELECT * FROM Users WHERE Username = @username", connection);
    command.Parameters.AddWithValue("@username", username);
    var reader = command.ExecuteReader();
    
    // Чтение данных...
}

// Пример неэффективного кода
public IEnumerable<Product> GetExpensiveProducts(List<Product> products)
{
    var filtered = products.Where(p => p.Price > 1000).ToList(); // Создаёт временный список
    return filtered.OrderBy(p => p.Name); // Сортирует временный список
}
 
// Более эффективная версия
public IEnumerable<Product> GetExpensiveProducts(List<Product> products)
{
    return products.Where(p => p.Price > 1000).OrderBy(p => p.Name); // Чейнинг без промежуточных списков
}

public class Note
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime UpdatedAt { get; set; }
}
 
public interface INoteRepository
{
    Task<IEnumerable<Note>> GetAllAsync();
    Task<Note> GetByIdAsync(int id);
    Task<Note> CreateAsync(Note note);
    Task<Note> UpdateAsync(Note note);
    Task DeleteAsync(int id);
}
 
public class InMemoryNoteRepository : INoteRepository
{
    private readonly List<Note> _notes = new List<Note>();
    private int _nextId = 1;
 
    public Task<IEnumerable<Note>> GetAllAsync()
    {
        return Task.FromResult(_notes.AsEnumerable());
    }
 
    public Task<Note> GetByIdAsync(int id)
    {
        var note = _notes.FirstOrDefault(n => n.Id == id);
        return Task.FromResult(note);
    }
 
    public Task<Note> CreateAsync(Note note)
    {
        note.Id = _nextId++;
        note.CreatedAt = DateTime.UtcNow;
        note.UpdatedAt = note.CreatedAt;
        
        _notes.Add(note);
        
        return Task.FromResult(note);
    }
 
    public Task<Note> UpdateAsync(Note note)
    {
        var existingNote = _notes.FirstOrDefault(n => n.Id == note.Id);
        if (existingNote == null)
            return Task.FromResult<Note>(null);
            
        existingNote.Title = note.Title;
        existingNote.Content = note.Content;
        existingNote.UpdatedAt = DateTime.UtcNow;
        
        return Task.FromResult(existingNote);
    }
 
    public Task DeleteAsync(int id)
    {
        var note = _notes.FirstOrDefault(n => n.Id == id);
        if (note != null)
            _notes.Remove(note);
            
        return Task.CompletedTask;
    }
}
 
[ApiController]
[Route("api/[controller]")]
public class NotesController : ControllerBase
{
    private readonly INoteRepository _repository;
    
    public NotesController(INoteRepository repository)
    {
        _repository = repository;
    }
    
    [HttpGet]
    public async Task<ActionResult<IEnumerable<Note>>> GetAll()
    {
        var notes = await _repository.GetAllAsync();
        return Ok(notes);
    }
    
    [HttpGet("{id}")]
    public async Task<ActionResult<Note>> GetById(int id)
    {
        var note = await _repository.GetByIdAsync(id);
        
        if (note == null)
            return NotFound();
            
        return Ok(note);
    }
    
    [HttpPost]
    public async Task<ActionResult<Note>> Create(Note note)
    {
        var createdNote = await _repository.CreateAsync(note);
        return CreatedAtAction(nameof(GetById), new { id = createdNote.Id }, createdNote);
    }
    
    [HttpPut("{id}")]
    public async Task<IActionResult> Update(int id, Note note)
    {
        if (id != note.Id)
            return BadRequest();
            
        var updatedNote = await _repository.UpdateAsync(note);
        
        if (updatedNote == null)
            return NotFound();
            
        return NoContent();
    }
    
    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(int id)
    {
        await _repository.DeleteAsync(id);
        return NoContent();
    }
}
 
// В Startup.ConfigureServices
services.AddSingleton<INoteRepository, InMemoryNoteRepository>();

// Проблемный код
public class UserManager
{
    public List<User> GetAllUsers()
    {
        var users = new List<User>();
        var connection = new SqlConnection("Server=...;Database=...;User=...;Password=...");
        connection.Open();
        var command = new SqlCommand("SELECT * FROM Users", connection);
        var reader = command.ExecuteReader();
        while (reader.Read())
        {
            var user = new User
            {
                Id = (int)reader["Id"],
                Name = (string)reader["Name"],
                Email = (string)reader["Email"]
            };
            users.Add(user);
        }
        reader.Close();
        connection.Close();
        return users;
    }
    
    public User GetUserById(int id)
    {
        var connection = new SqlConnection("Server=...;Database=...;User=...;Password=...");
        connection.Open();
        var command = new SqlCommand($"SELECT * FROM Users WHERE Id = {id}", connection);
        var reader = command.ExecuteReader();
        User user = null;
        if (reader.Read())
        {
            user = new User
            {
                Id = (int)reader["Id"],
                Name = (string)reader["Name"],
                Email = (string)reader["Email"]
            };
        }
        reader.Close();
        connection.Close();
        return user;
    }
}

public interface IUserRepository
{
    Task<IEnumerable<User>> GetAllAsync();
    Task<User> GetByIdAsync(int id);
}
 
public class UserRepository : IUserRepository
{
    private readonly string _connectionString;
    
    public UserRepository(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection");
    }
    
    public async Task<IEnumerable<User>> GetAllAsync()
    {
        var users = new List<User>();
        
        using (var connection = new SqlConnection(_connectionString))
        {
            await connection.OpenAsync();
            
            using var command = new SqlCommand("SELECT Id, Name, Email FROM Users", connection);
            using var reader = await command.ExecuteReaderAsync();
            
            while (await reader.ReadAsync())
            {
                users.Add(MapUser(reader));
            }
        }
        
        return users;
    }
    
    public async Task<User> GetByIdAsync(int id)
    {
        using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();
        
        using var command = new SqlCommand("SELECT Id, Name, Email FROM Users WHERE Id = @Id", connection);
        command.Parameters.AddWithValue("@Id", id);
        
        using var reader = await command.ExecuteReaderAsync();
        
        return await reader.ReadAsync() ? MapUser(reader) : null;
    }
    
    private static User MapUser(SqlDataReader reader)
    {
        return new User
        {
            Id = reader.GetInt32(reader.GetOrdinal("Id")),
            Name = reader.GetString(reader.GetOrdinal("Name")),
            Email = reader.GetString(reader.GetOrdinal("Email"))
        };
    }
}

public async Task<IActionResult> GetItems()
{
    var items = await _itemsService.GetItemsAsync();
    
    if (items == null)
        return NotFound();
        
    var cacheEntryOptions = new MemoryCacheEntryOptions()
        .SetSlidingExpiration(TimeSpan.FromMinutes(5))
        .SetAbsoluteExpiration(TimeSpan.FromHours(1));
        
    _cache.Set("items", items, cacheEntryOptions);
    
    return Ok(items.Select(i => new ItemDto(i)));
}

public async Task<IActionResult> GetItems()
{
    const string cacheKey = "items_list_v1";
    
    if (_cache.TryGetValue(cacheKey, out List<ItemDto> cachedItems))
    {
        return Ok(cachedItems);
    }
    
    var items = await _itemsService.GetItemsAsync();
    
    if (items == null)
        return NotFound();
        
    var itemDtos = items.Select(i => new ItemDto(i)).ToList();
    
    var cacheEntryOptions = new MemoryCacheEntryOptions()
        .SetSlidingExpiration(TimeSpan.FromMinutes(5))
        .SetAbsoluteExpiration(TimeSpan.FromHours(1));
        
    _cache.Set(cacheKey, itemDtos, cacheEntryOptions);
    
    return Ok(itemDtos);
}