.NET Разработчик

// продолжение BatchConfiguration.Configure()
…
bld.ComplexProperty(b => b.Volume, vol =>
{
  vol.Property(v => v.Amount)
   .HasColumnName("vol_amount");
  vol.Property(v => v.Unit)
   .HasColumnName("vol_unit");
});

bld.OwnsMany(b => b.HopAdditions, hop =>
{
  hop.ToTable("hop_additions");
  hop.WithOwner()
   .HasForeignKey("batch_id");
});

bld.Property(b => b.Status)
 .HasConversion<string>()
 .HasMaxLength(20);

bld.Ignore(b => b.DomainEvents);

public class DomainEventsInterceptor(
 // внедряем диспетчер доменных событий
) : SaveChangesInterceptor
{
  public override async ValueTask<int> SavedChangesAsync(
   SaveChangesCompletedEventData data,
   int result,
   CancellationToken ct = default)
  {
    var events = data.Context!.ChangeTracker
     .Entries<Batch>()
     .SelectMany(e =>
     {
       var ev = e.Entity.DomainEvents.ToList();
       e.Entity.ClearDomainEvents();
       return ev;
     })
     .ToList();

     // … обрабатываем события с помощью диспетчера …

     return await base.SavedChangesAsync(data, result, ct);
  }
}

public sealed class BreweryDbContext(
 DbContextOptions<BreweryDbContext> opts)
  : DbContext(opts)
{
  public DbSet<Batch> Batches => Set<Batch>();

  protected override void OnModelCreating(ModelBuilder mb)
  {
    mb.ApplyConfigurationsFromAssembly(
      typeof(BreweryDbContext).Assembly);
  }
}

Batch batch = await context.Batches
 .SingleAsync(b => b.Id == batchId);

batch.AddReading(new Gravity(1.012m), timeProvider.GetUtcNow().UtcDateTime);

await context.SaveChangesAsync();

public sealed class BatchConfiguration
 : IEntityTypeConfiguration<Batch>
{
  public void Configure(EntityTypeBuilder<Batch> bld)
  {
    bld.ToTable("batches");
    bld.HasKey(b => b.Id);
    bld.Property(b => b.Id)
     .HasConversion(id => id.Value, 
       value => new BatchId(value))
     .ValueGeneratedNever();

    bld.Property(b => b.RecipeId)
     .HasConversion(id => id.Value,
      value => new RecipeId(value));
  }
}

// продолжение BatchConfiguration.Configure()
…
bld.HasMany<FermentationReading>("_readings")
 .WithOne()
 .HasForeignKey("batch_id");

bld.Navigation("_readings")
 .UsePropertyAccessMode(PropertyAccessMode.Field)
 .AutoInclude();

bld.Property<DateTime?>("_bottledAt")
  .HasColumnName("bottled_at");

var thisWeek = await context.Batches
  .Where(b => EF.Property<DateTime?>(b, "_bottledAt") >= weekAgo)
  .ToListAsync();

public sealed class Batch
{
  private readonly List<FermentationReading>
   _readings = [];
  private readonly List<IDomainEvent>
   _events = [];
  private DateTime? _bottledAt;

  private Batch() { } // Для EF Core

  private Batch(BatchId id, 
   RecipeId recipeId, Volume volume)
  {
    Id = id;
    RecipeId = recipeId;
    Volume = volume;
    Status = Status.Fermenting;
  }

  public BatchId Id { get; private set; }
  public RecipeId RecipeId { get; private set; }
  public BatchStatus Status { get; private set; }
  public Volume Volume { get; private set; }

  public IReadOnlyCollection<FermentationReading>
   Readings => _readings.AsReadOnly();
  public IReadOnlyCollection<IDomainEvent>
   DomainEvents => _events.AsReadOnly();

  public static Batch Start(
   RecipeId recipeId, Volume volume) =>
    new(new BatchId(Guid.CreateVersion7()), recipeId, volume);

  public void AddReading(
   Gravity gravity, DateTime takenAt)
  {
    if (Status != Status.Fermenting)
      throw new DomainException("Измерения доступны только в процессе ферментации.");

    _readings.Add(new FermentationReading(gravity, takenAt));
  }

  public void Bottle(TimeProvider tp)
  {
    if (Status != Status.Fermenting)
     throw new DomainException("Только ферментированная партия может быть бутилирована.");

    Gravity[] lastTwo = _readings
     .OrderBy(r => r.TakenAt)
     .TakeLast(2)
     .Select(r => r.Gravity)
     .ToArray();

    if (lastTwo.Length < 2 || lastTwo[0] != lastTwo[1])
      throw new DomainException("Плотность должна быть одинаковой в последних 2х измерениях.");

    Status = Status.Bottled;
    _bottledAt = tp.GetUtcNow().UtcDateTime;
    _events.Add(new BatchBottled(Id));
  }

