Тип Record в C#

public class UserInfo
{
    public string Name { get; set; }
    public string Email { get; set; }
    public DateTime RegisteredDate { get; set; }
}

void ProcessUser(UserInfo user)
{
    // Где-то глубоко в коде
    if (string.IsNullOrEmpty(user.Email))
        user.Email = "[email protected]"; // Побочный эффект!
}

var user1 = new UserInfo { Name = "Иван", Email = "[email protected]" };
var user2 = new UserInfo { Name = "Иван", Email = "[email protected]" };
bool areEqual = user1 == user2; // Будет false!

var updatedUser = new UserInfo
{
    Name = user.Name,
    Email = "[email protected]", // Изменяем только это
    RegisteredDate = user.RegisteredDate
};

public record Person(string FirstName, string LastName);

public record Person
{
    public required string FirstName { get; init; }
    public required string LastName { get; init; }
}

public readonly record struct Point(double X, double Y, double Z);

public record MutablePerson
{
    public string FirstName { get; set; } = "";
    public string LastName { get; set; } = "";
}

var person1 = new Person("Иван", "Петров");
var person2 = new Person("Иван", "Петров");
 
bool areEqual = person1 == person2; // true для record, false для class

var ivan = new Person("Иван", "Петров");
var updatedIvan = ivan with { LastName = "Сидоров" };

var person = new Person("Иван", "Петров");
Console.WriteLine(person); // Выведет: Person { FirstName = Иван, LastName = Петров }

var user = new User("Алексей", "Иванов", 75000);
(string firstName, string lastName, int salary) = user;
Console.WriteLine($"{firstName} {lastName} зарабатывает {salary} руб/месяц");
 
record User(string FirstName, string LastName, int Salary);

public static decimal CalculateDiscount(Customer customer) =>
    customer switch
    {
        PremiumCustomer(_, _, int points) when points > 100 => 0.2m,
        PremiumCustomer => 0.1m,
        RegularCustomer(_, _, var purchaseCount) when purchaseCount > 10 => 0.05m,
        _ => 0m
    };
 
record Customer(string Name, string Email);
record RegularCustomer(string Name, string Email, int PurchaseCount) : Customer(Name, Email);
record PremiumCustomer(string Name, string Email, int LoyaltyPoints) : Customer(Name, Email);

public record Person(string FirstName, string LastName);
public record Employee(string FirstName, string LastName, string Department) 
    : Person(FirstName, LastName);

// Примерно так выглядит сгенерированный код
public override int GetHashCode()
{
    return HashCode.Combine(EqualityComparer<string>.Default.GetHashCode(FirstName),
                            EqualityComparer<string>.Default.GetHashCode(LastName));
}

public record Person(string FirstName, string LastName);

// Декомпилированная версия (упрощена для ясности)
public class Person : IEquatable<Person>
{
    protected virtual Type EqualityContract => typeof(Person);
    
    public string FirstName { get; init; }
    public string LastName { get; init; }
    
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
    
    public void Deconstruct(out string firstName, out string lastName)
    {
        firstName = FirstName;
        lastName = LastName;
    }
    
    public virtual bool Equals(Person? other)
    {
        if (other is null) return false;
        if (ReferenceEquals(this, other)) return true;
        return EqualityContract == other.EqualityContract && 
               EqualityComparer<string>.Default.Equals(FirstName, other.FirstName) && 
               EqualityComparer<string>.Default.Equals(LastName, other.LastName);
    }
    
    public override bool Equals(object? obj) => Equals(obj as Person);
    
    public override int GetHashCode()
    {
        return HashCode.Combine(EqualityContract, FirstName, LastName);
    }
    
    public static bool operator ==(Person? left, Person? right) => 
        (left is null && right is null) || (left?.Equals(right) ?? false);
    
    public static bool operator !=(Person? left, Person? right) => !(left == right);
    
    public virtual Person <Clone>$() => new Person(FirstName, LastName);
    
