Record в C#

public record Person(string FirstName, string LastName);

// C# 10+
public record struct Point(int X, int Y);

var john = new Person("John", "Doe");
var jane = john with { FirstName = "Jane" }; // Создание нового объекта на основе существующего

// Позиционный синтаксис (самый краткий)
public record Person(string FirstName, string LastName);
 
// Синтаксис, похожий на класс (больше контроля)
public record Person
{
    public string FirstName { get; init; }
    public string LastName { get; init; }
    
    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
}

// Класс
public class PersonClass
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    
    public PersonClass(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }
    
    public override bool Equals(object obj)
    {
        // 10-15 строк кода для корректного сравнения
    }
    
    public override int GetHashCode()
    {
        // 3-5 строк для корректного хеширования
    }
}
 
// Структура
public struct PersonStruct
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    
    // Аналогичные методы для Equals и GetHashCode
}
 
// Record
public record PersonRecord(string FirstName, string LastName);

var person = new PersonRecord("John", "Doe");
// Следующая строка вызовет ошибку компиляции
// person.FirstName = "Jane";

var johnDoe = new PersonRecord("John", "Doe");
var janeDoe = johnDoe with { FirstName = "Jane" };

var person = new PersonRecord("John", "Doe");
var (firstName, lastName) = person; // Деконструкция
Console.WriteLine($"First: {firstName}, Last: {lastName}");

public record struct Point(int X, int Y);

object person = new PersonRecord("John", "Doe");
 
string result = person switch
{
    PersonRecord("John", _) => "Hello, John!",
    PersonRecord(_, "Smith") => "Hello, Mr. Smith!",
    PersonRecord(var first, var last) => $"Hello, {first} {last}!",
    _ => "Who are you?"
};

// Тест на создание 1 000 000 объектов
var sw = Stopwatch.StartNew();
for (int i = 0; i < 1_000_000; i++)
{
    var person = new PersonRecord("John", "Doe");
}
sw.Stop();
Console.WriteLine($"Record creation: {sw.ElapsedMilliseconds} ms");
 
// Аналогичные тесты для класса и структуры

public record Person(string Name);
public record Employee(string Name, string Department) : Person(Name);

Employee emp = new Employee("John", "IT");
// Результат будет типа Employee, а не Person!
var person = emp with { Department = null };

var person = new PersonRecord("John", "Doe");
// System.Text.Json
string json = JsonSerializer.Serialize(person);
var deserialized = JsonSerializer.Deserialize<PersonRecord>(json);
 
// Newtonsoft.Json
string json2 = JsonConvert.SerializeObject(person);
var deserialized2 = JsonConvert.DeserializeObject<PersonRecord>(json2);

public record UserPreferences(
    ImmutableList<string> FavoriteTags,
    ImmutableDictionary<string, bool> Settings
);
 
var prefs = new UserPreferences(
    ImmutableList.Create("csharp", "programming"),
    ImmutableDictionary.CreateRange(new[] { 
        KeyValuePair.Create("darkMode", true), 
        KeyValuePair.Create("notifications", false) 
    })
);
 
// Обновление настроек без мутации
var newPrefs = prefs with { 
    FavoriteTags = prefs.FavoriteTags.Add("dotnet"),
    Settings = prefs.Settings.SetItem("autoSave", true)
};

IObservable<UserActionRecord> actions = ... // поток действий пользователя
 
actions
    .Where(action => action.Type == ActionType.SaveDocument)
    .Select(action => action with { Timestamp = DateTime.Now })
    .Subscribe(action => ProcessSaveAction(action));

public readonly record struct ProcessingResult(int Count, ReadOnlySpan<byte> Data);
 
public ProcessingResult ProcessData(ReadOnlySpan<byte> input)
{
    // Обработка данных...
    return new ProcessingResult(42, input.Slice(0, 10));
}

public record UserData(string Name, List<string> Permissions);
 
var user = new UserData("Admin", new List<string> { "read", "write" });
user.Permissions.Add("delete"); // Это работает!

public class ProductDto
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public string Description { get; set; }
    public string[] Categories { get; set; }
    
    // Конструктор, Equals, GetHashCode, ToString...
    // Еще 50+ строк кода...
}

