Funzioni incorporate in C #?

Come si fanno le "funzioni incorporate" in C #? Non credo di capire il concetto. Sono come metodi anonimi? Ti piacciono le funzioni lambda?

Nota : le risposte riguardano quasi interamente la capacità di incorporare le funzioni , ovvero "un'ottimizzazione manuale o del compilatore che sostituisce un sito di chiamata di funzione con il corpo della chiamata". Se sei interessato a funzioni anonime (aka lambda) , vedi la risposta di @ jalf o Di cosa parla questo 'Lambda'? .

Infine in .NET 4.5, il CLR consente di suggerire / suggerire ¹ metodo inline usando il MethodImplOptions.AggressiveInliningvalore. È disponibile anche nel bagagliaio del Mono (impegnato oggi).

// 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 . Precedentemente qui veniva usata la "forza". Dato che c'erano alcuni voti negativi, cercherò di chiarire il termine. Come nei commenti e nella documentazione, The method should be inlined if possible.Soprattutto considerando Mono (che è aperto), ci sono alcune limitazioni tecniche mono-specifiche che considerano inline o più generali (come le funzioni virtuali). Nel complesso, sì, questo è un suggerimento per il compilatore, ma immagino che sia quello che è stato chiesto.

I metodi inline sono semplicemente un'ottimizzazione del compilatore in cui il codice di una funzione viene inserito nel chiamante.

Non esiste un meccanismo per farlo in C # e devono essere usati con parsimonia nelle lingue in cui sono supportati - se non sai perché dovrebbero essere usati da qualche parte, non dovrebbero esserlo.

Modifica: per chiarire, ci sono due motivi principali che devono essere usati con parsimonia:

1. È facile creare enormi binari usando inline nei casi in cui non è necessario
2. Il compilatore tende a sapere meglio di te quando qualcosa dovrebbe, dal punto di vista delle prestazioni, essere sottolineato

È meglio lasciare le cose da solo e lasciare che il compilatore faccia il suo lavoro, quindi profilare e capire se inline è la soluzione migliore per te. Certo, alcune cose hanno semplicemente senso essere allineate (in particolare operatori matematici), ma lasciare che il compilatore lo gestisca è in genere la migliore pratica.

Aggiornamento: Per la risposta di konrad.kruczynski , quanto segue è vero per le versioni di .NET fino ae includendo 4.0.

È possibile utilizzare la classe MethodImplAttribute per evitare che un metodo venga inline ...

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

... ma non c'è modo di fare il contrario e costringerlo ad essere allineato.

Stai mescolando due concetti separati. L'allineamento delle funzioni è un'ottimizzazione del compilatore che non ha alcun impatto sulla semantica. Una funzione si comporta allo stesso modo sia che sia incorporata o meno.

D'altra parte, le funzioni lambda sono puramente un concetto semantico. Non è richiesto il modo in cui devono essere implementati o eseguiti, purché seguano il comportamento indicato nelle specifiche del linguaggio. Possono essere integrati se il compilatore JIT ne ha voglia o no.

Non esiste una parola chiave incorporata in C #, perché è un'ottimizzazione che di solito può essere lasciata al compilatore, specialmente nei linguaggi JIT. Il compilatore JIT ha accesso alle statistiche di runtime che gli consentono di decidere cosa incorporare in modo molto più efficiente di quanto è possibile quando si scrive il codice. Una funzione verrà sottolineata se il compilatore decide, e non c'è niente che tu possa fare al riguardo. :)

Vuoi dire funzioni in linea in senso C ++? In quale contenuto di una normale funzione viene automaticamente copiato in linea nel sito di chiamata? L'effetto finale è che nessuna chiamata di funzione si verifica effettivamente quando si chiama una funzione.

Esempio:

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

In tal caso, no, non esiste C # equivalente a questo.

Oppure intendi funzioni dichiarate all'interno di un'altra funzione? In tal caso, sì, C # supporta questo tramite metodi anonimi o espressioni lambda.

Esempio:

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

Cody ha ragione, ma voglio fornire un esempio di cosa sia una funzione in linea.

Supponiamo che tu abbia questo codice:

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;
}