  public void ClearDomainEvents() => _events.Clear();
}

public readonly record struct BatchId(Guid Value);
public readonly record struct RecipeId(Guid Value);
public readonly record struct Gravity(decimal Value);
public sealed record Volume(decimal Amount, string Unit);
public sealed record FermentationReading(decimal Gravity, DateTime TakenAt);

using System;
using System.Collections.Generic;

IReadOnlyList<string> log = ["start", "work", "done"];

Console.WriteLine(log[^1]); // done
Console.WriteLine(log[^2]); // work

public static class ReadOnlyListExtensions
{
  extension<T>(IReadOnlyList<T> list)
  {
    public T this[Index i] => 
     list[i.GetOffset(list.Count)];
  }
}

string? found = null;
outer: for (int x = 0; x < xMax; x++)
{
  for (int y = 0; y < yMax; y++)
  {
    if (GetValue(x, y) is { } value && value == target)
    {
      found = value;
      break outer;
    }
  }
}

row: for (int i = 0; i < rows; i++)
{
  for (int j = 0; j < cols; j++)
  {
    if (ShouldSkipRestOfRow(i, j)) continue row;
    Process(i, j);
  }
}

public record class Dog(string Name);
public record class Cat(int Lives);

public union Pet(Dog, Cat);

Pet pet = new Cat(9);

// Сопоставление с типом объединения
if (pet is Pet) // true
  Console.WriteLine("Это питомец");

// Сопоставление со значением
if (pet is Cat { Lives: > 0 } cat) // true
  Console.WriteLine($"У кошки {cat.Lives} жизней");

public closed record class Shape;
public record class Circle(double Radius) : Shape;
public record class Square(double Side) : Shape;

static double Area<T>(T shape) 
 where T : Shape => shape switch
{
  Circle(var r) => Math.PI * r * r,
  Square(var s) => s * s
};

var builder = WebApplication.CreateBuilder(args);

builder.Services
 .AddHttpClient("ApiClient", c =>
 {
   c.BaseAddress = new Uri("https://apiurl.com");
 })
 .AddTransientHttpErrorPolicy(p => 
  p.WaitAndRetryAsync(new[]
  {
    TimeSpan.FromSeconds(1),
    TimeSpan.FromSeconds(5),
    TimeSpan.FromSeconds(10)
  })
 );

var app = builder.Build();

app.MapGet("/external-api",
 async (IHttpClientFactory hcf) =>
 {
   var client = hcf.CreateClient("ApiClient");
   var response = await client.GetAsync("/data");
   return resp.IsSuccessStatusCode 
     ? Results.Ok(await resp.Content.ReadAsStringAsync()) 
     : Results.Problem();
 });

app.Run();

.AddTransientHttpErrorPolicy(p => 
  p.CircuitBreakerAsync(3, TimeSpan.FromMinutes(1)));

.AddTransientHttpErrorPolicy(p => 
  p.Or<TimeoutException>()
   .FallbackAsync(
    new HttpResponseMessage(HttpStatusCode.OK) 
     { Content = new StringContent("Резервный ответ") })
 );

EXPLAIN ANALYZE
SELECT * FROM orders WHERE total > 100;

ANALYZE orders;

-- Только для диагностики: посмотреть, как выглядит план без последовательного сканирования
SET enable_seqscan = off;

-- Самые медленные запросы по среднему времени 
SELECT query, calls, mean_exec_time
FROM pg_stat_statements
ORDER BY mean_exec_time DESC
LIMIT 10;

-- Сохраняем агрегированные данные в сводной таблице
CREATE TABLE sales_summary AS
SELECT product_id, SUM(quantity) AS total_sold
FROM order_details
GROUP BY product_id;

-- Храним агрегированные данные
CREATE MATERIALIZED VIEW mv_total_sales AS
SELECT product_id, SUM(quantity) AS total_qty
FROM order_details
GROUP BY product_id;

-- Уникальный индекс позволяет представлению обновляться без блокирования чтения 
CREATE UNIQUE INDEX idx_mv_total_sales_product
    ON mv_total_sales (product_id);

-- Обновление по расписанию; читатели будут получать старые данные до завершения обновления 
REFRESH MATERIALIZED VIEW CONCURRENTLY mv_total_sales;