    protected virtual bool PrintMembers(StringBuilder builder)
    {
        builder.Append($"FirstName = {FirstName}, LastName = {LastName}");
        return true;
    }
    
    public override string ToString()
    {
        StringBuilder builder = new StringBuilder();
        builder.Append("Person { ");
        if (PrintMembers(builder))
            builder.Append(" ");
        builder.Append("}");
        return builder.ToString();
    }
}

public record struct Point3D(double X, double Y, double Z);
 
public void ProcessPoint()
{
    // Создается в стеке, нет выделения памяти в куче
    var point = new Point3D(1.0, 2.0, 3.0);
    
    // Ещё один объект в стеке, снова без выделения в куче
    var shifted = point with { X = point.X + 10 };
}

// Что вы пишете
var newPerson = person with { FirstName = "Петр" };
 
// Во что это превращается компилятором (примерно)
var clone = person.<Clone>$();
clone.FirstName = "Петр";
var newPerson = clone;

// Для record struct примерно так:
var clone = person; // Создается копия по значению
clone.FirstName = "Петр";
var newPerson = clone;

// Решение - использовать собственный метод Equals
public record ComplexEntity
{
    public required string Id { get; init; }
    public required string Name { get; init; }
    public List<SubEntity> Items { get; init; } = new();
    
    // Переопределяем равенство, чтобы сравнивать только по ID
    public virtual bool Equals(ComplexEntity? other)
    {
        if (other is null) return false;
        if (ReferenceEquals(this, other)) return true;
        return Id == other.Id; // Сравниваем только по ID для оптимизации
    }
    
    public override int GetHashCode() => Id.GetHashCode();
}

// IL-код для позиционного свойства FirstName (псевдокод)
.field private string '<FirstName>k__BackingField'
.property string FirstName()
{
    .get { return this.<FirstName>k__BackingField; }
    .set { this.<FirstName>k__BackingField = value; }
}

public class RegularClass
{
    public string Prop1 { get; set; } = "";
    public int Prop2 { get; set; }
}
 
public record RecordClass(string Prop1, int Prop2);
 
public readonly record struct RecordStruct(string Prop1, int Prop2);
 
// Результаты для 1 миллиона объектов (относительно):
// Создание: RegularClass: 1x, RecordClass: 1.1x, RecordStruct: 0.7x
// Сравнение: RegularClass: 1x, RecordClass: 2.5x, RecordStruct: 2.3x
// Копирование с изменением: RegularClass: 1x, RecordClass: 1.2x, RecordStruct: 0.8x

public record Person(string Name, List<string> Hobbies);
 
var john = new Person("John", new List<string> { "Reading", "Gaming" });
var jane = john with { Name = "Jane" };
 
// Изменение в списке хобби jane отразится в списке john!
jane.Hobbies.Add("Swimming");
Console.WriteLine(string.Join(", ", john.Hobbies)); // Выведет: Reading, Gaming, Swimming

public record ImmutablePerson(string Name, IReadOnlyList<string> Hobbies);

public record PersonWithCloning(string Name, List<string> Hobbies)
{
// Переопределяем метод клонирования
protected virtual Person <Clone>$()
{
    return new Person(Name, new List<string>(Hobbies)); // Глубокое копирование списка
}
}

var properties = typeof(Person).GetProperties();
// В properties будут не только FirstName и LastName, 
// но и EqualityContract, и другие служебные члены

// Для корректной десериализации нужен пустой конструктор
public record JsonPerson(string Name, int Age)
{
public JsonPerson() : this("", 0) { }
}

public class Cache<TKey, TValue> where TKey : notnull
{
private Dictionary<TKey, TValue> _cache = new();
// С записями в качестве TKey словарь будет работать корректно,
// благодаря правильной реализации GetHashCode() и Equals()
}

record CacheKey(int UserId, string Region, DateTime Date);
 
