Возможности и нововведения C# 14

var fruits = new List<string> { "apple", "banana", "cherry" };

var fruits = ["apple", "banana", "cherry"];

// Массив
string[] fruitsArray = ["apple", "banana", "cherry"];
 
// ReadOnlySpan
ReadOnlySpan<string> fruitsSpan = ["apple", "banana", "cherry"];
 
// Собстевенные коллекции с соответствующими конструкторами
CustomCollection<string> customFruits = ["apple", "banana", "cherry"];

var matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

var result = numbers switch
{
    [] => "Пустая коллекция",
    [var first] => $"Один элемент: {first}",
    [var first, var second] => $"Два элемента: {first}, {second}",
    [var first, .. var middle, var last] => $"Много элементов, первый: {first}, последний: {last}",
    _ => "Что-то пошло не так"
};

if (data is [var x, var y, var z])
{
    // У нас есть коллекция с точно тремя элементами
    Console.WriteLine($"Точные координаты: {x}, {y}, {z}");
}
else if (data is [var first, .. var rest])
{
    // Коллекция с хотя бы одним элементом
    Console.WriteLine($"Первый элемент: {first}, всего элементов: {rest.Length + 1}");
}

public static CommandLineOptions Parse(string[] args)
{
    return args switch
    {
        [] => new CommandLineOptions { Help = true }, // Пустые аргументы -> показать справку
        
        ["help" or "-h" or "--help", .. var rest] => new CommandLineOptions { Help = true },
        
        ["-f" or "--file", var filename, .. var rest] => 
            new CommandLineOptions { 
                InputFile = filename, 
                Verbose = rest.Contains("-v") || rest.Contains("--verbose") 
            },
            
        [var firstArg, .. var rest] when firstArg.StartsWith("-") => 
            throw new ArgumentException($"Неизвестный параметр: {firstArg}"),
            
        _ => throw new ArgumentException("Некорректные аргументы командной строки")
    };
}

ReadOnlySpan<int> GetFirstThreeResults()
{
    return [GetResult1(), GetResult2(), GetResult3()];
}

var processedData = rawData
    .Where(item => item is [var id, var name, .. var details] && id > 0)
    .Select(item => new { 
        Id = item[0], 
        Name = item[1], 
        HasDetails = item.Length > 2 
    })
    .ToList();

var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
 
// Получение первых трёх элементов
var firstThree = numbers[..3]; // [1, 2, 3]
 
// Получение последних трёх элементов
var lastThree = numbers[^3..]; // [8, 9, 10]
 
// Получение диапазона элементов
var middleThree = numbers[3..6]; // [4, 5, 6]

var isValidSequence = sequence switch
{
    [var header, .. var payload, var checksum] when ValidateChecksum(payload, checksum) => true,
    _ => false
};

async IAsyncEnumerable<int> GetNumbersAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task.Delay(100); // Имитируем асинхронную работу
        yield return i;
    }
}
 
// Использование с коллекционными выражениями
async Task ProcessDataAsync()
{
    var asyncData = await CollectAsync(GetNumbersAsync());
    
    // Использование паттерн-матчинга с асинхронно полученной коллекцией
    var result = asyncData switch
    {
        [] => "Пусто",
        [var single] => $"Один элемент: {single}",
        [var first, var second, ..] => $"Минимум два элемента: {first}, {second}, ...",
    };
    
    Console.WriteLine(result);
}
 
// Вспомогательный метод для сбора асинхронной последовательности
async Task<List<T>> CollectAsync<T>(IAsyncEnumerable<T> source)
{
    var result = new List<T>();
    await foreach (var item in source)
    {
        result.Add(item);
    }
    return result;
}

object data = new[] { 1, new[] { 2, 3 }, 4 };
 
var description = data switch
{
    [var first, [var nested1, var nested2], var last] => 
        $"Вложенная структура: {first}, [{nested1}, {nested2}], {last}",
    
    [var first, .. var middle, var last] => 
        $"Обычная структура: {first}, middle: {middle.Length} элементов, {last}",
    
    _ => "Неизвестная структура"
};