public record ProductDto(
    int Id, 
    string Name, 
    decimal Price, 
    string Description, 
    string[] Categories);

public record BaseEvent(Guid Id, DateTime Timestamp);
public record UserCreatedEvent(Guid Id, DateTime Timestamp, string Username) 
    : BaseEvent(Id, Timestamp);

// Доменная модель
public class Product
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    // ... другие свойства и методы
}
 
// DTO на основе record
public record ProductDto(int Id, string Name);
 
// Конфигурация AutoMapper
cfg.CreateMap<Product, ProductDto>();

public record CreateProductCommand(
    string Name, 
    decimal Price, 
    string Description, 
    string[] Categories) : IRequest<Result<int>>;

public class CreateProductCommandHandler 
    : IRequestHandler<CreateProductCommand, Result<int>>
{
    // Реализация...
}

public record CreateProductCommand(/* ... */) : IRequest<Result<int>>;
 
public class CreateProductCommandValidator : AbstractValidator<CreateProductCommand>
{
    public CreateProductCommandValidator()
    {
        RuleFor(x => x.Name).NotEmpty().MaximumLength(100);
        RuleFor(x => x.Price).GreaterThan(0);
        // Другие правила...
    }
}
 
// Использование
public async Task<Result<int>> Handle(CreateProductCommand command, CancellationToken token)
{
    var validator = new CreateProductCommandValidator();
    var validationResult = await validator.ValidateAsync(command, token);
    
    if (!validationResult.IsValid)
        return Result.Failure<int>(validationResult.Errors.Select(e => e.ErrorMessage).ToArray());
    
    // Логика обработки...
}

// Раньше - десятки строк кода
public class Money
{
    public decimal Amount { get; }
    public string Currency { get; }
    
    public Money(decimal amount, string currency)
    {
        Amount = amount;
        Currency = currency?.ToUpperInvariant() ?? throw new ArgumentNullException(nameof(currency));
    }
    
    // Equals, GetHashCode, операторы == и != ...
}
 
// Теперь - просто и элегантно
public record Money(decimal Amount, string Currency)
{
    public Money(decimal amount, string currency) 
        : this(amount, currency?.ToUpperInvariant() ?? throw new ArgumentNullException(nameof(currency)))
    {
    }
}

// Команда
public record AddItemToCartCommand(Guid CartId, Guid ProductId, int Quantity) : ICommand<Result>;
 
// Запрос
public record GetCartQuery(Guid CartId) : IQuery<Result<CartDto>>;
 
// DTO для результата
public record CartDto(Guid Id, IReadOnlyList<CartItemDto> Items, decimal TotalPrice);
public record CartItemDto(Guid ProductId, string ProductName, int Quantity, decimal Price);

// Занимает больше памяти (хранится в куче)
public record PointRecord(double X, double Y);
 
// Занимает меньше памяти (хранится в стеке)
public record struct PointStruct(double X, double Y);

object message = GetMessage(); // Получаем сообщение откуда-то
 
var result = message switch
{
    UserCreatedEvent(_, _, var username) => $"Пользователь {username} создан",
    ItemAddedToCartEvent(_, _, var productId, var quantity) => $"Добавлено {quantity} единиц товара {productId}",
    OrderCompletedEvent { OrderTotal: > 1000 } => "Завершен крупный заказ",
    _ => "Неизвестное сообщение"
};

// Явно указываем, что Name не может быть null
public record User(string Name, string? Bio);
 
// Компилятор предупредит, если мы попытаемся сделать это
User user = new User(null!, "Some bio"); // Предупреждение компилятора
 
// А тут всё в порядке
User user2 = new User("John", null);

public record ApplicationState(
    bool IsLoading,
    User? CurrentUser,
    ImmutableList<Notification> Notifications);
 
// Потокобезопасное обновление
public ApplicationState AddNotification(ApplicationState state, Notification notification)
{
    return state with { 
        Notifications = state.Notifications.Add(notification) 
    };
}

public abstract record DomainEvent(Guid Id, DateTime OccurredAt);
 
