Question Quelle est la différence entre String et string en C #?


Exemple (notez le cas):

string s = "Hello world!";
String s = "Hello world!";

Que sont les des lignes directrices pour l'utilisation de chacun? Et quels sont les différences?


5345


origine


Réponses:


string est un alias en C # pour System.String.
Donc, techniquement, il n'y a pas de différence. C'est comme int  contre.  System.Int32.

En ce qui concerne les directives, il est généralement recommandé d'utiliser string chaque fois que vous faites référence à un objet.

par exemple.

string place = "world";

De même, je pense qu'il est généralement recommandé d'utiliser String si vous devez vous référer spécifiquement à la classe.

par exemple.

string greet = String.Format("Hello {0}!", place);

C'est le style que Microsoft a tendance à utiliser dans leurs exemples.


Il semble que les orientations dans ce domaine aient changé, StyleCop impose maintenant l'utilisation des alias spécifiques à C #.


5088



Juste pour l'exhaustivité, voici une décharge de cerveau d'informations connexes ...

Comme d'autres l'ont noté, string est un alias pour System.String. Ils compilent le même code, donc au moment de l'exécution, il n'y a aucune différence. C'est juste un des alias en C #. La liste complète est:

object:  System.Object
string:  System.String
bool:    System.Boolean
byte:    System.Byte
sbyte:   System.SByte
short:   System.Int16
ushort:  System.UInt16
int:     System.Int32
uint:    System.UInt32
long:    System.Int64
ulong:   System.UInt64
float:   System.Single
double:  System.Double
decimal: System.Decimal
char:    System.Char

Excepté string et object, les alias sont tous des types de valeur. decimal est un type de valeur, mais pas un type primitif dans le CLR. Le seul type primitif qui n'a pas d'alias est System.IntPtr.

Dans la spécification, les alias de type valeur sont appelés "types simples". Les littéraux peuvent être utilisés pour des valeurs constantes de chaque type simple; aucun autre type de valeur n'a de forme littérale disponible. (Comparez cela avec VB, ce qui permet DateTime littéraux, et a un alias pour cela aussi.)

Il y a une circonstance dans laquelle vous avoir utiliser les alias: lors de la spécification explicite du type sous-jacent d'une énumération. Par exemple:

public enum Foo : UInt32 {} // Invalid
public enum Bar : uint   {} // Valid

C'est juste une question de la façon dont la spécification définit les déclarations enum - la partie après le colon doit être le type intégral production, qui est un jeton de sbyte, byte, short, ushort, int, uint, long, ulong, char... par opposition à un type production telle qu'utilisée par les déclarations de variables par exemple. Cela n'indique aucune autre différence.

Enfin, quand il s'agit de l'utiliser: personnellement, j'utilise les alias partout pour l'implémentation, mais le type CLR pour toutes les API. Peu importe ce que vous utilisez en termes de mise en œuvre - la cohérence entre votre équipe est agréable, mais personne d'autre ne s'en souciera. D'autre part, il est vraiment important que si vous vous référez à un type dans une API, vous le faites de manière neutre. Une méthode appelée ReadInt32 est sans ambiguïté, alors qu'une méthode appelée ReadInt nécessite une interprétation. L'appelant pourrait utiliser un langage qui définit un int alias pour Int16, par exemple. Les concepteurs de framework .NET ont suivi ce modèle, de bons exemples étant dans le BitConverter, BinaryReader et Convert Des classes.


3031



String signifie System.String et c'est un type .NET Framework. string est un alias dans la langue C # pour System.String. Les deux sont compilés pour System.String en IL(Langue Intermédiaire), donc il n'y a pas de différence. Choisissez ce que vous aimez et utilisez-le. Si vous codez en C #, je préférerais string comme c'est un alias de type C # et bien connu par les programmeurs C #.

Je peux dire la même chose à propos de (int, System.Int32) etc..


607



