using System;

class Program
{
    static void Main()
    {
        int x = 10;

        Console.WriteLine(x++ + ++x);
    }
}

await GetUserAsync();
await GetOrdersAsync();
await GetRecommendationsAsync();

var userTask = GetUserAsync();
var ordersTask = GetOrdersAsync();
var recsTask = GetRecommendationsAsync();

await Task.WhenAll(userTask, ordersTask, recsTask);

var user = await userTask;
var orders = await ordersTask;
var recs = await recsTask;

Db.ChangeTracker.Clear();

public class IntegrationTestBase : IAsyncLifetime
{
    private static readonly PostgreSqlContainer _db =
        new PostgreSqlBuilder()
            .WithImage("postgres:16-alpine")
            .Build();

    private Respawner _respawner = null!;
    protected AppDbContext Db = null!;

    public async Task InitializeAsync()
    {
        await _db.StartAsync();

        var options = new DbContextOptionsBuilder<AppDbContext>()
            .UseNpgsql(_db.GetConnectionString())
            .Options;

        Db = new AppDbContext(options);

        // Реальные миграции - заодно проверяем, что они накатываются
        await Db.Database.MigrateAsync();

        await using var conn = new NpgsqlConnection(_db.GetConnectionString());
        await conn.OpenAsync();

        _respawner = await Respawner.CreateAsync(conn, new RespawnerOptions
        {
            DbAdapter = DbAdapter.Postgres,
            SchemasToInclude = ["public"]
        });
    }

    // Сброс данных перед каждым тестом - без пересоздания контейнера
    protected async Task ResetAsync()
    {
        await using var conn = new NpgsqlConnection(_db.GetConnectionString());
        await conn.OpenAsync();

        await _respawner.ResetAsync(conn);

        // Иначе тест может читать из кеша, а не из БД
        Db.ChangeTracker.Clear();
    }

    public Task DisposeAsync() => Task.CompletedTask;
}

public sealed class PaymentApiClient
{
    private readonly HttpClient _http;

    public PaymentApiClient(HttpClient http)
    {
        _http = http;
    }

    public async Task<string> GetStatusAsync(string id, CancellationToken ct)
    {
        using var response = await _http.GetAsync($"/payments/{id}", ct);

        response.EnsureSuccessStatusCode();

        return await response.Content.ReadAsStringAsync(ct);
    }
}

builder.Services.AddHttpClient<PaymentApiClient>(client =>
{
    client.BaseAddress = new Uri("https://payments.example.com");
    client.Timeout = TimeSpan.FromSeconds(10);
})
.ConfigurePrimaryHttpMessageHandler(() => new SocketsHttpHandler
{
    PooledConnectionLifetime = TimeSpan.FromMinutes(5),
    MaxConnectionsPerServer = 50
});

using System;
using System.Collections.Generic;
using System.Linq;

static IEnumerable<int> GetNumbers()
{
    Console.Write("A");
    yield return 1;

    Console.Write("B");
    yield return 2;
}

var query = GetNumbers().Where(x => x > 0);

Console.Write(query.First());
Console.Write(query.Count());

if (dict.TryGetValue(key, out var value))
{
    dict[key] = value + 1;
}
else
{
    dict[key] = 1;
}

using System.Runtime.InteropServices;

ref var count = ref CollectionsMarshal.GetValueRefOrAddDefault(
    dict,
    key,
    out var exists
);

if (!exists)
{
    count = 0;
}

count++;

public record User(string Name, int Age);

var a = new UserClass("Alice", 25);
var b = new UserClass("Alice", 25);

Console.WriteLine(a == b); // false

var a = new User("Alice", 25);
var b = new User("Alice", 25);

Console.WriteLine(a == b); // true

var user = new User("Alice", 25);

var updated = user with { Age = 26 };

Console.WriteLine(updated);
// User { Name = Alice, Age = 26 }

public record Team(string Name, List<string> Members);