public record OrderCreatedEvent(
    Guid Id, 
    DateTime OccurredAt,
    Guid OrderId, 
    Guid CustomerId,
    ImmutableList<OrderLineItem> Items,
    decimal TotalAmount) : DomainEvent(Id, OccurredAt);
 
public record OrderLineItem(Guid ProductId, string ProductName, int Quantity, decimal UnitPrice);

// API v1
namespace MyApi.V1.Models
{
    public record ProductDto(int Id, string Name, decimal Price);
}
 
// API v2 - добавились новые поля
namespace MyApi.V2.Models
{
    public record ProductDto(int Id, string Name, decimal Price, string Description, string[] Categories);
}
 
// Контроллеры
[ApiController]
[Route("api/v1/products")]
public class ProductsV1Controller : ControllerBase
{
    [HttpGet("{id}")]
    public ActionResult<V1.Models.ProductDto> GetProduct(int id) { /* ... */ }
}
 
[ApiController]
[Route("api/v2/products")]
public class ProductsV2Controller : ControllerBase
{
    [HttpGet("{id}")]
    public ActionResult<V2.Models.ProductDto> GetProduct(int id) { /* ... */ }
}

public class ProductsCache
{
    private readonly MemoryCache _cache = new MemoryCache(new MemoryCacheOptions());
 
    public ProductDto GetOrCreate(int id, Func<int, ProductDto> factory)
    {
        if (_cache.TryGetValue(id, out ProductDto cachedProduct))
            return cachedProduct;
 
        var product = factory(id);
        _cache.Set(id, product, TimeSpan.FromMinutes(10));
        return product;
    }
 
    // С Records нам не нужно беспокоиться о том, что закешированный объект 
    // может быть изменен после возврата из метода
}

// Определение типа
public record UserType(
    Guid Id, 
    string Username, 
    string Email, 
    string? AvatarUrl, 
    DateTime CreatedAt,
    ImmutableList<PostType> Posts);
 
public record PostType(
    Guid Id, 
    string Title, 
    string Content, 
    DateTime CreatedAt);
 
// Резолвер
public class Query
{
    public async Task<UserType> GetUser(Guid id, [Service] IUserRepository repository)
    {
        var user = await repository.GetByIdAsync(id);
        return MapToUserType(user);
    }
}

public record OrderSubmittedEvent(
    Guid OrderId,
    Guid CustomerId,
    ImmutableList<OrderItemDto> Items,
    decimal TotalAmount,
    DateTime SubmittedAt);
 
// Публикация
await _publishEndpoint.Publish(new OrderSubmittedEvent(
    order.Id,
    order.CustomerId,
    order.Items.Select(i => new OrderItemDto(i.ProductId, i.Quantity, i.Price)).ToImmutableList(),
    order.TotalAmount,
    DateTime.UtcNow));
 
// Обработка
public class OrderSubmittedConsumer : IConsumer<OrderSubmittedEvent>
{
    public async Task Consume(ConsumeContext<OrderSubmittedEvent> context)
    {
        var @event = context.Message;
        // Обработка события
    }
}

[Fact]
public async Task CreateProduct_WithValidData_ReturnsCreatedResult()
{
    // Arrange
    var command = new CreateProductCommand("Test Product", 19.99m, "Description", new[] { "Category1" });
    
    // Act
    var result = await _controller.CreateProduct(command);
    
    // Assert
    var createdResult = Assert.IsType<CreatedAtActionResult>(result);
    var returnValue = Assert.IsType<ProductDto>(createdResult.Value);
    Assert.Equal(command.Name, returnValue.Name);
}

public record Transaction(
    Guid Id,
    Guid AccountId,
    decimal Amount,
    string Description,
    TransactionType Type,
    DateTime ProcessedAt);
 
public enum TransactionType { Deposit, Withdrawal, Transfer }
 
// В сервисе
public async Task<Result<Transaction>> ProcessDeposit(Guid accountId, decimal amount, string description)
{
    // Проверки и бизнес-логика
    var transaction = new Transaction(
        Guid.NewGuid(),
        accountId,
        amount,
        description,
        TransactionType.Deposit,
        DateTime.UtcNow);
    
    await _transactionRepository.AddAsync(transaction);
    return Result.Success(transaction);
}