La meilleure réponse que j'ai jamais entendu à propos de l'utilisation des alias de type fournis en C provient de Jeffrey Richter dans son livre CLR Via C #. Voici ses 3 raisons:

  • J'ai vu un certain nombre de développeurs confus, ne sachant pas s'il fallait utiliser chaîne ou Chaîne dans leur code. Parce que dans C # la chaîne (un mot-clé) correspond exactement à System.String (un type FCL), il n'y a pas de différence et peut être utilisée.
  • En C #, longue cartes à System.Int64, mais dans un langage de programmation différent, longue pourrait mapper à un Int16 ou Int32. En fait, C ++ / CLI traite en fait longtemps comme Int32. Quelqu'un lisant le code source dans une langue pourrait facilement mal interpréter l'intention du code s'il ou elle avait l'habitude de programmer dans un langage de programmation différent. En fait, la plupart des langues ne traiteront même pas longue comme un mot-clé et ne compilera pas le code qui l'utilise.
  • Le FCL a de nombreuses méthodes qui ont des noms de type dans le cadre de leurs noms de méthodes. Par exemple, le BinaryReader type offre des méthodes telles que ReadBoolean, ReadInt32, ReadSingle, et ainsi de suite, et System.Convert type offre des méthodes telles que ToBoolean, ToInt32, ToSingle, etc. Bien qu'il soit légal d'écrire le code suivant, la ligne avec float me semble très anormale, et il n'est pas évident que la ligne soit correcte:
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

Donc là vous l'avez. Je pense que ce sont tous de très bons points. Cependant, je ne me vois pas utiliser les conseils de Jeffrey dans mon propre code. Peut-être que je suis trop coincé dans mon monde C # mais je finis par essayer de faire ressembler mon code au code du framework.


409



string est un mot réservé, mais String est juste un nom de classe. Cela signifie que string ne peut pas être utilisé comme nom de variable par lui-même.

Si pour une raison quelconque, vous vouliez une variable appelée chaîne, vous ne verriez que la première de ces compilations:

StringBuilder String = new StringBuilder();  // compiles
StringBuilder string = new StringBuilder();  // doesn't compile 

Si vous voulez vraiment un nom de variable appelé chaîne vous pouvez utiliser @ en préfixe:

StringBuilder @string = new StringBuilder();

Une autre différence essentielle: Stack Overflow les met en évidence différemment.


380



Il y a une différence - Vous ne pouvez pas utiliser String sans pour autant using System; préalablement.


327



Il a été couvert ci-dessus; Cependant, vous ne pouvez pas utiliser string en réflexion Tu dois utiliser String.


269



System.String est la classe de chaînes .NET - en C # string est un alias pour System.String - Donc en cours d'utilisation, ils sont les mêmes.

Pour ce qui est des lignes directrices, je ne m'embarrasserais pas trop et j'utiliserais ce que vous voudrez - il y a des choses plus importantes dans la vie et le code sera le même de toute façon.

Si vous trouvez des systèmes de construction où il est nécessaire de spécifier la taille des entiers que vous utilisez et que vous avez tendance à utiliser Int16, Int32, UInt16, UInt32 etc alors il pourrait sembler plus naturel d'utiliser String- et quand on se déplace entre différents langages .net cela peut rendre les choses plus compréhensibles - sinon j'utiliserais string et int.


204



Je préfère les capitalisés .NET types (plutôt que les alias) pour des raisons de formatage. le .NET les types sont colorés de la même manière que les autres types d'objets (les types de valeur sont des objets propres, après tout).

Mots clés conditionnels et de contrôle (comme if, switch, et return) sont en minuscules et en bleu foncé coloré (par défaut). Et je préférerais ne pas avoir le désaccord dans l'utilisation et le format.

Considérer:

String someString; 
string anotherString; 

167



string et String sont identiques de toutes les façons (sauf les majuscules "S"). Il n'y a aucune implication de performance de toute façon.

Minuscule string est préféré dans la plupart des projets en raison de la coloration syntaxique


166



C # est un langage utilisé avec le CLR.

string est un type en C #.

System.String est un type dans le CLR.

Lorsque vous utilisez C # avec le CLR string sera mappé à System.String.

Théoriquement, vous pouvez implémenter un compilateur C # qui a généré le bytecode Java. Une implémentation judicieuse de ce compilateur permettrait probablement de string à java.lang.String afin d'interopérer avec la bibliothèque d'exécution Java.


154