// Обработка потока данных с фильтрацией по паттерну
public IEnumerable<ProcessedItem> ProcessLargeDataset(IEnumerable<RawDataItem> rawData)
{
    foreach (var item in rawData)
    {
        // Используем паттерн-матчинг для эффективной фильтрации
        if (item.Data is [var id, var timestamp, .. var values] && 
            timestamp > DateTime.UtcNow.AddDays(-1) &&
            values.Length > 0)
        {
            yield return new ProcessedItem(id, values);
        }
    }
}

var complexData = [
    [1, 2, 3],
    [4, 5],
    [6, 7, 8, 9],
    [10]
];
 
// Фильтрация с использованием паттерн-матчинга
var filtered = complexData
    .Where(arr => arr is [var first, .. var rest] && first % 2 == 0)
    .SelectMany(arr => arr)
    .ToArray();

private int _foo;
public int Foo
{
    get
    {
        // Дополнительная логика
        return _foo;
    }
    set
    {
        // Валидация или побочные эффекты
        _foo = value;
        // Ещё какая-то логика
    }
}

public int Foo
{
    get
    {
        // Дополнительная логика
        return field;
    }
    set
    {
        // Валидация или побочные эффекты
        field = value;
        // Ещё какая-то логика
    }
}

[CompilerGenerated]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int <Foo>k__BackingField;
 
public int Foo
{
    get
    {
        return <Foo>k__BackingField;
    }
    set
    {
        <Foo>k__BackingField = value;
    }
}

internal static class ExtensionMembers
{
    public static void InsertOne<T>(this SpecialList<T> source, int index, T item)
    {
        if (index < 0 || index > source.Items.Count)
        {
            throw new ArgumentOutOfRangeException(nameof(index), "Index is out of range.");
        }
        source.Items.Insert(index, item);
    }
}

internal static class ExtensionMembers
{
    extension SpecialList<T>
    {
        public void Insert(int index, T item)
        {
            if (index < 0 || index > this.Items.Count)
            {
                throw new ArgumentOutOfRangeException(nameof(index), "Index is out of range.");
            }
            this.Items.Insert(index, item);
        }
        
        // Свойство-расширение!
        public int Count => this.Items.Count;
    }
}

internal static class ExtensionMembers
{
    extension<T>(SpecialList<T>)
    {
        public static bool IsEmpty(IEnumerable<T> source) => !source.Any();
    }
}

if (foo is not null)
{
    foo.Bar = 20;
}

foo?.Bar = 20;

counter?.Value += 1;  // Увеличивает Value только если counter не null
product?.Price *= 1.1;  // Увеличивает цену на 10% только если product не null

public void ProcessData(ref readonly LargeStruct data)
{
    // Здесь мы можем читать data, но не можем её изменять
    Console.WriteLine(data.Property);
    
    // Это вызовет ошибку компиляции:
    // data.Property = newValue; 
}

// До C# 14: приходилось выбирать между производительностью и безопасностью
public void ProcessMetrics(LargeMetricsStruct metrics) // Безопасно, но неэффективно - копирование!
{
    // Обработка данных
}
 
public void ProcessMetricsFast(ref LargeMetricsStruct metrics) // Эффективно, но небезопасно
{
    // Может случайно изменить данные, которые используются в другом потоке
    metrics.Counter++; // Упс! Побочный эффект, который трудно отследить
}

// C# 14: и безопасно, и эффективно
public void ProcessMetricsOptimal(ref readonly LargeMetricsStruct metrics)
{
    // Доступ к данным без копирования
    var aggregateValue = metrics.Value1 + metrics.Value2;
    
    // Попытка изменения вызовет ошибку компиляции:
    // metrics.Counter++; // Ошибка: невозможно изменить readonly reference
}

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; set; } = age;
    
    public void Introduce()
    {
        Console.WriteLine($"Меня зовут {Name}, мне {Age} лет.");
    }
}

public class Employee(string name, int age, string department) : Person(name, age)
{
    public string Department { get; } = department;
}

public abstract class EventHandler(string eventType, int priority)
{
    public string EventType { get; } = eventType;
    public int Priority { get; } = priority;
    