public record LogEntry(
    string Message,
    LogLevel Level,
    DateTime Timestamp,
    string? Exception = null,
    ImmutableDictionary<string, object>? Properties = null);
 
// Логирование
_logger.LogInformation(
    new LogEntry(
        "User profile updated",
        LogLevel.Information,
        DateTime.UtcNow,
        Properties: ImmutableDictionary.CreateRange(new Dictionary<string, object>
        {
            ["UserId"] = userId,
            ["Changes"] = changesCount
        })));

// Запрос к платежному шлюзу
public record PaymentRequest(
    string MerchantId,
    string OrderId,
    decimal Amount,
    string Currency,
    CardInfo Card);
 
public record CardInfo(
    string Number,
    string HolderName,
    string ExpiryMonth,
    string ExpiryYear,
    string Cvv);
 
// Ответ платежного шлюза
public record PaymentResponse(
    bool Success,
    string TransactionId,
    string? ErrorCode = null,
    string? ErrorMessage = null);
 
// Использование
var request = new PaymentRequest(
    "MERCHANT123",
    orderId.ToString(),
    orderAmount,
    "USD",
    new CardInfo(
        cardNumber,
        cardHolderName,
        expiryMonth,
        expiryYear,
        cvv));
 
var response = await _paymentGateway.ProcessPaymentAsync(request);

// Это не скомпилируется!
public class BaseEntity
{
    public Guid Id { get; set; }
}
 
public record UserRecord(Guid Id, string Name) : BaseEntity; // Ошибка!

public record Person(string Name);
public record Employee(string Name, string Department) : Person(Name);
 
Employee emp = new Employee("John", "IT");
// Ожидаем получить Person, но получим Employee с пустым Department!
var person = emp with { Department = null };

public record UserPreferences(string Theme, List<string> FavoriteTags);
 
var prefs = new UserPreferences("dark", new List<string> { "csharp", "dotnet" });
prefs.FavoriteTags.Add("azure"); // Это изменит внутреннее состояние!

public record UserPreferences(string Theme, ImmutableList<string> FavoriteTags);
 
var prefs = new UserPreferences(
    "dark",
    ImmutableList.Create("csharp", "dotnet"));
 
// Теперь нельзя изменить список напрямую
// А только создать новый объект
var newPrefs = prefs with { 
    FavoriteTags = prefs.FavoriteTags.Add("azure") 
};

// Так не заработает с EF Core
public record Product(int Id, string Name, decimal Price);

// Сущность EF - обычный класс
public class ProductEntity
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}
 
// DTO - Record
public record ProductDto(int Id, string Name, decimal Price);
 
// Маппинг
var product = _mapper.Map<ProductDto>(productEntity);

// Это работает для классов с пустым конструктором
var instance = Activator.CreateInstance(typeof(MyClass));
 
// Но для Records с позиционными параметрами нужно знать все аргументы
var record = Activator.CreateInstance(
    typeof(MyRecord),
    new object[] { "arg1", "arg2" });

// Если у BigRecord 50+ свойств, такая операция создаст копию всех полей
var newRecord = existingBigRecord with { OneProperty = newValue };

// До Records
public class PaymentMessage
{
public Guid Id { get; set; }
public string CustomerId { get; set; }
public decimal Amount { get; set; }
public string Currency { get; set; }
public PaymentStatus Status { get; set; }
public DateTime ProcessedAt { get; set; }
 
// Переопределения Equals, GetHashCode, ToString...
// Дополнительные методы для безопасного копирования...
}

// После Records
public record PaymentMessage(
Guid Id,
string CustomerId,
decimal Amount,
string Currency,
PaymentStatus Status,
DateTime ProcessedAt);

public abstract record InventoryEvent(Guid Id, DateTime Timestamp, Guid WarehouseId);
 
public record ItemReceivedEvent(
Guid Id,
DateTime Timestamp,
Guid WarehouseId,
Guid ProductId,
int Quantity,
string BatchNumber) : InventoryEvent(Id, Timestamp, WarehouseId);
 