var cache = new Dictionary<CacheKey, UserData>();
var key = new CacheKey(123, "Europe", DateTime.Today);
cache[key] = new UserData();
 
// Позже в другом месте кода
var sameKey = new CacheKey(123, "Europe", DateTime.Today);
var data = cache[sameKey]; // Найдет данные, хотя это другой обьект

// Запись с изменяемым состоянием внутри
public record UserState(string Name, Dictionary<string, object> Metadata);
 
var state = new UserState("John", new Dictionary<string, object>());
// Хотя state - запись и "неизменяема", но ее Metadata можно менять!
state.Metadata["LastLogin"] = DateTime.Now;

// Традиционный подход с классами
public class BookDto
{
    public int Id { get; set; }
    public string Title { get; set; } = "";
    public string AuthorName { get; set; } = "";
}
 
// То же самое, но с записями
public record BookDto(int Id, string Title, string AuthorName);
 
// Для детальной информации о книге
public record BookDetailDto(int Id, string Title, int Year, decimal Price, 
                           string AuthorName, string Genre);

// Web API контроллер
[ApiController]
[Route("api/[controller]")]
public class BooksController : ControllerBase
{
    [HttpGet("{id}")]
    public ActionResult<BookDto> GetBook(int id)
    {
        // Получаем книгу из сервиса
        var book = _bookService.GetBook(id);
        
        // Преобразуем в DTO и возвращаем
        return new BookDto(book.Id, book.Title, book.Author.FullName);
    }
    
    [HttpPost]
    public ActionResult<BookDto> CreateBook(CreateBookDto bookDto)
    {
        // CreateBookDto - тоже запись
        var newBook = _bookService.AddBook(bookDto);
        return CreatedAtAction(nameof(GetBook), new { id = newBook.Id },
            new BookDto(newBook.Id, newBook.Title, newBook.Author.FullName));
    }
}
 
public record CreateBookDto(string Title, string AuthorName, int Year, decimal Price);

// Старая версия API
public record UserDtoV1(int Id, string Name, string Email);
 
// Новая версия с дополнительными полями
public record UserDtoV2(int Id, string Name, string Email, DateTime RegisteredDate, string? AvatarUrl) 
    : UserDtoV1(Id, Name, Email);
 
// В контроллере
[HttpGet("v1/users/{id}")]
public ActionResult<UserDtoV1> GetUserV1(int id) => GetUserInternal(id);
 
[HttpGet("v2/users/{id}")]
public ActionResult<UserDtoV2> GetUserV2(int id) => GetUserInternal(id);
 
private UserDtoV2 GetUserInternal(int id)
{
    var user = _userService.GetUser(id);
    return new UserDtoV2(user.Id, user.Name, user.Email, user.RegisteredDate, user.AvatarUrl);
}

public record RegistrationRequest
{
    public string Email { get; }
    public string Password { get; }
    public string ConfirmPassword { get; }
    
    public RegistrationRequest(string email, string password, string confirmPassword)
    {
        // Валидация на уровне конструктора
        if (string.IsNullOrWhiteSpace(email) || !email.Contains('@'))
            throw new ArgumentException("Invalid email format", nameof(email));
            
        if (string.IsNullOrWhiteSpace(password) || password.Length < 8)
            throw new ArgumentException("Password must be at least 8 characters", nameof(password));
            
        if (password != confirmPassword)
            throw new ArgumentException("Passwords do not match", nameof(confirmPassword));
            
        Email = email;
        Password = password;
        ConfirmPassword = confirmPassword;
    }
}

public record CustomerDto(string Name, string Email, string Phone);
 
public class CustomerValidator : AbstractValidator<CustomerDto>
{
    public CustomerValidator()
    {
        RuleFor(x => x.Name).NotEmpty().MaximumLength(100);
        RuleFor(x => x.Email).NotEmpty().EmailAddress();
        RuleFor(x => x.Phone).Matches(@"^\+?[0-9]{10,15}$");
    }
}
 