    public abstract void HandleEvent(EventContext context);
    
    protected void LogEventProcessing(string message)
    {
        Console.WriteLine($"[{EventType}] {message}");
    }
}
 
// Конкретная реализация с использованием первичного конструктора
public class PaymentEventHandler(string paymentProvider) 
    : EventHandler("Payment", 10)
{
    public string PaymentProvider { get; } = paymentProvider;
    
    public override void HandleEvent(EventContext context)
    {
        LogEventProcessing($"Processing payment via {PaymentProvider}");
        // Логика обработки платежа
    }
}

// Определение сервиса с зависимостями через первичный конструктор
public class OrderService(
    IRepository<Order> orderRepository,
    IPaymentGateway paymentGateway,
    ILogger<OrderService> logger)
{
    public async Task<OrderResult> CreateOrder(OrderRequest request)
    {
        logger.LogInformation("Creating new order for customer {CustomerId}", request.CustomerId);
        
        // Использование внедрённых зависимостей
        var order = new Order { /* ... */ };
        await orderRepository.SaveAsync(order);
        
        var paymentResult = await paymentGateway.ProcessPayment(request.Payment);
        
        return new OrderResult { /* ... */ };
    }
}

services.AddScoped<IOrderService, OrderService>();

// Модульный тест с использованием моков
[Fact]
public async Task CreateOrder_ValidRequest_ReturnsSuccessResult()
{
    // Arrange
    var orderRepositoryMock = new Mock<IRepository<Order>>();
    var paymentGatewayMock = new Mock<IPaymentGateway>();
    var loggerMock = new Mock<ILogger<OrderService>>();
    
    var service = new OrderService(
        orderRepositoryMock.Object,
        paymentGatewayMock.Object,
        loggerMock.Object);
    
    // Act
    var result = await service.CreateOrder(new OrderRequest { /* ... */ });
    
    // Assert
    Assert.NotNull(result);
    Assert.True(result.Success);
    orderRepositoryMock.Verify(r => r.SaveAsync(It.IsAny<Order>()), Times.Once);
}

public interface IProduct
{
    string Name { get; }
    decimal Price { get; }
}
 
// Расширение интерфейса с помощью свойств
internal static class ProductExtensions
{
    extension IProduct
    {
        public decimal PriceWithVat => this.Price * 1.2m;
        public bool IsExpensive => this.Price > 100m;
        
        public string GetFormattedPrice(string currencySymbol = "$")
        {
            return $"{currencySymbol}{this.Price:0.00}";
        }
    }
}
 
// Использование
public void DisplayProductInfo(IProduct product)
{
    Console.WriteLine($"Name: {product.Name}");
    Console.WriteLine($"Price: {product.GetFormattedPrice("€")}");
    Console.WriteLine($"Price with VAT: {product.PriceWithVat:C}");
    Console.WriteLine($"Is expensive: {product.IsExpensive}");
}

// Старый подход - иерархия интерфейсов
public interface IProduct { /* ... */ }
public interface IProductWithPricing : IProduct { decimal GetPriceWithDiscount(decimal discount); }
public interface IProductWithInventory : IProduct { int StockQuantity { get; } }
 
// Класс вынужден реализовывать всё, даже если нужна только часть функциональности
public class StandardProduct : IProductWithPricing, IProductWithInventory { /* ... */ }

// Новый подход - базовый интерфейс + расширения
public interface IProduct { /* ... */ }
 
internal static class PricingExtensions
{
    extension IProduct
    {
        public decimal GetPriceWithDiscount(decimal discount) =>
            this.Price * (1 - discount);
    }
}
 
internal static class InventoryExtensions
{
    extension(ProductWithInventory implements IProduct)
    {
        public int StockQuantity { get; }
    }
}

public string GetUserName(User? user)
{
// Более элегантная проверка и генерация исключения
return user?.Name ?? throw new ArgumentNullException(nameof(user));
}

// Присваивание с проверкой
user?.Address ??= new Address();  // Создаёт новый Address, только если user?.Address == null

