Ne peut spécifier à la fois une classe de contrainte et la contrainte de «classe» ou «structure»

Il n'y a actuellement que trois classes héritables dans le cadre dont les descendants peuvent être des types de valeur: objet , valeur de type et Enum . Les trois de ces types sont des types de classe, mais tout type dérivé de valueltype ou Enum sera un type de valeur et tout type dérivé de objet Ce qui n'est pas dérivé de valeur type sera un type de classe. Avec tout type autre que ce qui précède, un classe ou struct serait soit redondant, soit contradictoire; non coïncidemment, c # désactive les contraintes d'être directement spécifiés pour les types ci-dessus.

Dans certaines langues et cadres, une philosophie de conception dominante est que s'il existe une forme d'expression particulière où le comportement qui s'applique à cette forme générale serait inutile Il n'y a aucune raison pour que le concepteur de langue / cadre ne soit pas démarré pour interdire une telle forme. Sous une telle philosophie, il serait parfaitement légal d'avoir un type générique contraint à un type scellé (E.G. Fnord) . Une telle chose serait inutile si le type en question était scellé et que non la version future ne serait jamais autrement , mais puisque l'application de l'interprétation normale des contraintes génériques à une telle situation donnerait un comportement raisonnable et, étant donné qu'il pourrait être éventuellement certaines situations dans lesquelles de telles contraintes pourraient être utiles (par exemple, un code d'écriture pour utiliser une classe qui est en développement et qu'il est actuellement scellé, mais peut être scellé ou non à être scellé dans sa version finale, ni de son code d'écriture pour interfacer avec le code basé sur la réflexion que s'attend à ce que les formes génériques particulières), la philosophie suggère que contraignant un type générique à une classe scellée devrait être légal.

Dans certaines autres langues et cadres, une philosophie différente détient: Si un programmeur peut s'attendre à une forme particulière. d'une construction pour offrir des fonctionnalités au-delà de la forme générale, mais ce n'est pas le cas, et si cette forme particulière ne semblerait pas très utile sans de telles fonctionnalités, la langue devrait interdire, même si la construction serait VE un sens précis qui a été bien défini et ne pouvait être exprimé par d'autres moyens si les responsables de la langue ne voient pas une raison pour que les programmeurs veulent exprimer ce sens réel.

Le fait que ni C # NOR .NET n'a aucun problème à avoir un paramètre de type contraint à un autre, même lorsque cet autre paramètre est d'un type qui ne serait pas accepté comme une contrainte, suggère que la restriction est imposée artificiellement par la langue en raison de la philosophie susmentionnée. Il est malheureux, IMHO, puisqu'il y a de nombreuses situations où il serait utile de pouvoir dire, par exemple xxx

et même si .NET permettrait u utilement à une telle construction, et Même si le seul obstacle qui empêche le C # d'excepter du code informatique à rechercher explicitement de telles contraintes afin de les interdire, les concepteurs C # ont décidé d'interdire de telles constructions plutôt que de leur permettre de se comporter comme ça. HasanyFlags ne pouvait rien faire directement avec un t qu'il ne pouvait pas faire avec system.enum , et à l'aide d'un t en tant que system.enum ne serait généralement pas plus rapide que d'utiliser un system.enum (parfois plus lent), mais t pourrait néanmoins être utile pour un Motifs de couple:

1. La méthode pourrait appliquer au moment de la compilation que les paramètres doivent être le type * même * énuméré
2. La méthode pourrait utiliser une classe statique `énumevaluator` pour générer et cacher des délégués statiques de type` Func`, de telle que `HasanyFlags (t Enum1, t Enum2)` pourrait être mis en œuvre comme `Retour Enumevaluator.hasanyFlags (Enum1, Enum2); `. Une telle fonction pourrait être plus de dix fois aussi rapide que `Enum.hasflag`.

   Néanmène, utile, car il pourrait être de spécifier de telles contraintes, le seul moyen de les spécifier dans C # est d'avoir le code source C # spécifiant un type factice pouvant être utilisé comme contrainte, puis exécutez le code compilé via un utilitaire qui remplacera toutes les références au type factice avec des références au type que on voulait utiliser en premier lieu.