Y a-t-il une raison pour laquelle C # ne prend pas en charge les méthodes en ligne manuelles? Et qu'en est-il des paramètres facultatifs?

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

  •  06-07-2019
  •  | 
  •  

Question

Existe-t-il une raison de conception à cela (comme la raison pour laquelle ils ont abandonné l'héritage multiple)?

ou ce n'était tout simplement pas assez important?

et la même question s’applique aux paramètres facultatifs dans les méthodes ... c’était déjà dans la première version de vb.net ... donc il n’ya sûrement pas de paresse qui empêche MS de permettre les paramètres facultatifs, probablement une décision d’architecture .. et cela semble avoir changé d'avis à ce sujet, car le C # 4 va inclure cela.

Quelqu'un sait-il quelle a été la décision et pourquoi l'ont-ils abandonné?

EDIT:

Peut-être que vous ne m'avez pas bien compris. Je travaille dernièrement sur un programme de calcul (nombres de support de toute taille, jusqu'au dernier chiffre), dans lequel certaines méthodes sont utilisées littéralement des millions de fois par seconde.

Disons que j'ai une méthode appelée Add (int num), et que cette méthode est très utilisée avec 1 comme paramètre ( Add (1); ), j'ai découvert que c'était plus rapide mettre en œuvre une méthode spéciale en particulier pour un. Et je ne parle pas de surcharge: écrire une nouvelle méthode appelée AddOne et y copier littéralement la méthode Add, sauf qu'au lieu d'utiliser num , j'écris 1 . Cela peut vous paraître terriblement étrange, mais en réalité, il est plus rapide.

(autant que c'est moche)

Cela m'a fait me demander pourquoi C # ne prend pas en charge le mode manuel, ce qui peut être incroyablement utile ici.

merci (et pourquoi m'as-tu voté bas: S)

Modifier 2:

Je me suis demandé s'il fallait ou non ajouter ceci. Je connais très bien les bizarreries (et les inconvénients) de choisir une plate-forme telle que dot net pour un tel projet, mais je pense que les optimisations dot net sont plus importantes que vous ne le pensez ... en particulier des fonctionnalités telles que Tout processeur, etc.

Était-ce utile?

La solution

Pour répondre à une partie de votre question, consultez le blog d'Eric Gunnerson: Pourquoi C # n'a-t-il pas de mot clé 'en ligne'?

Une citation de son message:

  

Pour C #, l'inline se produit à la JIT   niveau, et l’EEC fait généralement une   décision décente.

EDIT: Je ne suis pas sûr de la raison de la prise en charge retardée des paramètres facultatifs, mais ils sont "abandonnés". On dirait qu’ils sont censés l’appliquer en fonction de nos attentes par rapport aux autres langues proposées. J'imagine que cela ne figurait pas en tête de leur liste de priorités et qu'ils avaient des délais pour que certaines fonctionnalités soient disponibles pour chaque version. Cela n’a probablement pas gagné en importance jusqu’à présent, d’autant plus que la surcharge de méthodes était une alternative disponible. En attendant, nous avons des génériques (2.0) et les fonctionnalités qui rendent LINQ possible, etc. (3.0). Je suis content de la progression de la langue. Les fonctionnalités mentionnées ci-dessus sont plus importantes pour moi que d'obtenir rapidement de l'aide pour les paramètres facultatifs.

Autres conseils

La mise en ligne manuelle serait presque inutile. Le compilateur JIT insère des méthodes au cours de la compilation de code natif, le cas échéant, et je pense que dans presque tous les cas, le compilateur JIT est plus à même de deviner quand il convient que le programmeur.

En ce qui concerne les paramètres facultatifs, je ne sais pas pourquoi ils n'étaient pas présents dans les versions précédentes. Cela dit, je n’aime pas qu’ils soient là en C # 4, car je les considère un peu nuisibles car le paramètre est intégré dans l’assemblage consommateur et vous devez le recompiler si vous modifiez les valeurs standard dans une DLL et que vous voulez que ce soit consommateur. assemblage pour utiliser les nouveaux.

EDIT:

Quelques informations supplémentaires sur l'inlining. Bien que vous ne puissiez pas forcer le compilateur JIT à intégrer un appel de méthode, vous pouvez le forcer à NE PAS insérer un appel à une méthode. Pour cela, vous utilisez System.Runtime.CompilerServices.MethodImplAttribute, comme suit: 

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

    //Other code
}

Mon estimation éclairée: la raison pour laquelle les versions précédentes de C # n'avaient pas de paramètres facultatifs était due à de mauvaises expériences avec C ++. En apparence, ils ont l'air assez simple, mais il y a quelques cas inquiétants. Je pense qu'un des livres de Herb Sutter décrit cela plus en détail; en général, il s'agit de redéfinir les méthodes virtual . Maximilian a mentionné l'un des cas de coin .NET dans sa réponse.

Vous pouvez également vous en sortir en écrivant manuellement plusieurs surcharges; cela peut ne pas être très agréable pour l'auteur de la classe, mais les clients ne remarqueront guère la différence entre les surcharges et les paramètres facultatifs.

Après toutes ces années, pourquoi C # 4.0 les at-il ajoutés? 1) amélioration de la parité avec VB.NET et 2) interopérabilité plus facile avec COM.

  

Je travaille depuis peu sur un programme de calcul (nombres de support de toute taille, jusqu'au dernier chiffre), dans lequel certaines méthodes sont utilisées littéralement des millions de fois par seconde.

Ensuite, vous avez choisi une mauvaise langue. Je suppose que vous avez réellement profilé votre code (non?) Et que vous savez qu'il n'y a rien en dehors de la micro-optimisation qui puisse vous aider. De plus, vous utilisez une bibliothèque bigint native hautes performances et n'écrivez pas la vôtre, n'est-ce pas?

Si c'est vrai, n'utilisez pas .NET. Si vous pensez que vous pouvez gagner en rapidité avec une spécialisation partielle, accédez à Haskell, C, Fortran ou à n’importe quel autre langage le faisant automatiquement ou vous exposant à la possibilité de vous y inscrire à la main.

Si Add (1) a vraiment de l'importance pour vous, les allocations de tas seront également importantes.

Cependant, vous devriez vraiment regarder ce que le profileur peut vous dire ...

C # les a ajoutés à la version 4.0: http: / /msdn.microsoft.com/en-us/library/dd264739(VS.100).aspx

Pour ce qui est de la raison pour laquelle elles n’ont pas été faites dès le début, c’est probablement parce qu’elles estimaient que les surcharges de méthodes donnaient plus de souplesse. Avec la surcharge, vous pouvez spécifier plusieurs "valeurs par défaut" en fonction des autres paramètres que vous prenez. Ce n’est pas beaucoup plus syntaxique.

Même dans des langages tels que C ++, aligner quelque chose ne garantit pas que cela se produira; c'est un indice pour le compilateur. Le compilateur peut suivre l'indication ou faire sa propre chose .

C # est une autre étape supprimée du code d'assemblage généré (via IL + le JIT), il devient donc encore plus difficile de garantir que quelque chose sera en ligne. De plus, vous avez des problèmes tels que les implémentations x86 + x64 du JIT qui diffèrent par leur comportement.

Java n'inclut pas non plus de mot clé intégré . Les meilleurs JIT Java peuvent intégrer des méthodes même virtuelles, et l'utilisation de mots clés tels que privé ou final ne fait aucune différence (ce qui était le cas auparavant, mais cela fait maintenant partie de l'histoire ancienne).

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top