Встроенные функции в C #?

Как вы делаете "встроенные функции" в C #? Я не думаю, что понимаю концепцию. Они как анонимные методы? Как лямбда-функции?

Примечание . Ответы почти полностью касаются возможности встроенных функций , т. Е. «Оптимизации вручную или компилятора, которая заменяет сайт вызова функции телом вызываемого». Если вас интересуют анонимные (или лямбда) функции , см . Ответ @ jalf или Что такое «лямбда», о которой все говорят? ,

Наконец, в .NET 4.5 CLR позволяет намекать / предлагать ¹ метод встраивания, используя MethodImplOptions.AggressiveInliningзначение. Это также доступно в стволе Моно (совершенный сегодня).

// The full attribute usage is in mscorlib.dll,
// so should not need to include extra references
using System.Runtime.CompilerServices; 

...

[MethodImpl(MethodImplOptions.AggressiveInlining)]
void MyMethod(...)

1 . Ранее здесь использовалась «сила». Поскольку было несколько отрицательных голосов, я попытаюсь уточнить этот термин. Как и в комментариях и документации, The method should be inlined if possible.особенно с учетом Mono (который открыт), существуют некоторые специфические для моно технические ограничения, касающиеся встраивания или более общие (например, виртуальные функции). В целом, да, это подсказка компилятору, но я думаю, это то, о чем просили.

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

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

Изменить: Чтобы уточнить, есть две основные причины, по которым их нужно использовать экономно:

1. Легко сделать массивные двоичные файлы с помощью встроенного в случаях, когда это не нужно
2. Компилятор имеет тенденцию знать лучше, чем вы, когда что-то должно быть с точки зрения производительности встроено

Лучше оставить все как есть и позволить компилятору выполнить свою работу, а затем профилировать и выяснить, является ли inline лучшим решением для вас. Конечно, некоторые вещи имеют смысл встраивать (в частности, в математические операторы), но, как правило, использование компилятора - это лучшая практика.

Обновление: Per ответ konrad.kruczynski в следующем верно для версий .NET до 4.0 включительно.

Вы можете использовать класс MethodImplAttribute, чтобы предотвратить вставку метода ...

[MethodImpl(MethodImplOptions.NoInlining)]
void SomeMethod()
{
    // ...
}

... но нет способа сделать обратное и заставить его быть встроенным.

Вы смешиваете две разные концепции. Встраивание функций - это оптимизация компилятора, которая не влияет на семантику. Функция ведет себя одинаково независимо от того, встроена она или нет.

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

В C # нет встроенного ключевого слова, потому что это оптимизация, которую обычно можно оставить компилятору, особенно в языках JIT. JIT-компилятор имеет доступ к статистике времени выполнения, что позволяет ему решать, что встроить гораздо эффективнее, чем вы можете при написании кода. Функция будет встроена, если компилятор решит, и вы ничего не можете с этим поделать. :)

Вы имеете в виду встроенные функции в смысле C ++? В каких случаях содержимое обычной функции автоматически копируется в строку вызова? Конечным эффектом является то, что при вызове функции не происходит никакого вызова функции.

Пример:

inline int Add(int left, int right) { return left + right; }

Если это так, то нет, C # не эквивалентно этому.

Или вы имеете в виду функции, которые объявлены внутри другой функции? Если это так, то да, C # поддерживает это с помощью анонимных методов или лямбда-выражений.

Пример:

static void Example() {
  Func<int,int,int> add = (x,y) => x + y;
  var result = add(4,6);  // 10
}

Коди это правильно, но я хочу привести пример того, что такое встроенная функция.

Допустим, у вас есть этот код:

private void OutputItem(string x)
{
    Console.WriteLine(x);

    //maybe encapsulate additional logic to decide 
    // whether to also write the message to Trace or a log file
}

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{  // let's pretend IEnumerable<T>.ToList() doesn't exist for the moment
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);
        OutputItem(y);
    }
    return result;
}

Компилятор Just-In-Time оптимизатор может выбрать , чтобы изменить код , чтобы избежать повторно поместить вызов OutputItem () в стеке, так что было бы , как если бы вы написали код , как это вместо того, чтобы :

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);

        // full OutputItem() implementation is placed here
        Console.WriteLine(y);   
    }

    return result;
}

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

Отредактировано, чтобы показать сценарий с большей вероятностью быть встроенным.

Да Точно, единственное различие - факт, что это возвращает значение.

Упрощение (без использования выражений):

List<T>.ForEach Принимает меры, не ожидает возврата.

Так что Action<T>делегата было бы достаточно .. сказать:

List<T>.ForEach(param => Console.WriteLine(param));

это то же самое, что сказать:

List<T>.ForEach(delegate(T param) { Console.WriteLine(param); });

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

В то время как

List<T>.Where Принимает функцию, ожидая результата.

Так Function<T, bool>что можно ожидать:

List<T>.Where(param => param.Value == SomeExpectedComparison);

что так же, как:

List<T>.Where(delegate(T param) { return param.Value == SomeExpectedComparison; });

Вы также можете объявить эти методы встроенными и присвоить их переменным IE:

Action myAction = () => Console.WriteLine("I'm doing something Nifty!");

myAction();

или

Function<object, string> myFunction = theObject => theObject.ToString();

string myString = myFunction(someObject);

Надеюсь, это поможет.

Есть случаи, когда я хочу заставить код быть встроенным.

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

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

Утверждение «лучше всего оставить все это в покое и позволить компилятору выполнить работу…» (Коди Брошиус) - полная чушь. Я программирую высокопроизводительный игровой код в течение 20 лет, и мне еще не приходилось сталкиваться с «достаточно умным» компилятором, который бы знал, какой код должен быть встроен (функции) или нет. Было бы полезно иметь «встроенный» оператор в c #, правда в том, что компилятор просто не имеет всей информации, необходимой для определения, какая функция должна быть всегда встроенной или нет без подсказки «inline». Конечно, если функция маленькая (accessor), то она может быть автоматически вставлена, но что, если это несколько строк кода? Безусловно, компилятор не знает, вы не можете просто оставить это на усмотрение компилятора (кроме алгоритмов).

Я знаю, что этот вопрос о C #. Тем не менее, вы можете написать встроенные функции в .NET с F #. смотрите: использование `inline` в F #

Нет, в C # такой конструкции нет, но JIT-компилятор .NET может решить выполнять вызовы встроенных функций во время JIT. Но я на самом деле не знаю, действительно ли он делает такие оптимизации.
(Думаю, так и должно быть :-))

Если ваши сборки будут созданы, вы можете взглянуть на TargetedPatchingOptOut. Это поможет ngen решить, следует ли использовать встроенные методы. Ссылка на MSDN

Тем не менее, это всего лишь декларативная подсказка для оптимизации, а не обязательная команда.

Лямбда-выражения являются встроенными функциями! Я думаю, что у C # нет лишних атрибутов, таких как inline или что-то в этом роде!

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

static void Main(string[] args)
{
    int a = 1;

    Action inline = () => a++;
    inline();
    //here a = 2
}