// Использование в контроллере
[HttpPost]
public ActionResult CreateCustomer(CustomerDto customer)
{
    var validator = new CustomerValidator();
    var result = validator.Validate(customer);
    
    if (!result.IsValid)
        return BadRequest(result.Errors);
        
    // Продолжаем обработку...
}

public record DatabaseConfig(string ConnectionString, int MaxPoolSize, int CommandTimeout);
public record EmailConfig(string SmtpServer, int Port, string Username, string Password, bool UseSsl);
public record AppConfig(string ApiKey, DatabaseConfig Database, EmailConfig Email);
 
// Использование с Microsoft.Extensions.Configuration
services.Configure<AppConfig>(configuration.GetSection("AppConfig"));
 
// Внедрение через DI
public class EmailService
{
    private readonly EmailConfig _config;
    
    public EmailService(IOptions<AppConfig> appConfig)
    {
        _config = appConfig.Value.Email;
    }
    
    // Использование конфигурации...
}

// Состояние пользовательской сессии
public record SessionState(
    User? CurrentUser,
    Dictionary<string, object> Items,
    DateTime LastActivity
);
 
// Изменение состояния возвращает новое состояние
public static class SessionManager
{
    public static SessionState SetUser(this SessionState state, User user)
        => state with { CurrentUser = user, LastActivity = DateTime.Now };
        
    public static SessionState AddItem(this SessionState state, string key, object value)
    {
        var newItems = new Dictionary<string, object>(state.Items) { [key] = value };
        return state with { Items = newItems, LastActivity = DateTime.Now };
    }
    
    public static SessionState RemoveItem(this SessionState state, string key)
    {
        if (!state.Items.ContainsKey(key))
            return state;
            
        var newItems = new Dictionary<string, object>(state.Items);
        newItems.Remove(key);
        return state with { Items = newItems, LastActivity = DateTime.Now };
    }
}
 
// Использование
var initialState = new SessionState(null, new Dictionary<string, object>(), DateTime.Now);
var loggedInState = initialState.SetUser(new User("john", "John Doe"));
var finalState = loggedInState.AddItem("preferences", new UserPreferences());

// Команды
public record CreateOrderCommand(Guid CustomerId, List<OrderItemDto> Items);
public record UpdateOrderStatusCommand(Guid OrderId, OrderStatus NewStatus);
 
// События
public record OrderCreatedEvent(Guid OrderId, Guid CustomerId, List<OrderItemDto> Items, DateTime CreatedAt);
public record OrderStatusChangedEvent(Guid OrderId, OrderStatus OldStatus, OrderStatus NewStatus, DateTime ChangedAt);
 
// DTO
public record OrderItemDto(Guid ProductId, int Quantity, decimal UnitPrice);

// Обработчик события
public class OrderEventHandler : IEventHandler<OrderCreatedEvent>
{
    public Task Handle(OrderCreatedEvent @event, CancellationToken cancellationToken)
    {
        // Создаем проекцию заказа на основе события
        var orderProjection = new OrderProjection(
            @event.OrderId,
            @event.CustomerId,
            @event.Items.Select(i => new OrderItemProjection(i.ProductId, i.Quantity, i.UnitPrice)).ToList(),
            @event.CreatedAt,
            OrderStatus.Created
        );
        
        // Сохраняем проекцию
        return _repository.SaveProjectionAsync(orderProjection, cancellationToken);
    }
}
 
// Проекция (тоже запись)
public record OrderProjection(
    Guid OrderId,
    Guid CustomerId,
    List<OrderItemProjection> Items,
    DateTime CreatedAt,
    OrderStatus Status
);
 
public record OrderItemProjection(Guid ProductId, int Quantity, decimal UnitPrice);

// Контракты для межсервисного взаимодействия
public record OrderPlacedMessage(Guid OrderId, Guid CustomerId, decimal TotalAmount);
public record PaymentProcessedMessage(Guid PaymentId, Guid OrderId, PaymentStatus Status);
 
