Как реализовать LastOrDefault не зная тип объекта?

Реализация LastOrDefault для неизвестного типа

Для реализации универсального LastOrDefault без знания конкретного типа объекта на этапе компиляции существует несколько подходов, в зависимости от того, с какими коллекциями мы работаем и какие ограничения имеются.

1. Использование обобщенных методов (дженериков)

Наиболее типичный подход - создание обобщенного метода с параметром типа T:

public static T LastOrDefaultGeneric<T>(IEnumerable<T> collection)
{
    if (collection == null)
        throw new ArgumentNullException(nameof(collection));
    
    if (collection is IList<T> list)
        return list.Count > 0 ? list[list.Count - 1] : default;
    
    T result = default;
    bool found = false;
    
    foreach (var item in collection)
    {
        result = item;
        found = true;
    }
    
    return found ? result : default;
}

// Использование
var numbers = new List<int> { 1, 2, 3 };
var lastNumber = LastOrDefaultGeneric(numbers); // 3

var empty = new List<string>();
var lastString = LastOrDefaultGeneric(empty); // null

2. Использование рефлексии для необобщенных коллекций

Если тип коллекции неизвестен на этапе компиляции, можно использовать рефлексию:

public static object LastOrDefaultReflection(object collection)
{
    if (collection == null)
        return null;
    
    var type = collection.GetType();
    
    // Проверяем, реализует ли коллекция IEnumerable
    var enumerableInterface = type.GetInterface("IEnumerable");
    if (enumerableInterface == null)
        throw new ArgumentException("Object does not implement IEnumerable");
    
    // Получаем метод GetEnumerator
    var getEnumeratorMethod = type.GetMethod("GetEnumerator");
    if (getEnumeratorMethod == null)
        throw new InvalidOperationException("Cannot find GetEnumerator method");
    
    var enumerator = getEnumeratorMethod.Invoke(collection, null);
    var moveNextMethod = enumerator.GetType().GetMethod("MoveNext");
    var currentProperty = enumerator.GetType().GetProperty("Current");
    
    object last = null;
    bool hasItems = false;
    
    // Перебираем элементы
    while ((bool)moveNextMethod.Invoke(enumerator, null))
    {
        last = currentProperty.GetValue(enumerator);
        hasItems = true;
    }
    
    // Если коллекция реализует IDisposable
    var disposable = enumerator as IDisposable;
    disposable?.Dispose();
    
    return hasItems ? last : GetDefaultValue(type);
}

private static object GetDefaultValue(Type type)
{
    return type.IsValueType ? Activator.CreateInstance(type) : null;
}

3. Использование динамического типа (dynamic)

В C# 4.0+ можно использовать dynamic для работы с неизвестными типами:

public static dynamic LastOrDefaultDynamic(IEnumerable<dynamic> collection)
{
    if (collection == null)
        return null;
    
    dynamic last = null;
    bool hasItems = false;
    
    foreach (var item in collection)
    {
        last = item;
        hasItems = true;
    }
    
    return hasItems ? last : GetDefaultDynamic(collection);
}

private static dynamic GetDefaultDynamic(IEnumerable<dynamic> collection)
{
    // Пытаемся определить тип элементов
    var enumerator = collection.GetEnumerator();
    if (enumerator.MoveNext())
    {
        var first = enumerator.Current;
        return first == null ? null : Activator.CreateInstance(first.GetType());
    }
    
    return null;
}

4. Работа с необобщенными интерфейсами

Для максимальной гибкости можно использовать необобщенные коллекции:

public static object LastOrDefaultNonGeneric(IEnumerable collection)
{
    if (collection == null)
        return null;
    
    object last = null;
    bool hasItems = false;
    
    var enumerator = collection.GetEnumerator();
    try
    {
        while (enumerator.MoveNext())
        {
            last = enumerator.Current;
            hasItems = true;
        }
    }
    finally
    {
        if (enumerator is IDisposable disposable)
            disposable.Dispose();
    }
    
    return hasItems ? last : null;
}

// Использование
ArrayList arrayList = new ArrayList { 1, "test", DateTime.Now };
var result = LastOrDefaultNonGeneric(arrayList);

5. Универсальная реализация с проверкой типа

Наиболее надежный подход, сочетающий несколько методов:

public static object LastOrDefaultUniversal(object collection)
{
    if (collection == null)
        return null;
    
    var collectionType = collection.GetType();
    
    // Проверяем, является ли коллекция обобщенной IEnumerable<>
    if (collectionType.IsGenericType && 
        collectionType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
    {
        var elementType = collectionType.GetGenericArguments()[0];
        var method = typeof(Enumerable).GetMethod("LastOrDefault", 
            BindingFlags.Public | BindingFlags.Static);
        var genericMethod = method.MakeGenericMethod(elementType);
        return genericMethod.Invoke(null, new[] { collection });
    }
    
    // Для необобщенных IEnumerable
    if (collection is IEnumerable enumerable)
    {
        return LastOrDefaultNonGeneric(enumerable);
    }
    
    throw new ArgumentException("Object is not a collection");
}

Ключевые моменты реализации:

1. Обработка null значений - всегда проверяйте входные параметры
2. Оптимизация для индексируемых коллекций - используйте доступ по индексу для IList<T>
3. Освобождение ресурсов - не забывайте о IDisposable для энумераторов
4. Возврат значений по умолчанию - default(T) для типов значений, null для ссылочных типов
5. Безопасность типов - при работе с рефлексией обрабатывайте исключения

Выбор подхода зависит от конкретных требований:

• Для статически типизированных коллекций используйте дженерики
• Для динамических сценариев - рефлексию или dynamic
• Для максимальной производительности - специализированные проверки типов

Все реализации должны корректно обрабатывать пустые коллекции, возвращая значение по умолчанию для соответствующего типа элементов.