Unsafe generic math in C#

if (typeof(T) != typeof(string))

T Add(T value1, T value2)
{
    // лишние ветки будут убраны JIT компилятором
    if (typeof(T) == typeof(int)) {
        // боксинг тоже убирается JIT
        return ((int)(object)value1) + ((int)(object)value2);
    } 
    if (typeof(T) == typeof(byte)) { ... }
}

Вариант return (T)(i32Left + i32Right) не компилируется — нет гарантии, что T это int (хоть мы-то знаем, что это так). Можно попробовать двойное преобразование return (T)(object)(i32Left + i32Right). Сначала сумма упаковывается, затем — распаковывается в T. Это будет работать только если типы до упаковки и после упаковки совпадают.

[MethodImpl(MethodImplOptions.NoInlining)]
        private static T ThrowInvalidOperation<T>() => throw new InvalidOperationException("Not support type");
        
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static T Add<T>(T lft, T rgt) where T : struct 
        {
            if(typeof(T) == typeof(int))
                return (T)(object)((int)(object)lft + (int)(object)rgt);
            if(typeof(T) == typeof(float))
                return (T)(object)((float)(object)lft + (float)(object)rgt);
            if(typeof(T) == typeof(decimal))
                return (T)(object)((decimal)(object)lft + (decimal)(object)rgt);
            if(typeof(T) == typeof(double))
                return (T)(object)((double)(object)lft + (double)(object)rgt);

            return ThrowInvalidOperation<T>();
        }
    
        [Benchmark]
        public int GenericAdd() => Add(10, 20);

        [Benchmark]
        public int DirectAdd() => 10 + 20;

А если [MethodImpl(MethodImplOptions.AggressiveInlining)]?

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static T Add<T>(T left, T right)
            where T : struct
        {
            if (typeof(T) == typeof(int))
            {
                int sum = Unsafe.As<T, int>(ref left) + Unsafe.As<T, int>(ref right);
                return Unsafe.As<int, T>(ref sum);
            }
            // if (typeof(T) ==...
          
            throw new NotSupportedException();
        }

Добавил ещё бенчмарк код тут, можете у себя проверить. Результаты у меня выглядят так:

То есть, что способ через Unsafe (Sum_Unsafe), что через каст в Оbject (Sum_Оbject) что просто вызов оператора + (Sum_Operator) — все дают одинаковый результат (на уровне погрешности). Но в боевом коде думаю вполне возможна ситуации когда Jit не сможет заинлайнить метод и не выкинет каст в object, тогда как unsafe не создаёт дополнительных инструкций.

Метод через каст экземпляра (Sum_Cast) — в ~36-43 раза медленнее чем вызов оператора.

Описанный вариант вызова через expressions (Sum_Expression) самый сложный и самый медленный — в ~237 раз медленнее обычного вызова (а на CoreRT и вовсе в 872 раза медленнее, вероятно стоит им тикет по этому поводу поставить). Это можно объяснить тем что на каждой итерации делается обращение к словарю и после вызов делегата.

Ещё набросал более оптимальную версию через expressions (Sum_Expression_NoDict). Она с кешированием, но без словаря и немного оптимизирована для инлайнинга (вынес основную логику в отдельную функцию). Она всего в 10 раз медленнее (и в ~482 раза на CoreRT), то есть примерно как virtual call вместо простого сложения.

P.S.: Извините за поздний ответ в теме, только заметил апдейт в статье.