Приведи пример возможности языка C# для расширения поведения типа

Пример расширения поведения типа в C#: методы расширения

В C# одним из мощнейших средств расширения поведения существующих типов являются методы расширения (extension methods). Они позволяют "добавлять" новые методы к уже существующим типам без модификации исходного кода, создания производных классов или использования композиции. Это особенно полезно для:

• Работы со сторонними библиотеками или системными типами
• Создания fluent-интерфейсов
• Добавления доменно-специфичной функциональности к базовым типам

Базовый пример: расширение типа string

Допустим, мы хотим добавить метод для проверки, является ли строка корректным email-адресом:

using System;
using System.Text.RegularExpressions;

public static class StringExtensions
{
    private static readonly Regex EmailRegex = 
        new Regex(@"^[^@\s]+@[^@\s]+\.[^@\s]+$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
    
    // Метод расширения для типа string
    public static bool IsValidEmail(this string input)
    {
        if (string.IsNullOrWhiteSpace(input))
            return false;
            
        return EmailRegex.IsMatch(input.Trim());
    }
    
    // Еще один метод расширения - обратный вызов при условии
    public static string IfValidEmail(this string email, Action<string> action)
    {
        if (email.IsValidEmail())
        {
            action?.Invoke(email);
        }
        return email;
    }
}

// Использование
class Program
{
    static void Main()
    {
        string email = "user@example.com";
        
        // Используем наш метод расширения как будто он родной для string
        bool isValid = email.IsValidEmail();
        Console.WriteLine($"Email valid: {isValid}");
        
        // Цепочка вызовов (fluent interface)
        "test@domain.com"
            .IfValidEmail(e => Console.WriteLine($"Sending to {e}"))
            .ToUpper();
    }
}

Расширение системных и сторонних типов

Методы расширения особенно мощны при работе с типами, которые мы не можем изменить:

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

public static class CollectionExtensions
{
    // Расширяем IEnumerable<T> - системный интерфейс
    public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T> source)
        where T : class
    {
        return source.Where(item => item != null);
    }
    
    // Расширение для словаря с безопасным получением значения
    public static TValue GetValueOrDefault<TKey, TValue>(
        this IDictionary<TKey, TValue> dictionary, 
        TKey key, 
        TValue defaultValue = default)
    {
        return dictionary.TryGetValue(key, out var value) ? value : defaultValue;
    }
    
    // Метод расширения для математических операций
    public static bool IsBetween(this int value, int min, int max)
    {
        return value >= min && value <= max;
    }
}

// Использование
class Example
{
    public void ProcessData()
    {
        List<string> items = new List<string> { "a", null, "b", null, "c" };
        
        // Используем наш метод расширения
        var validItems = items.WhereNotNull().ToList();
        
        // Расширение для int
        int age = 25;
        bool isAdult = age.IsBetween(18, 65); // true
        
        // Расширение для Dictionary
        var config = new Dictionary<string, string>
        {
            ["Timeout"] = "30",
            ["Retries"] = "3"
        };
        
        string timeout = config.GetValueOrDefault("Timeout", "10");
        string missing = config.GetValueOrDefault("MissingKey", "default");
    }
}

Расширение перечислений (enum)

using System;

public static class EnumExtensions
{
    // Метод расширения для любого enum
    public static string GetDescription(this Enum value)
    {
        var field = value.GetType().GetField(value.ToString());
        var attributes = field?.GetCustomAttributes(
            typeof(System.ComponentModel.DescriptionAttribute), false);
            
        if (attributes != null && attributes.Length > 0)
            return ((System.ComponentModel.DescriptionAttribute)attributes[0]).Description;
            
        return value.ToString();
    }
    
    // Проверка наличия флага в битовом перечислении
    public static bool HasFlagEx<T>(this T value, T flag) where T : Enum
    {
        var intValue = Convert.ToInt64(value);
        var intFlag = Convert.ToInt64(flag);
        return (intValue & intFlag) == intFlag;
    }
}

[Flags]
public enum UserPermissions
{
    None = 0,
    Read = 1,
    Write = 2,
    Delete = 4,
    Admin = Read | Write | Delete
}

class EnumUsage
{
    public void CheckPermissions()
    {
        var permissions = UserPermissions.Read | UserPermissions.Write;
        
        // Используем наш метод расширения
        bool canWrite = permissions.HasFlagEx(UserPermissions.Write); // true
        bool isAdmin = permissions.HasFlagEx(UserPermissions.Admin); // false
    }
}

Ключевые особенности методов расширения:

1. Синтаксический сахар: Методы расширения - это статические методы, которые компилятор преобразует в обычные статические вызовы, но позволяют использовать более естественный объектно-ориентированный синтаксис.

2. Статические классы: Методы расширения должны быть объявлены в статических классах.

3. Ключевое слово this: Первый параметр метода помечается ключевым словом this, указывая на тип, который расширяется.

4. Видимость и пространства имен: Методы расширения доступны только при подключении соответствующего пространства имен с помощью using.

5. Приоритет: Методы экземпляра всегда имеют приоритет над методами расширения с той же сигнатурой.

Ограничения и лучшие практики:

// Плохая практика - излишнее расширение базовых типов
public static class ControversialExtensions
{
    // Излишне - уже есть string.IsNullOrEmpty()
    public static bool IsEmpty(this string str) => string.IsNullOrEmpty(str);
    
    // Лучше - добавляет реальную новую функциональность
    public static string Truncate(this string str, int maxLength)
    {
        if (string.IsNullOrEmpty(str) || str.Length <= maxLength)
            return str;
        return str.Substring(0, maxLength) + "...";
    }
}

Методы расширения - это мощный инструмент, который следует использовать умеренно и осмысленно. Они отлично подходят для:

• Создания DSL (Domain Specific Language)
• Расширения сторонних библиотек
• Добавления вспомогательных методов для часто используемых операций
• Реализации паттернов типа Repository или Specification

Однако важно не злоупотреблять ими и не создавать методы расширения там, где достаточно обычных методов или где они могут нарушить ясность кода.