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

StackOverflow https://stackoverflow.com/questions/1621623

  •  06-07-2019
  •  | 
  •  

Вопрос

Есть ли для этого какая-либо дизайнерская причина (например, причина, по которой они отказались от множественного наследования)?

или это просто было недостаточно важно?

и тот же вопрос применим к необязательным параметрам в методах...это уже было в первой версии vb.net ...так что это, конечно, не лень, из-за которой MS не разрешает необязательные параметры, вероятно, архитектурное решение..и, похоже, они изменили свое мнение по этому поводу, потому что C # 4 собирается включить это..

Кто-нибудь знает, каково было решение и почему они отказались от него?

Редактировать:

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

Допустим, у меня есть метод под названием Add(int num), и этот метод часто используется с параметром 1 в качестве параметра (Add(1);), я обнаружил, что быстрее реализовать специальный метод специально для одного.И я не имею в виду перегрузку - написать новый метод с именем addOne и буквально скопировать в него метод Add, за исключением того, что вместо использования num Я пишу 1.Это может показаться вам ужасно странным, но на самом деле это быстрее.

(как бы это ни было уродливо)

Это заставило меня задуматься, почему C # не поддерживает встроенное руководство, которое может быть удивительно полезным здесь.

Спасибо.(и почему вы проголосовали против меня: S)

Правка 2:

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

Это было полезно?

Решение

Чтобы ответить на часть вашего вопроса, смотрите запись в блоге Эрика Ганнерсона: Почему в C # нет ключевого слова 'inline'?

Цитата из его поста:

В C # встраивание происходит на уровне JIT , и JIT обычно принимает достойное решение.

Редактировать:Я не уверен в причине задержки поддержки дополнительных параметров, однако утверждение, что они "отказались" от этого, звучит так, как будто от них ожидали, что они реализуют это на основе наших ожиданий от того, что предлагали другие языки.Я предполагаю, что это не было на первом месте в их списке приоритетов, и у них были крайние сроки, чтобы выпустить определенные функции для каждой версии.Вероятно, до сих пор это не приобретало особого значения, тем более что перегрузка метода была доступной альтернативой.Тем временем мы получили дженерики (2.0), а также функции, которые делают LINQ возможным и т.д.(3.0).Я доволен развитием языка;вышеупомянутые функции для меня важнее, чем получение поддержки необязательных параметров на ранней стадии.

Другие советы

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

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

Редактировать:

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

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

    //Other code
}

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

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

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

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

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

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

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

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

C # добавил их в версии 4.0: http://msdn.microsoft.com/en-us/library/dd264739 (ПРОТИВ 100).aspx

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

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

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

Java не включает в себя встроенный ключевое слово либо.Лучшие Java JITs могут встроить даже виртуальные методы, а также использовать ключевые слова, такие как Частное или Финал имеет какое-либо значение (так было раньше, но теперь это древняя история).

Лицензировано под: CC-BY-SA с атрибуция
Не связан с StackOverflow
scroll top