public record ItemShippedEvent(
Guid Id,
DateTime Timestamp,
Guid WarehouseId,
Guid ProductId,
int Quantity,
Guid OrderId) : InventoryEvent(Id, Timestamp, WarehouseId);

public record InventoryProjection(
Guid WarehouseId,
ImmutableDictionary<Guid, int> StockLevels);
 
public InventoryProjection ApplyEvent(InventoryProjection projection, InventoryEvent @event)
{
return @event switch
{
    ItemReceivedEvent e => projection with {
        StockLevels = projection.StockLevels.SetItem(
            e.ProductId,
            projection.StockLevels.GetValueOrDefault(e.ProductId) + e.Quantity)
    },
    ItemShippedEvent e => projection with {
        StockLevels = projection.StockLevels.SetItem(
            e.ProductId,
            projection.StockLevels.GetValueOrDefault(e.ProductId) - e.Quantity)
    },
    _ => projection
};
}

public record SearchQuery(
string Term,
ImmutableList<string> Filters,
int Page,
int PageSize,
SortDirection SortBy);
 
// Использование в кеше
public class SearchCache
{
private readonly MemoryCache _cache = new(new MemoryCacheOptions());
 
public SearchResult GetOrCompute(SearchQuery query, Func<SearchQuery, SearchResult> searcher)
{
    // Благодаря корректной реализации GetHashCode и Equals в Records,
    // поиск в кеше работает корректно даже для сложных объектов
    if (_cache.TryGetValue(query, out SearchResult cachedResult))
        return cachedResult;
 
    var result = searcher(query);
    _cache.Set(query, result, TimeSpan.FromMinutes(5));
    return result;
}
}

public record AccountState(
Guid Id,
decimal Balance,
ImmutableList<TransactionRecord> Transactions);
 
public record TransactionRecord(
Guid Id,
DateTime Timestamp,
decimal Amount,
string Description);
 
public AccountState ApplyTransaction(AccountState account, decimal amount, string description)
{
var transaction = new TransactionRecord(
    Guid.NewGuid(),
    DateTime.UtcNow,
    amount,
    description);
 
return account with
{
    Balance = account.Balance + amount,
    Transactions = account.Transactions.Add(transaction)
};
}

public record UserEvent(
Guid UserId,
string EventType,
DateTime Timestamp,
ImmutableDictionary<string, string> Attributes);
 
public record DailyUserStats(
DateTime Date,
int UniqueUsers,
int SessionCount,
int PageViews,
ImmutableDictionary<string, int> EventCounts);
 
// Функциональный стиль обработки потока событий
public DailyUserStats AggregateEvents(DailyUserStats current, UserEvent @event)
{
if (@event.Timestamp.Date != current.Date)
    return current;
 
var eventCounts = current.EventCounts;
if (eventCounts.ContainsKey(@event.EventType))
    eventCounts = eventCounts.SetItem(@event.EventType, eventCounts[@event.EventType] + 1);
else
    eventCounts = eventCounts.Add(@event.EventType, 1);
 
return current with
{
    PageViews = @event.EventType == "page_view" ? current.PageViews + 1 : current.PageViews,
    EventCounts = eventCounts
};
}

// Без Records
public class Transaction
{
public Guid Id { get; }
public decimal Amount { get; }
public string Description { get; }
// ...другие свойства
 
// ToString() либо отсутствует, либо требует ручной реализации
}
 
// С Records
public record Transaction(
Guid Id,
decimal Amount,
string Description);
 
// При отладке:
// Transaction { Id = 7f8d9a23-..., Amount = 125.50, Description = "Grocery shopping" }

public class RecordChangeTrackingInterceptor : IInterceptor
{
public void Intercept(IInvocation invocation)
{
    if (invocation.Method.Name.StartsWith("With"))
    {
        var before = invocation.InvocationTarget;
        invocation.Proceed();
        var after = invocation.ReturnValue;
        
        Console.WriteLine($"Record changed: {before} -> {after}");
    }
    else
    {
        invocation.Proceed();
    }
}
}

// До оптимизации: выделение в куче
public record CoordinateRecord(double Latitude, double Longitude);
 
// После оптимизации: выделение в стеке
public readonly record struct CoordinateStruct(double Latitude, double Longitude);