Как сделать расширение?

Создание и использование расширений (extension methods) в C#

Расширения (extension methods) — это специальный синтаксис C#, который позволяет "добавлять" методы к существующим типам без изменения их исходного кода, наследования или использования паттерна декоратор. Это достигается через статические методы в статических классах с применением ключевого слова this к первому параметру.

Основные правила создания расширений

1. Статический класс: Метод расширения должен быть объявлен внутри статического класса.
2. Статический метод: Сам метод должен быть статическим.
3. Ключевое слово this: Первый параметр метода должен использовать модификатор this и указывать на тип, который расширяется.

Практический пример создания расширения

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

public static class StringExtensions
{
    // Метод расширения для типа string
    public static bool IsPalindrome(this string str)
    {
        if (string.IsNullOrEmpty(str))
            return false;
            
        // Убираем пробелы и приводим к нижнему регистру для сравнения
        string cleaned = new string(str.Where(char.IsLetterOrDigit).ToArray())
                           .ToLower();
        
        // Сравниваем строку с её перевернутой версией
        return cleaned.SequenceEqual(cleaned.Reverse());
    }
    
    // Ещё один пример: метод для повторения строки указанное количество раз
    public static string Repeat(this string str, int count)
    {
        if (count <= 0) return string.Empty;
        return string.Concat(Enumerable.Repeat(str, count));
    }
}

Использование расширений в коде

После объявления расширений их можно использовать как обычные методы экземпляра:

class Program
{
    static void Main()
    {
        string text1 = "А роза упала на лапу Азора";
        string text2 = "hello";
        string text3 = "madam";
        
        Console.WriteLine($"'{text1}' палиндром: {text1.IsPalindrome()}"); // true
        Console.WriteLine($"'{text2}' палиндром: {text2.IsPalindrome()}"); // false
        Console.WriteLine($"'{text3}' палиндром: {text3.IsPalindrome()}"); // true
        
        // Использование другого расширения
        string repeated = "Hi ".Repeat(3);
        Console.WriteLine(repeated); // "Hi Hi Hi "
        
        // Расширения можно использовать и со строковыми литералами
        Console.WriteLine("racecar".IsPalindrome()); // true
    }
}

Расширения для пользовательских типов

Расширения работают не только для встроенных типов, но и для любых других, включая ваши собственные классы:

public class ShoppingCart
{
    public List<Product> Products { get; } = new List<Product>();
}

public static class ShoppingCartExtensions
{
    public static decimal CalculateTotal(this ShoppingCart cart)
    {
        return cart.Products.Sum(p => p.Price * p.Quantity);
    }
    
    public static void AddProduct(this ShoppingCart cart, Product product)
    {
        var existing = cart.Products.FirstOrDefault(p => p.Id == product.Id);
        if (existing != null)
            existing.Quantity += product.Quantity;
        else
            cart.Products.Add(product);
    }
}

// Использование
var cart = new ShoppingCart();
cart.AddProduct(new Product { Id = 1, Price = 100, Quantity = 2 });
decimal total = cart.CalculateTotal(); // 200

Расширения для интерфейсов

Один из самых мощных сценариев использования — расширение интерфейсов. Это позволяет добавлять функциональность ко всем типам, реализующим интерфейс:

public static class EnumerableExtensions
{
    // Метод расширения для IEnumerable<T>
    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
    {
        var random = new Random();
        return source.OrderBy(x => random.Next());
    }
    
    // Метод для проверки, содержит ли коллекция дубликаты
    public static bool HasDuplicates<T>(this IEnumerable<T> source)
    {
        var seen = new HashSet<T>();
        foreach (var item in source)
        {
            if (!seen.Add(item))
                return true;
        }
        return false;
    }
}

// Теперь этот метод доступен для всех коллекций
var numbers = new List<int> { 1, 2, 3, 4, 5 };
var shuffled = numbers.Shuffle(); // [3, 1, 5, 2, 4] (случайный порядок)

Важные нюансы и ограничения

• Приоритет методов: Если в классе уже существует метод с такой же сигнатурой, он будет иметь приоритет над методом расширения.
• Доступ только через using: Для использования расширений необходимо подключить пространство имен, в котором объявлен статический класс с помощью директивы using.
• Расширение свойств и событий: Синтаксис методов расширения не поддерживает расширение свойств, событий или операторов напрямую (хотя для операторов есть отдельный механизм через перегрузку).
• Null-безопасность: Если вызвать метод расширения на null-ссылке, будет выброшено NullReferenceException. Для безопасной работы можно проверять первый параметр в самом методе.

Рекомендации по использованию

1. Семантическая группировка: Объединяйте связанные расширения в одном статическом классе.
2. Осмысленные имена: Называйте классы расширений по шаблону [Тип]Extensions.
3. Документируйте расширения: Поскольку расширения выглядят как встроенные методы, важно документировать их XML-комментариями.
4. Не злоупотребляйте: Избегайте добавления тривиальных методов, которые не приносят реальной пользы или могут быть легко реализованы через существующие методы.

Расширения — это мощный инструмент, который, при правильном использовании, делает код более читаемым и выразительным, позволяя создавать DSL-подобные (Domain Specific Language) конструкции прямо в C#.