// Действует только если все элементы цепочки не null
user?.Profile?.Settings?.EnableNotifications = true;

public class ImmutablePerson(string name, DateOnly birthDate)
{
public string Name { get; } = name;
public DateOnly BirthDate { get; } = birthDate;
public int Age => CalculateAge(BirthDate, DateOnly.FromDateTime(DateTime.Today));
 
// Методы, возвращающие новые экземпляры вместо изменения текущего
public ImmutablePerson WithName(string newName) => new(newName, BirthDate);
public ImmutablePerson WithBirthDate(DateOnly newBirthDate) => new(Name, newBirthDate);
 
private static int CalculateAge(DateOnly birthDate, DateOnly today)
{
var age = today.Year - birthDate.Year;
if (today.DayOfYear < birthDate.DayOfYear)
    age--;
return age;
}
}

// Builder с использованием новых возможностей C# 14
public class QueryBuilder(string initialTable)
{
private readonly string _table = initialTable;
private string? _where;
private int? _limit;
 
public QueryBuilder Where(string condition)
{
    return this with { _where = condition };
}
 
public QueryBuilder Limit(int limit)
{
    return this with { _limit = limit };
}
 
public string Build()
{
    var query = $"SELECT * FROM {_table}";
    
    query += _where is not null ? $" WHERE {_where}" : "";
    query += _limit is not null ? $" LIMIT {_limit}" : "";
    
    return query;
}
}
 
// Использование
var query = new QueryBuilder("users")
.Where("age > 18")
.Limit(10)
.Build();

// Простая реализация Maybe-монады с использованием C# 14
public readonly struct Maybe<T>(T? value)
{
private readonly T? _value = value;
 
public static Maybe<T> None => new(default);
public static Maybe<T> Some(T value) => new(value);
 
public bool HasValue => _value is not null;
 
public TResult Match<TResult>(Func<T, TResult> some, Func<TResult> none) =>
    HasValue ? some(_value!) : none();
 
public Maybe<TResult> Map<TResult>(Func<T, TResult> map) =>
    HasValue ? new Maybe<TResult>(map(_value!)) : Maybe<TResult>.None;
 
public Maybe<TResult> Bind<TResult>(Func<T, Maybe<TResult>> bind) =>
    HasValue ? bind(_value!) : Maybe<TResult>.None;
}
 
// Использование
public Maybe<User> FindUserById(int id)
{
var user = repository.GetUser(id);
return user is not null ? Maybe<User>.Some(user) : Maybe<User>.None;
}
 
// С паттерн-матчингом
var userGreeting = FindUserById(123)
.Match(
    user => $"Привет, {user.Name}!",
    () => "Пользователь не найден"
);

public static class ServiceProxyGenerator
{
extension<T>() where T : class
{
    public static T CreateProxy(IServiceProvider services) =>
        (T)CreateProxyImplementation(typeof(T), services);
}
 
private static object CreateProxyImplementation(Type interfaceType, IServiceProvider services)
{
    // Использование метаданных типа для генерации прокси
    var methods = interfaceType.GetMethods();
    
    // Генерация динамической реализации с логгированием, кэшированием и т.д.
    // Реальная реализация была бы длиннее
    
    return generatedProxy;
}
}
 
// Использование
var customerService = ServiceProxyGenerator.CreateProxy<ICustomerService>(serviceProvider);

[InlineArray(10)]
public struct Buffer10<T>
{
private T _element0;
}
 
// Использование
var buffer = new Buffer10<int>();
for (int i = 0; i < 10; i++)
{
buffer[i] = i * i;
}

[Benchmark]
public int SumArrayStandard()
{
int sum = 0;
int[] array = new int[1000];
for (int i = 0; i < array.Length; i++)
{
    array[i] = i;
}
for (int i = 0; i < array.Length; i++)
{
    sum += array[i];
}
return sum;
}
 
[Benchmark]
public int SumArrayInline()
{
int sum = 0;
Buffer1000<int> buffer = new Buffer1000<int>();
for (int i = 0; i < 1000; i++)
{
    buffer[i] = i;
}
for (int i = 0; i < 1000; i++)
{
    sum += buffer[i];
}
return sum;
}
 
