Pourquoi C # inclut-il des constructions de programmation qui ne sont pas conformes aux CLS?

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

  •  14-11-2019
  •  | 
  •  

Question

Il semble étrange que le langage phare de .NET inclue des constructions de programmation qui ne sont pas conformes aux CLS. Pourquoi donc?

Exemple (de ici): Deux membres internes publics / protégés / protégés définis avec une seule différence de cas

public int intA = 0;
public int INTA = 2;

ou 

public int x = 0;

public void X()
{
}
Était-ce utile?

La solution

Même les entiers non signés ne sont pas conformes (du moins, sur l'API publique), mais ils sont très importants pour les personnes qui font un changement de bit, en particulier lorsqu'ils se déplacent à droite (signé et non signé ont des comportements de décalage à droite différents).

Ils sont finalement là pour vous donner la liberté de les utiliser le cas échéant. La sensibilité de cas dont je pouvais devenir moins religieux - malgré le commodité d'avoir un champ et une propriété ne diffèrent que par cas, je pense que je pourrais vivre heureux avec le fait d'être obligé d'utiliser un nom différent! Surtout maintenant, nous avons automatiquement implémenté des propriétés ...

Ceci est similaire à la façon dont il vous permet d'utiliser unsafe - La différence ici étant que quelques entiers non signés ne vont pas déstabiliser tout le temps d'exécution, ils n'ont donc pas besoin de très forts Guards Molly.

Vous pouvez ajouter:

[assembly: CLSCompliant(true)]

Si vous le souhaitez, et le compilateur vous dira quand vous vous trompez.

Et enfin: plus Le code (par volume) n'est pas consommé en tant que composant. Il est écrit pour faire un travail et peut-être consommé par un autre code en interne. Ce sont principalement des rédacteurs / vendeurs de bibliothèque qui doivent s'inquiéter de choses comme la conformité CLS. C'est (par les chiffres) la minorité.

Autres conseils

Ce n'est pas ainsi que fonctionne la conformité CLS. C'est quelque chose qui est ton charge. C # ne se retient pas à une stricte conformité elle-même, ce qui en ferait une langue avec une mauvaise expressivité. Le fait de faire glisser toutes les langages .NET vers le plus bas dénominateur commun aurait rapidement tué la plate-forme comme un environnement de programmation viable.

C'est à vous de vous assurer que le publiquement Les types visibles dans votre assemblée rencontrent la conformité CLS. S'assurer que les membres de la classe ne diffèrent pas uniquement par cas est très simple à faire. Laissez le compilateur vous aider en utilisant l'attribut [assembly: CLSCompliant (true)] et le compilateur vous avertira lorsque vous avez glissé.

Voir http://msdn.microsoft.com/en-us/library/bhc3fa7f.aspx.

CLS est une spécification à laquelle on s'acte. Citation d'en haut:

Lorsque vous concevez vos propres composants conformes à CLS, il est utile d'utiliser un outil conforme à CLS. L'écriture de composants conformes aux CL sans ce support est plus difficile car sinon vous n'aurez peut-être pas accès à toutes les fonctionnalités CLS que vous souhaitez utiliser.

Certains compilateurs de langage conformes aux CL, tels que les compilateurs C # ou Visual Basic, vous permettent de spécifier que vous comptez que votre code soit conforme aux CLS. Ces compilateurs peuvent vérifier la conformité CLS et vous faire savoir quand votre code utilise des fonctionnalités qui ne sont pas prises en charge par le CLS. Les compilateurs C # et Visual Basic vous permettent de marquer un élément de programme comme conforme aux CLS, ce qui amènera le compilateur à générer une erreur de compilation en temps si le code n'est pas conforme à CLS. Par exemple, le code suivant génère un avertissement de compilateur.

Exemple de code à partir du lien ci-dessus:

using System;

// Assembly marked as compliant.
[assembly: CLSCompliant(true)]

// Class marked as compliant.
[CLSCompliant(true)]
public class MyCompliantClass {
   // ChangeValue exposes UInt32, which is not in CLS.
   // A compile-time warning results.
   public void ChangeValue(UInt32 value){ }

   public static void Main( ) {
   int i = 2;
   Console.WriteLine(i);
   }
}

Ce code génère l'avertissement C # suivant:

Copier l'avertissement CS3001: le type d'argument «Uint» n'est pas conforme aux CLS

Mes deux cents sur la conformité CLS

Les langues .NET sont toutes des évolutions de langues qui existaient au moment de sa création. Les langues ont été fabriquées afin que vous puissiez facilement convertir les projets de base en projets .NET sans trop d'efforts de développement. En raison des grandes différences entre les langues, il faut une sorte de convention pour que les langues se parlent. Prenez les exemples de langue ci-dessous:

VB.NET est une langue dérivée de la langue précédente VB6. Il est supposé être très similaire dans le style VB6 et en tant que tel prend beaucoup des conventions utilisées par VB6. Étant donné que VB6 était censé être facile à apprendre / utiliser par les non-développeurs, il a certaines caractéristiques qui le rendent plus idiot. Typage dynamique, insensibilité au cas étant deux de ces choses.

C # .NET / C ++. Net sont des dérivés du C ++ plus convivial des programmeurs. Puisqu'ils sont une évolution de cette langue, il y a des choses que C ++ vous laisserait faire. Sensibilité à la casse, typage statique, etc.

Maintenant, face à deux langues différentes, ils voulaient faire de Microsoft interopérable, j'ai fait la seule chose raisonnable. Ils ont fait des restrictions sur la façon dont les deux langues peuvent interagir les unes avec les autres grâce à l'utilisation d'un contrat logiciel essentiellement. Ce code ne peut être utilisé que de cette manière en raison des différences dans les langues.

Par exemple, prenez le code VB.NET CALPEL C # CODE Si le code C # avait deux fonctions qui différaient uniquement au cas où, x () vs x (), VB.NET ne pourrait jamais appeler ce code correctement car il est insensible au cas. La conformité CLS doit rendre cela illégal. Si vous regardez les autres règles, ils font essentiellement la même chose pour les autres fonctionnalités de la langue entre les différentes langues.

Je suppose que l'insensibilité au cas n'a été incluse que dans la conformité CLS afin que VB.NET puisse être conforme aux CLS. D'après ce que je comprends, il n'y a aucun problème si une construction de langage particulière n'est pas conforme aux CLS à moins que vous ne l'utilisiez de telle manière que les PEICE indemnisés soient disponibles dans l'API publique de votre code.

L'indice de Microsoft semble être que la conformité CLS n'est importante que dans le code auquel vous accédez à partir de différentes langues (comme la référence à un assembly C # à partir d'un projet VB.NET).

Je pense que Microsoft voulait donner aux développeurs la liberté. Aucune contrainte si ce n'est pas nécessaire. C # n'est pas limité par CLS car tout le monde n'a pas besoin d'interopérabilité avec VB.

S'il y avait un accord universel sur les fonctionnalités devraient être incluses dans un langage de programmation, le monde n'aurait besoin que d'un seul langage de programmation (qui inclurait précisément les fonctionnalités que tout le monde convenait être là). Bien sûr, en réalité, certaines personnes considéreront comme des caractéristiques importantes dont d'autres ne se soucient pas (ou même trouveront désagréable). La norme CLS fait essentiellement trois choses:

  1. Il indique que certaines fonctionnalités sont si importantes que tout langage qui ne les inclut pas doit être considéré comme inadéquat pour la programmation .NET à usage général.
  2. Il indique que les programmeurs dont les bibliothèques ne nécessitent aucune fonctionnalité que ceux énumérés devraient s'attendre à ce que leurs bibliothèques soient utilisables par les programmeurs utilisant tout langage adapté à la programmation .NET à terme.
  3. Il informe les programmeurs que si des parties de leurs bibliothèques nécessiteraient l'utilisation de fonctionnalités que les langages ne sont pas nécessaires pour prendre en charge, ces pièces peuvent ne pas être utilisables dans les langages qui conviennent à la programmation .NET, mais n'incluent pas les fonctionnalités requises.

Lorsque des langages comme VB.NET ou C # permettent la création d'une programmation conforme aux non-CLS, ce que cela signifie, c'est que Microsoft a décidé que certaines fonctionnalités étaient suffisamment utiles pour justifier l'inclusion dans ces langues, mais pas si merveilleuse ou non controversée que pour justifier la mandat de tous les langages les inclure.

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