// Отправка сообщения
await _publishEndpoint.Publish(new OrderPlacedMessage(
    order.Id,
    order.CustomerId,
    order.CalculateTotalAmount()
));
 
// Потребитель сообщения
public class PaymentConsumer : IConsumer<OrderPlacedMessage>
{
    public async Task Consume(ConsumeContext<OrderPlacedMessage> context)
    {
        var message = context.Message;
        
        // Обработка заказа...
        var paymentResult = await _paymentService.ProcessPayment(
            message.OrderId, 
            message.CustomerId, 
            message.TotalAmount
        );
        
        // Публикация результата
        await context.Publish(new PaymentProcessedMessage(
            paymentResult.PaymentId,
            message.OrderId,
            paymentResult.Status
        ));
    }
}

public record TransactionContext(Guid TransactionId, List<CompensationAction> CompensationActions);
public record CompensationAction(Guid ServiceId, string ActionType, string SerializedParameters);
 
// Выполнение действия с компенсацией
public async Task<Result> ExecuteWithCompensation(
    TransactionContext context,
    Func<Task<Result>> action,
    CompensationAction compensation)
{
    // Добавляем компенсирующее действие в контекст
    var updatedContext = context with 
    { 
        CompensationActions = new List<CompensationAction>(context.CompensationActions) { compensation }
    };
    
    // Сохраняем обновленный контекст
    await _transactionRepository.SaveContextAsync(updatedContext);
    
    // Выполняем действие
    var result = await action();
    
    if (!result.IsSuccess)
    {
        // Если что-то пошло не так, запускаем компенсацию
        await _compensationService.CompensateAsync(updatedContext);
    }
    
    return result;
}

public async Task<ProcessingResult> ProcessDataBatchAsync(List<DataItem> items)
{
    var initialState = new ProcessingState(
        ProcessedCount: 0,
        FailedCount: 0,
        Errors: new List<string>(),
        StartTime: DateTime.UtcNow
    );
    
    // Параллельная обработка с агрегацией результатов через неизменяемые состояния
    var finalState = await items
        .ToAsyncEnumerable()
        .ParallelForEachAsync(async (item, ct) =>
        {
            try
            {
                await _processor.ProcessItemAsync(item, ct);
                return new ProcessingState(1, 0, new List<string>(), default);
            }
            catch (Exception ex)
            {
                return new ProcessingState(0, 1, new List<string> { ex.Message }, default);
            }
        }, maxConcurrency: 10)
        .AggregateAsync(initialState, (current, update) => new ProcessingState(
            current.ProcessedCount + update.ProcessedCount,
            current.FailedCount + update.FailedCount,
            current.Errors.Concat(update.Errors).ToList(),
            current.StartTime
        ));
    
    var duration = DateTime.UtcNow - finalState.StartTime;
    return new ProcessingResult(
        finalState.ProcessedCount,
        finalState.FailedCount, 
        finalState.Errors,
        duration
    );
}
 
public record ProcessingState(int ProcessedCount, int FailedCount, List<string> Errors, DateTime StartTime);
public record ProcessingResult(int ProcessedCount, int FailedCount, List<string> Errors, TimeSpan Duration);

// Старый подход с классами
public class Money
{
    public decimal Amount { get; }
    public string Currency { get; }
 
    public Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency;
    }
 
    // Плюс десятки строк для Equals, GetHashCode, операторов сравнения...
}
 
// Новый подход с records
public record Money(decimal Amount, string Currency)
{
    public static Money Zero(string currency) => new(0, currency);
    
    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new InvalidOperationException("Cannot add different currencies");
        
        return this with { Amount = Amount + other.Amount };
    }
}

public record EmailMessage(
    string From,
    List<string> To,
    List<string> Cc,
    string Subject,
    string Body,
    List<Attachment> Attachments,
    bool IsHtml);
 
