Есть ли причина, по которой C # не поддерживает ручные встроенные методы? А как насчет необязательных параметров?

Ручная вставка будет почти бесполезной. Компилятор JIT встрояет методы во встроенную компиляцию кода, где это необходимо, и я думаю, что почти во всех случаях JIT-компилятор лучше угадывает, когда это подходит, чем программист.

Что касается дополнительных параметров, я не знаю, почему их не было в предыдущих версиях. Тем не менее, я не люблю, чтобы они были там на С# 4, потому что я считаю их несколько вредными, потому что параметр запекается в сборку потребления, и вам нужно перекомпилировать его, если вы измените стандартные значения в DLL и хотите, чтобы потребитель чтобы использовать новые.

EDIT:

Дополнительная информация о inlining. Хотя вы не можете заставить компилятор JIT встроить вызов метода, вы можете заставить его НЕ встраивать вызов метода. Для этого вы используете System.Runtime.CompilerServices.MethodImplAttribute, например:

internal static class MyClass
{
    [System.Runtime.CompilerServices.MethodImplAttribute(MethodImplOptions.NoInlining)]
    private static void MyMethod()
    {
        //Powerful, magical code
    }

    //Other code
}

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

Затем вы выбрали неправильный язык. Я полагаю, вы действительно профилировали свой код (правильно?) И знаете, что нет ничего, кроме микрооптимизации, которая может вам помочь. Кроме того, вы используете высокопроизводительную собственную библиотеку bigint и не записываете свои собственные, не так ли?

Если это правда, не используйте .NET. Если вы считаете, что можете получить скорость по частичной специализации, перейдите в Haskell, C, Fortran или любой другой язык, который либо делает это автоматически, либо может предоставить вам инкрустировать, чтобы сделать это вручную.

Если Add(1) действительно имеет значение для вас, также важны распределения кучи.

Однако, вы должны действительно посмотреть, что может рассказать профайлер...

Мое образованное предположение: причина, по которой более ранние версии С# не имели необязательных параметров, из-за плохого опыта с ними в С++. На первый взгляд они выглядят прямолинейно, но есть несколько неприятных угловых случаев. Я думаю, что одна из книг Херба Саттера описывает это более подробно; в общем, это связано с переопределением методов virtual. Максимилиан упомянул об одном из случаев с .NET в его ответе.

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

Итак, после всех этих лет без них, почему С# 4.0 добавил их? 1) улучшенная четность с VB.NET и 2) более легкое взаимодействие с COM.

Java не включает ключевое слово inline. Лучшие JIT Java могут встроить даже виртуальные методы, а также использование ключевых слов, таких как private или final, не имеет никакого значения (раньше оно использовалось, но теперь это древняя история).

Даже в таких языках, как С++, вложение чего-то не гарантирует, что это произойдет; это подсказка для компилятора. Компилятор может либо взять подсказку, либо сделать свое дело.

С# - еще один шаг, удаленный из сгенерированного кода сборки (через IL + JIT), поэтому становится еще труднее гарантировать, что что-то будет встроено. Кроме того, у вас есть проблемы, подобные реализациям x86 + x64 JIT, отличающимся поведением.

С# добавил их в 4.0: http://msdn.microsoft.com/en-us/library/dd264739(VS.100).aspx

Что касается того, почему они не были сделаны с самого начала, это, скорее всего, потому, что они чувствовали, что перегрузки методов дают большую гибкость. При перегрузке вы можете указать несколько "значений по умолчанию" на основе других параметров, которые вы принимаете. Его также не намного больше синтаксиса.