L' ottimizzatore Just-In-Time del compilatore potrebbe scegliere di modificare il codice per evitare di effettuare ripetutamente una chiamata a OutputItem () nello stack, in modo che sia come se invece avessi scritto il codice in questo modo:

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;
}

In questo caso, diremmo che la funzione OutputItem () era inline. Nota che potrebbe farlo anche se OutputItem () viene chiamato anche da altre posizioni.

Modificato per mostrare uno scenario più probabile da includere.

Sì Esatto, l'unica distinzione è il fatto che restituisce un valore.

Semplificazione (non usando espressioni):

List<T>.ForEach Intraprende un'azione, non prevede un risultato di ritorno.

Quindi un Action<T>delegato basterebbe .. dire:

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

è come dire:

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

la differenza è che il tipo di parametro e la declerazione del delegato sono dedotti dall'uso e le parentesi graffe non sono richieste su un metodo inline semplice.

Mentre

List<T>.Where Accetta una funzione, in attesa di un risultato.

Quindi Function<T, bool>ci si aspetterebbe:

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

che è lo stesso di:

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

Puoi anche dichiarare questi metodi in linea e assegnarli alle variabili IE:

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

myAction();

o

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

string myString = myFunction(someObject);

Spero che aiuti.

Ci sono occasioni in cui desidero forzare l'inserimento del codice.

Ad esempio, se ho una routine complessa in cui vi è un gran numero di decisioni prese all'interno di un blocco altamente iterativo e tali decisioni si traducono in azioni simili ma leggermente diverse da eseguire. Si consideri ad esempio un comparatore di ordinamento complesso (non basato su DB) in cui l'algoritmo di ordinamento ordina gli elementi in base a una serie di diversi criteri non correlati come si potrebbe fare se si ordinassero le parole in base a criteri grammaticali e semantici per un linguaggio veloce sistema di riconoscimento. Tenderei a scrivere funzioni di supporto per gestire tali azioni al fine di mantenere la leggibilità e la modularità del codice sorgente.

So che quelle funzioni di supporto dovrebbero essere allineate perché è così che il codice verrebbe scritto se non dovesse mai essere compreso da un essere umano. Vorrei certamente assicurarmi in questo caso che non vi fosse alcuna funzione di chiamata ambientale.

L'affermazione "è meglio lasciare queste cose da sole e lasciare che il compilatore faccia il lavoro .." (Cody Brocious) è un rubish completo. Sto programmando un codice di gioco ad alte prestazioni da 20 anni e devo ancora imbattermi in un compilatore che è "abbastanza intelligente" per sapere quale codice dovrebbe essere incorporato (funzioni) o meno. Sarebbe utile avere un'istruzione "inline" in c #, la verità è che il compilatore non ha tutte le informazioni necessarie per determinare quale funzione dovrebbe essere sempre incorporata o meno senza il suggerimento "inline". Sicuro se la funzione è piccola (accessor) potrebbe essere automaticamente incorporata, ma cosa succede se si tratta di poche righe di codice? Non ha senso, il compilatore non ha modo di saperlo, non puoi lasciarlo al compilatore per un codice ottimizzato (oltre gli algoritmi).

So che questa domanda riguarda C #. Tuttavia, è possibile scrivere funzioni incorporate in .NET con F #. vedi: Uso di `inline` in F #

No, non esiste tale costrutto in C #, ma il compilatore .NET JIT potrebbe decidere di eseguire chiamate di funzione inline al momento JIT. Ma in realtà non so se stia davvero facendo tali ottimizzazioni.
(Penso che dovrebbe :-))

Nel caso in cui i tuoi assiemi vengano modificati, potresti dare un'occhiata a TargetedPatchingOptOut. Ciò aiuterà ngen a decidere se includere metodi. Riferimento MSDN

È comunque solo un suggerimento dichiarativo da ottimizzare, non un comando imperativo.

Le espressioni lambda sono funzioni incorporate! Penso che C # non abbia un attributo extra come inline o qualcosa del genere!

C # non supporta i metodi (o le funzioni) incorporati come fanno i linguaggi dinamici come Python. Tuttavia, metodi anonimi e lambda possono essere utilizzati per scopi simili, anche quando è necessario accedere a una variabile nel metodo di contenimento, come nell'esempio seguente.

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

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