Что такое ad-hoc-полиморфизм?

Что такое Ad-hoc полиморфизм?

Ad-hoc полиморфизм (от лат. ad hoc — "для конкретного случая") — это вид полиморфизма, при котором функция или оператор может работать с разными типами данных, но для каждого типа определяется отдельная, конкретная реализация. Это достигается не через общий интерфейс или наследование, а через перегрузку функций (method overloading) или шаблоны/дженерики с явной специализацией. В отличие от параметрического полиморфизма (где одна реализация работает для всех типов, как в List<T>) и полиморфизма подтипов (через наследование и интерфейсы), ad-hoc полиморфизм требует явного определения поведения для каждого поддерживаемого типа.

В C# ad-hoc полиморфизм реализуется в первую очередь через перегрузку методов и перегрузку операторов.

Основные механизмы в C#

1. Перегрузка методов (Method Overloading)

Один и тот же метод может иметь несколько версий с разными сигнатурами (типами или количеством параметров). Компилятор выбирает подходящую версию на основе типов аргументов на этапе компиляции (статическое разрешение).

public class Calculator
{
    // Перегрузка для int
    public int Add(int a, int b)
    {
        return a + b;
    }
    
    // Перегрузка для double
    public double Add(double a, double b)
    {
        return a + b;
    }
    
    // Перегрузка для строк (конкатенация)
    public string Add(string a, string b)
    {
        return a + b;
    }
}

// Использование
var calc = new Calculator();
int result1 = calc.Add(5, 10);        // Вызов int-версии
double result2 = calc.Add(3.14, 2.5); // Вызов double-версии
string result3 = calc.Add("Hello, ", "World!"); // Вызов string-версии

2. Перегрузка операторов (Operator Overloading)

C# позволяет переопределять поведение операторов (например, +, -, ==) для пользовательских типов.

public class Vector
{
    public int X { get; }
    public int Y { get; }
    
    public Vector(int x, int y) => (X, Y) = (x, y);
    
    // Перегрузка оператора +
    public static Vector operator +(Vector v1, Vector v2)
    {
        return new Vector(v1.X + v2.X, v1.Y + v2.Y);
    }
    
    // Перегрузка оператора * (умножение на скаляр)
    public static Vector operator *(Vector v, int scalar)
    {
        return new Vector(v.X * scalar, v.Y * scalar);
    }
}

// Использование
var v1 = new Vector(1, 2);
var v2 = new Vector(3, 4);
var sum = v1 + v2;        // Vector(4, 6)
var scaled = v1 * 3;      // Vector(3, 6)

3. Явная реализация интерфейса (частный случай)

Хотя это ближе к полиморфизму подтипов, явная реализация интерфейса позволяет предоставлять разные реализации метода для одного класса в зависимости от типа интерфейса.

interface ILogger
{
    void Log(string message);
}

class MultiLogger : ILogger
{
    void ILogger.Log(string message) => Console.WriteLine($"Interface: {message}");
    public void Log(string message) => Console.WriteLine($"Public: {message}");
}

// Использование
var logger = new MultiLogger();
logger.Log("Direct call");            // Вызов public-метода
((ILogger)logger).Log("Via interface"); // Вызов явной реализации интерфейса

Отличия от других типов полиморфизма

• Ad-hoc vs параметрический (дженерики): В ad-hoc для каждого типа нужна своя реализация, в параметрическом — одна обобщенная реализация работает для всех типов.
• Ad-hoc vs полиморфизм подтипов (наследование): В подтипах используется единый интерфейс, а выбор метода происходит динамически (через виртуальные методы). В ad-hoc выбор делается статически на этапе компиляции.

Преимущества и недостатки

Преимущества:

• Повышение читаемости кода — можно использовать одинаковые имена для логически схожих операций.
• Гибкость работы с пользовательскими типами — например, перегрузка операторов делает код более интуитивным.
• Статическая типизация — проверки на этапе компиляции снижают риск ошибок времени выполнения.

Недостатки:

• Дублирование кода — если логика для разных типов схожа, приходится поддерживать несколько реализаций.
• Ограниченная расширяемость — нельзя добавить поддержку нового типа без модификации исходного кода (в отличие, например, от extension-методов в сочетании с интерфейсами).
• Сложность разрешения перегрузок — при множестве перегруженных версий компилятор может выбрать неочевидный вариант, что приводит к ошибкам.

Практическое применение в C# Backend

В backend-разработке на C# ad-hoc полиморфизм часто используется в:

• Библиотеках математических вычислений (перегрузка операторов для векторов, матриц).
• API-контроллерах (перегрузка методов для обработки разных форматов запросов — JSON, XML).
• Сравнении объектов (перегрузка операторов ==, !=, методов Equals).
• Построителях запросов ORM (например, перегруженные методы Where для разных типов условий в Entity Framework).

Пример в контексте Web API:

[ApiController]
[Route("api/[controller]")]
public class ProductsController : ControllerBase
{
    // Перегрузка для получения по ID
    [HttpGet("{id}")]
    public IActionResult GetProduct(int id) { /* ... */ }
    
    // Перегрузка для получения по строковому идентификатору (например, GUID)
    [HttpGet("{guid}")]
    public IActionResult GetProduct(string guid) { /* ... */ }
    
    // Перегрузка для получения с фильтрацией по query-параметрам
    [HttpGet]
    public IActionResult GetProducts([FromQuery] string category) { /* ... */ }
}

Таким образом, ad-hoc полиморфизм в C# — мощный инструмент для создания выразительного и типобезопасного кода, но требующий взвешенного подхода, чтобы избежать излишнего дублирования и сложностей поддержки.