C'è qualche motivo per cui C # non supporta i metodi inline manuali? E i parametri opzionali?

Question

C'è qualche motivo progettuale per questo (come il motivo per cui hanno rinunciato alla multi eredità)?

o semplicemente non era abbastanza importante?

e la stessa domanda si applica ai parametri opzionali nei metodi ... questo era già nella prima versione di vb.net ... quindi sicuramente nessuna pigrizia che fa sì che MS non consenta i parametri opzionali, probabilmente la decisione dell'architettura .. e sembra che abbiano cambiato idea, perché C # 4 lo includerà ..

Qualcuno sa quale è stata la decisione e perché l'hanno abbandonata?

Modifica

Forse non mi hai capito del tutto. Di recente sto lavorando a un programma di calcolo (supporta numeri di qualsiasi dimensione, fino all'ultima cifra), in cui alcuni metodi vengono usati letteralmente milioni di volte al secondo.

Supponi di avere un metodo chiamato Aggiungi (int num) e questo metodo viene usato molto silenziosamente con 1 come parametro ( Aggiungi (1); ), ho scoperto che è più veloce implementare un metodo speciale appositamente per uno. E non intendo sovraccarico - Scrivere un nuovo metodo chiamato AddOne e letteralmente copiare il metodo Add in esso, tranne che invece di usare num sto scrivendo 1 . Questo potrebbe sembrare orribilmente strano per te, ma in realtà più veloce.

(per quanto brutto sia)

Questo mi ha fatto chiedermi perché C # non supporta gli inline manuali che possono essere incredibilmente utili qui.

Grazie. (e perché mi hai votato: S)

Modifica 2:

Mi sono chiesto se aggiungerlo o meno. Conosco molto bene la stranezza (e gli svantaggi) della scelta di una piattaforma come dot net per tale progetto, ma penso che le ottimizzazioni di dot net siano più importanti di quanto si pensi ... specialmente funzionalità come Any CPU etc.

Answer 1

Per rispondere a una parte della tua domanda, vedi il post sul blog di Eric Gunnerson: Perché C # non ha una parola chiave" inline "?

Una citazione dal suo post:

  

Per C #, l'allineamento avviene in JIT   livello e JIT generalmente fa un   decisione decente.

EDIT: non sono sicuro del motivo del ritardo nel supporto dei parametri opzionali, tuttavia dicendo che "hanno rinunciato a" sembra che ci si aspettasse che lo implementassero in base alle nostre aspettative su ciò che altre lingue offrivano. Immagino che non fosse in cima alla loro lista di priorità e che avevano scadenze per ottenere alcune funzionalità fuori porta per ogni versione. Probabilmente non ha acquisito importanza fino ad ora, soprattutto perché il sovraccarico del metodo era un'alternativa disponibile. Nel frattempo abbiamo ottenuto generics (2.0) e le funzionalità che rendono possibile LINQ ecc. (3.0). Sono contento della progressione della lingua; le funzioni di cui sopra sono più importanti per me che ottenere supporto per i parametri opzionali all'inizio.

Answer 2

L'allineamento manuale sarebbe quasi inutile. Il compilatore JIT incorpora i metodi durante la compilazione del codice nativo, ove appropriato, e penso che in quasi tutti i casi il compilatore JIT sia più bravo a indovinare quando è appropriato del programmatore.

Per quanto riguarda i parametri opzionali, non so perché non fossero presenti nelle versioni precedenti. Detto questo, non mi piacciono che siano lì in C # 4, perché li considero un po 'dannosi perché il parametro viene cotto nell'assembly che consuma e devi ricompilarlo se cambi i valori standard in una DLL e vuoi che consumino assembly per usare quelli nuovi.

EDIT:

Alcune informazioni aggiuntive sull'inline. Sebbene non sia possibile forzare il compilatore JIT a incorporare una chiamata al metodo, è possibile forzarlo a NON incorporare una chiamata al metodo. Per questo, usi System.Runtime.CompilerServices.MethodImplAttribute, in questo modo:

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

    //Other code
}

Answer 3

La mia ipotesi istruita: il motivo per cui le versioni precedenti di C # non avevano parametri opzionali è a causa di brutte esperienze con loro in C ++. In superficie, sembrano abbastanza semplici, ma ci sono alcuni fastidiosi casi angolari. Penso che uno dei libri di Herb Sutter lo descriva in modo più dettagliato; in generale, ha a che fare con l'override dei metodi virtual . Maximilian ha menzionato uno dei casi angolari .NET nella sua risposta.

Puoi anche cavartela praticamente senza scrivere manualmente più sovraccarichi; questo potrebbe non essere molto utile per l ' autore della classe, ma i client difficilmente noteranno la differenza tra sovraccarichi e parametri opzionali.

Quindi, dopo tutti questi anni senza, perché li ha aggiunti C # 4.0? 1) miglioramento della parità con VB.NET e 2) interoperabilità più semplice con COM.

Answer 4

  

Di recente sto lavorando a un programma di calcolo (supporta numeri di qualsiasi dimensione, fino all'ultima cifra), in cui alcuni metodi vengono usati letteralmente milioni di volte al secondo.

Quindi hai scelto una lingua sbagliata. Suppongo che tu abbia effettivamente profilato il tuo codice (giusto?) E so che non c'è nulla oltre alle micro-ottimizzazioni che possono aiutarti. Inoltre, stai utilizzando una libreria bigint nativa ad alte prestazioni e non stai scrivendo la tua, vero?

Se questo è vero, non usare .NET. Se ritieni di poter ottenere velocità sulla specializzazione parziale, vai su Haskell, C, Fortran o qualsiasi altra lingua che lo fa automaticamente o che può esporre te stesso per farlo a mano.

Se Aggiungi (1) è davvero importante per te, anche le allocazioni di heap saranno importanti.

Tuttavia, dovresti davvero vedere cosa può dirti il ??profiler ...

Answer 5

C # li ha aggiunti in 4.0: http: / /msdn.microsoft.com/en-us/library/dd264739(VS.100).aspx

Per quanto riguarda il motivo per cui non sono stati eseguiti dall'inizio, è molto probabile perché hanno ritenuto che i sovraccarichi del metodo offrissero maggiore flessibilità. Con il sovraccarico è possibile specificare più "valori predefiniti" in base agli altri parametri che si stanno assumendo. Inoltre non è molto più sintassi.

Answer 6

Anche in linguaggi come il C ++, includere qualcosa non garantisce che ciò accada; è un suggerimento per il compilatore. Il compilatore può prendere il suggerimento o fare il proprio cosa .

C # è un altro passo rimosso dal codice assembly generato (tramite IL + JIT), quindi diventa ancora più difficile garantire che qualcosa sia in linea. Inoltre, hai problemi come le implementazioni x86 + x64 della JIT che differiscono nel comportamento.

Answer 7

Java non include neanche una parola chiave in linea . I migliori JIT Java possono incorporare anche metodi virtuali, né l'uso di parole chiave come privato o finale fa alcuna differenza (era solito, ma ora è storia antica).