WITH batch AS (
 DELETE FROM source_table
 WHERE ctid IN (
   SELECT ctid
   FROM source_table
   WHERE processed = false
   LIMIT 1000
 )
 RETURNING col1, col2
)
INSERT INTO archive_table (col1, col2)
SELECT col1, col2 FROM batch;

BEGIN;
UPDATE accounts
SET balance = balance - 100
WHERE account_id = 1;

INSERT INTO transactions (account_id, amount)
VALUES (1, -100);

COMMIT;

-- Плохо: соединение с suppliers, которая не используется 
SELECT p.product_name, c.category_name
FROM products p
JOIN categories c ON p.category_id = c.category_id
JOIN suppliers  s ON p.supplier_id = s.supplier_id;

SELECT p.product_name, c.category_name
FROM products p
JOIN categories c ON p.category_id = c.category_id;

-- Проверка существования: EXISTS останавливается на первом совпадении
SELECT c.customer_id, c.name
FROM customers c
WHERE EXISTS (
 SELECT 1 FROM orders o
 WHERE o.customer_id = c.customer_id
   AND o.total > 100
);

-- Плохо: подзапрос на каждую строку 
SELECT o.order_id,
  (SELECT c.name FROM customers c
   WHERE c.customer_id = o.customer_id) AS customer_name
FROM orders o;

-- Хорошо: одно соединение
SELECT o.order_id, c.name AS customer_name
FROM orders o
JOIN customers c ON o.customer_id = c.customer_id;

-- Плохо: подзапрос повторяется 
SELECT
  c.customer_id,
  c.name,
  (
    SELECT SUM(o.total_amount)
    FROM orders o
    WHERE o.customer_id = c.customer_id
      AND o.order_date >= DATE '2026-01-01'
  ) AS total_spent,
  (
    SELECT COUNT(*)
    FROM orders o
    WHERE o.customer_id = c.customer_id
      AND o.order_date >= DATE '2026-01-01'
  ) AS order_count
FROM customers c;

-- Хорошо: считаем результат один раз и переиспользуем 
WITH customer_order_totals AS (
  SELECT
    customer_id,
    SUM(total_amount) AS total_spent,
    COUNT(*) AS order_count
  FROM orders
  WHERE order_date >= DATE '2026-01-01'
  GROUP BY customer_id
)
SELECT
  c.customer_id, c.name,
  COALESCE(t.total_spent, 0) AS total_spent,
  COALESCE(t.order_count, 0) AS order_count
FROM customers c
LEFT JOIN customer_order_totals t ON t.customer_id = c.customer_id;

SELECT p.product_id, p.product_name
FROM products p
WHERE EXISTS (
  SELECT 1 FROM order_details od
  WHERE od.product_id = p.product_id
);

-- Плохо: извлечение всех столбцов
SELECT * FROM customers;

-- Хорошо: только используемые столбцы
SELECT customer_id, first_name, last_name
FROM customers;

SELECT o.order_id, o.total
FROM orders o
WHERE o.completed = true
  AND o.order_date >= '2026-01-01'
  AND o.order_date <  '2026-02-01';

-- Keyset-пагинация по индексированному столбцу
SELECT * FROM orders
WHERE order_id > 1000
ORDER BY order_id
LIMIT 10;

-- Читаем только записи, обновлённые с последнего запуска
SELECT * FROM records
WHERE modified_date > '2026-08-10 00:00';

-- Составной индекс для частой фильтрации по статусу и дате
CREATE INDEX idx_orders_status_order_date
  ON orders (status, order_date);

-- Добавляем часто читаемые данные
CREATE INDEX idx_orders_status_order_date_covering
  ON orders (status, order_date)
  INCLUDE (customer_id, total_amount);

SELECT customer_id, total_amount
FROM orders
WHERE status = 'paid'
 AND order_date >= DATE '2026-01-01';

-- Плохо: функция по order_date отключает сканирование по индексу
SELECT * FROM orders
WHERE EXTRACT(YEAR FROM order_date) = 2025;

-- Хорошо: диапазон по чистому значению столбца
SELECT * FROM orders
WHERE order_date >= '2025-01-01'
  AND order_date <  '2026-01-01';

-- Плохо: полное сканирование таблицы
SELECT * FROM customers
WHERE last_name LIKE '%son';

-- Хорошо: сканирование индекса по известному префиксу
SELECT * FROM customers
WHERE last_name LIKE 'Anders%';

CREATE TABLE logs (
  log_id     int PRIMARY KEY,
  event_date timestamptz NOT NULL,
  user_id    int NOT NULL
);