public class EmailBuilder
{
    private string _from = "";
    private List<string> _to = new();
    private List<string> _cc = new();
    private string _subject = "";
    private string _body = "";
    private List<Attachment> _attachments = new();
    private bool _isHtml = false;
 
    public EmailBuilder From(string from) { _from = from; return this; }
    public EmailBuilder To(string to) { _to.Add(to); return this; }
    public EmailBuilder Cc(string cc) { _cc.Add(cc); return this; }
    public EmailBuilder Subject(string subject) { _subject = subject; return this; }
    public EmailBuilder Body(string body) { _body = body; return this; }
    public EmailBuilder IsHtml(bool isHtml = true) { _isHtml = isHtml; return this; }
    public EmailBuilder Attach(Attachment attachment) { _attachments.Add(attachment); return this; }
 
    public EmailMessage Build() => new(
        _from, 
        new List<string>(_to), 
        new List<string>(_cc), 
        _subject, 
        _body, 
        new List<Attachment>(_attachments), 
        _isHtml);
}
 
// Использование
var email = new EmailBuilder()
    .From("[email protected]")
    .To("[email protected]")
    .Subject("Hello from Records")
    .Body("Check out this amazing feature!")
    .Build();

public abstract record Vehicle(string Model, int Year);
public record Car(string Model, int Year, int Doors) : Vehicle(Model, Year);
public record Motorcycle(string Model, int Year, bool HasSideCar) : Vehicle(Model, Year);
 
public static class VehicleFactory
{
    public static Vehicle CreateVehicle(string type, string model, int year)
        => type.ToLower() switch
        {
            "car" => new Car(model, year, 4),
            "sports-car" => new Car(model, year, 2),
            "motorcycle" => new Motorcycle(model, year, false),
            "sidecar" => new Motorcycle(model, year, true),
            _ => throw new ArgumentException($"Unknown vehicle type: {type}")
        };
}

// Originator - объект, состояние которого мы хотим сохранять
public class DocumentEditor
{
    private string _text = "";
    private int _cursorPosition = 0;
    private List<string> _selections = new();
    
    // Состояние редактора в виде записи
    public record EditorState(string Text, int CursorPosition, List<string> Selections);
    
    // Сохранение состояния
    public EditorState CreateMemento() => 
        new(_text, _cursorPosition, new List<string>(_selections));
    
    // Восстановление из состояния
    public void RestoreFromMemento(EditorState state)
    {
        _text = state.Text;
        _cursorPosition = state.CursorPosition;
        _selections = new List<string>(state.Selections);
    }
}
 
// Caretaker - хранитель состояний
public class DocumentHistory
{
    private Stack<DocumentEditor.EditorState> _history = new();
    
    public void SaveState(DocumentEditor editor) => 
        _history.Push(editor.CreateMemento());
    
    public void Undo(DocumentEditor editor)
    {
        if (_history.Count > 0)
            editor.RestoreFromMemento(_history.Pop());
    }
}

public abstract record Result<T>
{
    private Result() { } // Запрещаем прямое создание
 
    public record Success(T Value) : Result<T>;
    public record Failure(string Error) : Result<T>;
 
    // Упрощение работы с результатами
    public TResult Match<TResult>(
        Func<T, TResult> onSuccess,
        Func<string, TResult> onFailure) =>
        this switch
        {
            Success s => onSuccess(s.Value),
            Failure f => onFailure(f.Error),
            _ => throw new InvalidOperationException("Invalid result state")
        };
}
 
// Использование
public Result<User> GetUserById(int id)
{
    var user = _repository.FindById(id);
    if (user == null)
        return new Result<User>.Failure($"User with ID {id} not found");
    return new Result<User>.Success(user);
}
 
// Обработка результата
GetUserById(123).Match(
    user => Console.WriteLine($"Found: {user.Name}"),
    error => Console.WriteLine($"Error: {error}")
);

