Вбудовані функції в C #?

Як ви робите "вбудовані функції" в C #? Я не думаю, що я розумію цю концепцію. Вони схожі на анонімні методи? Як функції лямбда?

Примітка . Відповіді майже повністю стосуються можливості вбудованих функцій , тобто "оптимізація вручну чи компілятора, яка замінює сайт виклику функції тілом виклику". Якщо вас цікавлять анонімні (інакше лямбда) функції , див. Відповідь @ jalf або Що це за "лямбда", про який всі говорять? .

Нарешті, у .NET 4.5 CLR дозволяє натякнути / запропонувати ¹ метод, вкладений з використанням MethodImplOptions.AggressiveInliningзначення. Він також доступний у багажнику Mono (вчинено сьогодні).

// 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. Компілятор, як правило, знає краще, ніж ви, коли щось, з точки зору продуктивності, має бути накресленим

Найкраще залишити речі в спокої і дозволити компілятору виконувати свою роботу, а потім профайлювати і з’ясувати, чи найкраще рішення для вас. Звичайно, деякі речі просто мають сенс бути накресленими (особливо математичні оператори), але дозволяти компілятору обробляти це, як правило, найкраща практика.

Оновлення: Відповідно до відповіді konrad.kruczynski , для версій .NET до версії 4.0 включається наступне.

Ви можете використовувати клас MethodImplAttribute, щоб запобігти введенню методу ...

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

... але немає способу зробити протилежне і змусити його накреслити.

Ви змішуєте дві окремі концепції. Функція вбудовування - це оптимізація компілятора, яка не впливає на семантику. Функція поводиться так само, незалежно від того, вбудована вона чи ні.

З іншого боку, лямбда-функції - це суто семантичне поняття. Немає вимог щодо того, як вони мають бути реалізовані або виконані, якщо вони дотримуються поведінки, викладеної в мовній специфікації. Вони можуть бути накреслені, якщо компілятор JIT відчуває, що це подобається, чи ні, якщо цього немає.

В C # немає ключового слова вбудованого тексту, оскільки це оптимізація, яку зазвичай можна залишити компілятору, особливо на мовах JIT'ed. Компілятор 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 років, і мені ще не довелося натрапити на достатньо розумний компілятор, щоб знати, який код слід накреслити (функції) чи ні. Було б корисно мати "inline" заяву в c #, правда, компілятор просто не має всієї необхідної інформації, щоб визначити, яка функція повинна бути вбудованою чи ні без підказки "inline". Звичайно, якщо функція невелика (аксесуар), вона може бути автоматично введена, але що робити, якщо це кілька рядків коду? Немає думки, компілятор не має можливості знати, ви не можете просто залишити це до компілятора для оптимізованого коду (крім алгоритмів).

Я знаю, це питання стосується C #. Однак ви можете записувати вбудовані функції в .NET за допомогою F #. див.: Використання `inline` у F #

Ні, такої конструкції в C # немає, але компілятор .NET JIT міг вирішити робити вбудовані виклики функцій у час JIT. Але я насправді не знаю, чи справді це оптимізація.
(Я думаю, що це повинно :-))

У випадку, якщо ваші збори будуть ngen-ed, ви можете поглянути на Tar targetPatchingOptOut. Це допоможе ngen вирішити, чи використовувати вбудовані методи. Посилання MSDN

Це все ще лише декларативний натяк на оптимізацію, але не імперативна команда.

Лямбда-вирази - це вбудовані функції! Я думаю, що у C # немає такого додаткового атрибуту, як вбудований чи щось подібне!

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

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

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