web-dev-qa-db-fra.com

Pourquoi n'y a-t-il pas de macros en C #?

Lorsque j'ai appris le C # pour la première fois, j'ai été surpris de constater qu'ils ne supportaient pas les macros de la même capacité que celle existant en C/C++. Je me rends compte que le mot clé #define existe en C #, mais il fait grandement défaut par rapport à ce que j'ai appris à aimer en C/C++. Est-ce que quelqu'un sait pourquoi de vrais il manque des macros en C #?

Je m'excuse si cette question a déjà été posée, sous une forme ou une autre. Je vous promets que j'ai passé 5 bonnes minutes à chercher des doublons avant de poster.

c#.netmacrosc-preprocessor
48
Andrew Garrison

Pour que vous puissiez vous amuser en tapant CECI encore et encore.

// Windows presetation foundation dependency property.
public class MyStateControl : ButtonBase
{
  public MyStateControl() : base() { }
  public Boolean State
  {
    get { return (Boolean)this.GetValue(StateProperty); }
    set { this.SetValue(StateProperty, value); } 
  }
  public static readonly DependencyProperty StateProperty = DependencyProperty.Register(
    "State", typeof(Boolean), typeof(MyStateControl),new PropertyMetadata(false));
}

Évidemment, les concepteurs de C # et de .NET n'utilisent jamais les bibliothèques ou les frameworks qu'ils créent. S'ils le faisaient, ils se rendraient compte qu'une certaine forme de système macro syntactique hygiénique est définitivement en ordre. 

Ne laissez pas les faiblesses des macros boiteuses de C et C++ vous contrarier du pouvoir de la résolution du code de compilation. La résolution du temps de compilation et la génération de code vous permettent d’exprimer plus efficacement le sens et l’intention du code sans avoir à épeler tous les détails du code source. Par exemple, si vous pouviez remplacer ce qui précède par ceci:

public class MyStateControl : ButtonBase
{
  public MyStateControl() : base() { }

  [DependencyProperty(DefaultValue=true)] 
  bool State { get; set; }
}

Boo les a, OcamML (au moins Meta ML) les a, et C et C++ les ont (sous une forme désagréable, mais mieux que de ne pas en avoir du tout). C # ne le fait pas.

35
bencooley

C # s'adresse à un public plus large (ou à un autre terme, base de consommateurs) que C++, C ou ASM. Le seul moyen d’atteindre cet objectif est d’atteindre des programmeurs considérablement moins qualifiés. Par conséquent, tous les outils puissants mais dangereux sont enlevés. C'est à dire. macros, héritage multiple, contrôle de la durée de vie d'un objet ou programmation indépendante du type.

De la même manière, les allumettes, les couteaux et les pistolets de scellement sont utiles et nécessaires, mais ils doivent être tenus hors de portée des enfants. (malheureusement, des incendies criminels, des meurtres, des fuites de mémoire et du code illisible se produisent toujours).

Et avant de m'accuser de ne pas penser en C #, combien de fois avez-vous écrit cela:

protected int _PropOne;
public int PropOne
{
    get
    {
        return _PropOne;
    }
    set
    {
        if(value == _PropOne) { return; }
        NotifyPropertyChanging("PropOne");
        _PropOne = value;
        NotifyPropertyChanged("PropOne");
    }
}

Avec les macros, à chaque fois, ces 16 lignes ressemblent à ça:

DECLARE_PROPERTY(int, PropOne)
DECLARE_PROPERTY(string, PropTwo)
DECLARE_PROPERTY(BitmapImage, PropThree)
9
Agent_L

Les macros en C/C++ ont été utilisées pour définir des constantes, produire de petites fonctions inline et pour diverses choses directement liées à la compilation du code (#ifdef). 

En C #, vous avez des constantes fortement typées, un compilateur assez intelligent pour intégrer des fonctions en ligne lorsque cela est nécessaire, et vous savez compiler correctement (sans en-tête non compilé). 

Mais il n'y a pas de raison particulière pour laquelle vous ne pouvez pas exécuter votre fichier CS via le préprocesseur C si vous le souhaitez vraiment :)

4
Seth

En tant que programmeur C # de longue date qui est parti apprendre le C++ pendant un certain temps, la prise en charge de la métaprogrammation C # me manque maintenant. Au moins, je comprends maintenant mieux ce que peut signifier métaprogrammation.

J'aimerais vraiment voir le type de support macro instillé dans Nemerle en C #. Cela semble ajouter une capacité d'extension très naturelle et puissante à la langue. Si vous ne l'avez pas examiné, je vous le recommande vivement.

Il y a d'excellents exemples sur Wikipedia .

2
Drew Noakes

Les macros sont surchargées dans C++ mais ils ont toujours leurs utilisations . Cependant, la plupart de ces utilisations ne sont pas pertinentes dans C# en raison de la réflexion et de la meilleure utilisation intégrée des exceptions pour le signalement des erreurs.

1
Motti

Cet article compare les macros Perl et LISP mais le point reste le même: les macros de niveau texte (Perl/c ++) causent des problèmes énormes par rapport aux macros de niveau source (LISP)

http://lists.warhead.org.uk/pipermail/iwe/2005-July/000130.html

Des gens plus courageux que moi ont lancé leur propre macro comme un système en c # http://www.codeproject.com/KB/recipes/prepro.aspx

1
Matthew Lock

Tous ceux qui sont d’accord avec l’idée que les macros sont mauvaises devraient lire le livre "Avec les mains jointes". http://en.wikipedia.org/wiki/With_Folded_Hands Il raconte comment nous pouvons empêcher les gens de faire des choses stupides au point de les empêcher de faire des choses très sages. 

Bien que j'aime C #, je déteste vraiment que cela contribue à la stupidification des ingénieurs en logiciel. Alors, oui, laissez les macros aux professionnels. Pendant que nous y sommes, laissez également les professionnels nommer les variables. Cela peut donner du code vraiment illisible. Pour suivre la déclaration complète de "le code doit être lisible en définitive", toutes les variables doivent être nommées A-Z, suivies de a-z (ou de toute autre construction arbitraire, comme uniquement les noms). Parce qu'une personne non qualifiée peut nommer sa variable "SomethingUsefulButNotAllowedByTheCompilerBecauseSomeUsersMayDoDumbThings".

0
Kevin Williams

Les macros sont un outil pour l'époque où la plupart des programmeurs étaient plus intelligents que le compilateur. En C/C++, cela reste vrai dans certains cas.

De nos jours, la plupart des programmeurs ne sont pas aussi intelligents que le compilateur/runtime C #.

0
Imagist