public class Base { } 
public record Derived : Base { } // Ошибка компиляции!

public record Person(string Name);
public record Employee(string Name, string Department) : Person(Name);
 
// А теперь попробуем:
Person person = new Employee("Иван", "ИТ");
var newPerson = person with { Name = "Петр" };
 
// Какой тип будет у newPerson? Person или Employee?
// И что случится с полем Department?

public record Person(string Name);
public record Employee(Person PersonInfo, string Department);
 
// Теперь без потери данных:
var employee = new Employee(new Person("Иван"), "ИТ");
var newEmployee = employee with { PersonInfo = employee.PersonInfo with { Name = "Петр" } };

// С таким определением будут проблемы:
public record User(int Id, string Name, string Email);
 
// Для EF Core лучше использовать:
public record User
{
    public int Id { get; init; }
    public required string Name { get; init; }
    public required string Email { get; init; }
    
    // Необходим пустой конструктор для EF Core!
    public User() { }
}

// Это НЕ работает с отслеживанием изменений EF Core
var updatedUser = user with { Email = "[email protected]" };
_context.SaveChanges(); // Изменения не сохранятся
 
// Приходится делать так:
_context.Entry(user).CurrentValues.SetValues(updatedUser);
_context.SaveChanges(); // Теперь изменения сохранятся

public record ComplexEntity(
    Guid Id,
    string Name,
    string Description,
    List<Item> Items,
    Dictionary<string, string> Metadata,
    // ... и еще много свойств
);

public record CacheKey(int UserId, string Resource, DateTime Date)
{
    // Переопределяем, чтобы использовать только поля, важные для кеширования
    public virtual bool Equals(CacheKey? other)
    {
        if (other is null) return false;
        if (ReferenceEquals(this, other)) return true;
        return UserId == other.UserId && Resource == other.Resource; // Игнорируем Date
    }
 
    public override int GetHashCode() => HashCode.Combine(UserId, Resource);
}

// Проблема с десериализацией без пустого конструктора
public record ApiResponse(bool Success, string Message, object? Data);
 
// JSON: {"Success":true,"Message":"OK","Data":null}
 
// Нужны либо пустой конструктор, либо специальная настройка JsonSerializer:
var options = new JsonSerializerOptions
{
    PropertyNameCaseInsensitive = true
};
var response = JsonSerializer.Deserialize<ApiResponse>(json, options);

// Проблема циклической зависимости с записями
public record Department(string Name, Employee? Manager);
public record Employee(string Name, Department Department);
 
// Как создать такие объекты, если они ссылаются друг на друга?
// С обычными классами это просто:
var dept = new Department { Name = "ИТ" };
var emp = new Employee { Name = "Иван", Department = dept };
dept.Manager = emp; // С записями так не получится!

// Традиционный ООП подход
public class Order
{
    public Guid Id { get; }
    public List<OrderItem> Items { get; private set; }
    public OrderStatus Status { get; private set; }
    
    public void AddItem(OrderItem item) {
        Items.Add(item);
        RecalculateTotal();
    }
    
    public void ChangeStatus(OrderStatus status) {
        // Логика проверки и изменения статуса
        Status = status;
    }
}
 
// Подход с записями
public record OrderData(Guid Id, IReadOnlyList<OrderItemData> Items, OrderStatus Status, decimal Total);
public record OrderItemData(Guid ProductId, int Quantity, decimal UnitPrice);
 
public class OrderService
{
    public OrderData AddItem(OrderData order, OrderItemData newItem)
    {
        var items = order.Items.ToList();
        items.Add(newItem);
        var total = CalculateTotal(items);
        return order with { Items = items, Total = total };
    }
    
    public OrderData ChangeStatus(OrderData order, OrderStatus newStatus)
    {
        // Логика проверки
        return order with { Status = newStatus };
    }
}