[InlineArray(1000)]
public struct Buffer1000<T>
{
private T _element0;
}

public class HighPerformanceBuffer
{
public int Size 
{
    get 
    {
        // Оптимизация: кэшируем размер для частых обращений
        if (field <= 0)
        {
            field = CalculateActualSize();
        }
        return field;
    }
    private set { field = value; }
}
 
private int CalculateActualSize() 
{
    // Какая-то сложная логика вычисления размера
    return 1000;
}
}

[InlineArray(10000)]
public struct UserBuffer
{
private User _firstUser;
}
 
// Компактное хранение пользователей без лишних выделений памяти
public class UserCache
{
private UserBuffer _users;
private int _count;
 
public void Add(User user) 
{
    if (_count < 10000) 
    {
        _users[_count++] = user;
    }
}
}

[InlineArray(1024)]
public struct Vector1024
{
private float _element0;
}
 
public float DotProduct(Vector1024 a, Vector1024 b)
{
float sum = 0;
for (int i = 0; i < 1024; i++)
{
    sum += a[i] * b[i];
}
return sum;
}

[InlineArray(4096)]
public struct AudioBuffer
{
    private byte _element0;
}
 
public class AudioProcessor
{
    private readonly AudioBuffer _buffer;
    
    public void ProcessAudioChunk(ReadOnlySpan<byte> data)
    {
        // Копируем входные данные во временный буфер
        for (int i = 0; i < Math.Min(data.Length, 4096); i++)
        {
            _buffer[i] = data[i];
        }
        
        // Обрабатываем данные без дополнительных аллокаций
        // ...
    }
}

// До C# 14 - метод-расширение транслировался в статический вызов
// string.IsNullOrEmpty(obj.ToString())
 
// C# 14 - более прямая компиляция
extension string
{
    public bool IsEmpty => this.Length == 0;
}
// может компилироваться в более эффективный код, близкий к:
// obj.ToString().Length == 0

// Такие паттерны теперь компилируются в более оптимальный код
var result = value switch
{
    [var x, var y] when x < 0 => "Отрицательное X",
    [var x, var y] when y < 0 => "Отрицательное Y",
    [var x, var y] => $"Положительные ({x}, {y})",
    _ => "Не пара"
};

// Старый код с многословным объявлением резервных полей
private readonly Dictionary<string, int> _cache;
public Dictionary<string, int> Cache
{
    get { return _cache; }
}
 
// Обновленный с использованием field
public Dictionary<string, int> Cache
{
    get { return field; }
}
private set { field = value; }

// Существующий код остается нетронутым
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    // ...другие свойства
}
 
// Новые возможности через расширения
internal static class CustomerExtensions
{
    extension Customer
    {
        public bool IsPremium => this.Purchases.Sum(p => p.Amount) > 10000;
        public decimal LoyaltyScore => CalculateLoyaltyScore(this);
    }
    
    private static decimal CalculateLoyaltyScore(Customer customer)
    {
        // Сложная бизнес-логика, вынесенная из основного класса
        return /*...*/;
    }
}

// До C# 14
public class EmailBuilder
{
    private string _subject;
    private string _body;
    private List<string> _recipients = new List<string>();
    
    public EmailBuilder WithSubject(string subject)
    {
        _subject = subject;
        return this;
    }
    
    public EmailBuilder WithBody(string body)
    {
        _body = body;
        return this;
    }
    
    // ...другие методы
}
 
// C# 14 с первичными конструкторами и immutable-подходом
public class EmailBuilder(string subject = "", string body = "", List<string>? recipients = null)
{
    private List<string> _recipients = recipients ?? [];
    
    public EmailBuilder WithSubject(string subject) => this with { subject = subject };
    public EmailBuilder WithBody(string body) => this with { body = body };
    public EmailBuilder AddRecipient(string email) 
    {
        var newList = [.. _recipients, email];
        return this with { recipients = newList };
    }
    
    public Email Build() => new Email(subject, body, _recipients);
}