// Доменные модели как record типы
public record ProductItem(Guid Id, string Name, decimal Price, string Category);
public record OrderItem(ProductItem Product, int Quantity)
{
    public decimal TotalPrice => Product.Price * Quantity;
}
public record Order(Guid Id, Guid CustomerId, List<OrderItem> Items, OrderStatus Status, DateTime CreatedAt)
{
    public decimal TotalAmount => Items.Sum(i => i.TotalPrice);
}
public enum OrderStatus { Created, Paid, Shipped, Delivered, Cancelled }
 
// DTO для API
public record ProductDto(Guid Id, string Name, decimal Price, string Category);
public record OrderItemDto(Guid ProductId, string ProductName, decimal UnitPrice, int Quantity, decimal TotalPrice);
public record OrderDto(Guid Id, Guid CustomerId, List<OrderItemDto> Items, OrderStatus Status, DateTime CreatedAt, decimal TotalAmount);

public class OrderService
{
    private readonly IRepository<Order> _orderRepo;
    private readonly IRepository<ProductItem> _productRepo;
    
    // Добавление товара в заказ
    public async Task<Order> AddItemToOrderAsync(Guid orderId, Guid productId, int quantity)
    {
        var order = await _orderRepo.GetByIdAsync(orderId);
        var product = await _productRepo.GetByIdAsync(productId);
        
        // Если товар уже в заказе - увеличиваем количество
        var existingItem = order.Items.FirstOrDefault(i => i.Product.Id == productId);
        if (existingItem != null)
        {
            var newItems = order.Items.Select(item => 
                item.Product.Id == productId 
                    ? existingItem with { Quantity = existingItem.Quantity + quantity }
                    : item
            ).ToList();
            
            var updatedOrder = order with { Items = newItems };
            return await _orderRepo.UpdateAsync(updatedOrder);
        }
        
        // Иначе добавляем новый товар
        var orderItem = new OrderItem(product, quantity);
        var items = new List<OrderItem>(order.Items) { orderItem };
        var newOrder = order with { Items = items };
        
        return await _orderRepo.UpdateAsync(newOrder);
    }
    
    // Изменение статуса заказа
    public async Task<Order> ChangeOrderStatusAsync(Guid orderId, OrderStatus newStatus)
    {
        var order = await _orderRepo.GetByIdAsync(orderId);
        var updatedOrder = order with { Status = newStatus };
        return await _orderRepo.UpdateAsync(updatedOrder);
    }
}

[ApiController]
[Route("api/[controller]")]
public class OrdersController : ControllerBase
{
    private readonly OrderService _orderService;
    
    [HttpGet("{id}")]
    public async Task<ActionResult<OrderDto>> GetOrder(Guid id)
    {
        var order = await _orderService.GetOrderAsync(id);
        return Ok(MapToDto(order));
    }
    
    [HttpPost("{id}/items")]
    public async Task<ActionResult<OrderDto>> AddOrderItem(Guid id, [FromBody] AddItemRequest request)
    {
        var order = await _orderService.AddItemToOrderAsync(id, request.ProductId, request.Quantity);
        return Ok(MapToDto(order));
    }
    
    [HttpPut("{id}/status")]
    public async Task<ActionResult<OrderDto>> UpdateStatus(Guid id, [FromBody] UpdateStatusRequest request)
    {
        var order = await _orderService.ChangeOrderStatusAsync(id, request.Status);
        return Ok(MapToDto(order));
    }
    
    // Маппинг от доменной модели к DTO
    private OrderDto MapToDto(Order order) => new(
        order.Id,
        order.CustomerId,
        order.Items.Select(i => new OrderItemDto(
            i.Product.Id,
            i.Product.Name,
            i.Product.Price,
            i.Quantity,
            i.TotalPrice
        )).ToList(),
        order.Status,
        order.CreatedAt,
        order.TotalAmount
    );
}
 
// Модели запросов
public record AddItemRequest(Guid ProductId, int Quantity);
public record UpdateStatusRequest(OrderStatus Status);