.net caractère - Quelle est la différence entre String et string en C#?



spéciaux operator (25)

Exemple ( notez le cas ):

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

Quelles sont les directives pour l'utilisation de chacun? Et quelles sont les différences ?


Answers

string est un mot réservé, mais String n'est qu'un nom de classe. Cela signifie que la string ne peut pas être utilisée seule comme nom de variable.

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 @ comme préfixe:

StringBuilder @string = new StringBuilder();

Autre différence critique: le dépassement de capacité les met en évidence différemment.


System.String est la classe de chaînes .NET. En C #, string est un alias pour System.String . Par conséquent, leur utilisation est identique.

En ce qui concerne les directives, je ne m'embourberais pas trop et utiliserais ce que vous voudriez être - il y a des choses plus importantes dans la vie et le code sera le même de toute façon.

Si vous vous trouvez en train de construire des systèmes 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., il peut sembler plus naturel d'utiliser String - et lorsque vous vous déplacez entre différents Les langages .net pourraient rendre les choses plus compréhensibles - sinon, j'utiliserais string et int.


Il y a une différence : vous ne pouvez pas utiliser String sans using System; préalablement.


Contrairement à ce qui semble être une pratique courante chez les autres programmeurs, je préfère String à string , juste pour souligner le fait que String est un type de référence, comme l'a mentionné Jon Skeet.


Il y a une citation sur ce numéro du livre de Daniel Solis .

Tous les types prédéfinis sont directement mappés aux types .NET sous-jacents. Les noms de type C # (chaîne) sont simplement des alias pour les types .NET (String ou System.String), de sorte que l'utilisation des noms .NET fonctionne parfaitement syntaxiquement, bien que cela soit déconseillé. Dans un programme C #, vous devez utiliser les noms C # plutôt que les noms .NET.


Je préfère les types .NET majuscules (plutôt que les alias) pour des raisons de formatage. Les types .NET ont la même couleur que les autres types d'objet (les types de valeur sont des objets appropriés, après tout).

Les mots-clés conditionnels et de contrôle (tels que if , switch et return ) sont en minuscule et en bleu foncé (par défaut). Et je préférerais que le désaccord ne soit pas utilisé ni formaté.

Considérer:

String someString; 
string anotherString; 

String représente System.String et il s'agit d'un type .NET Framework. string est un alias dans le langage C # pour System.String . Les deux sont compilés dans System.String en IL (langage intermédiaire), il n'y a donc pas de différence. Choisissez ce que vous aimez et utilisez-le. Si vous codez en C #, je préférerais string car il s’agit d’un alias de type C # bien connu des programmeurs C #.

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


L'utilisation des types de système facilite le portage entre C # et VB.Net, si vous êtes dans ce genre de chose.


C'est couvert ci-dessus; Cependant, vous ne pouvez pas utiliser de string en réflexion; vous devez utiliser String .


Les deux sont les même. Mais du point de vue des directives de codage, il est préférable d’utiliser string au lieu de String . C'est ce que les développeurs utilisent généralement. par exemple, au lieu d'utiliser Int32 nous utilisons int comme int est alias pour Int32

FYI «La chaîne de mots clés est simplement un alias de la classe prédéfinie System.String .» - Spécification du langage C # 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx


Comme le disent les autres, ils sont identiques. Les règles StyleCop, par défaut, vous obligeront à utiliser string comme bonne pratique de style de code C #, sauf lors du référencement de fonctions statiques System.String , telles que String.Format , String.Join , String.Concat , etc.


String ( System.String ) est une classe de la bibliothèque de classes de base. string (minuscule) est un travail réservé en C # qui est un alias pour System.String. Int32 vs int est une situation similaire au Boolean vs. bool . Ces mots clés spécifiques au langage C # vous permettent de déclarer des primitives dans un style similaire à C.


Juste pour être complet, voici un tas d’informations connexes ...

Comme d'autres l'ont noté, string est un alias de System.String . Ils compilent dans le même code, donc au moment de l'exécution, il n'y a aucune différence. Ceci 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

En dehors de string et object , les alias sont tous des types 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 les valeurs constantes de chaque type simple; aucun autre type de valeur n'a de forme littérale disponible. (Comparez cela avec VB, qui autorise les littéraux DateTime et possède également un alias.)

Il existe une situation dans laquelle vous devez utiliser les alias: lorsque vous spécifiez explicitement le 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 côlon doit être la production de type intégral , qui est un signe de sbyte , byte , short , ushort , int , uint , long , ulong , char . .. par opposition à une production de type telle qu'utilisée par les déclarations de variables, par exemple. Cela n'indique aucune autre différence.

Enfin, quand il s'agit d'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 au sein de votre équipe est une bonne chose, mais personne d'autre ne s'en soucie. D'un autre côté, il est réellement important que si vous faites référence à un type dans une API, vous le fassiez 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 peut utiliser un langage qui définit un alias int pour Int16 , par exemple. Les concepteurs du framework .NET ont suivi ce modèle, de bons exemples étant dans les BitConverter , BinaryReader et Convert .


Oui, il n'y a pas de différence entre eux, tout comme le boolet Boolean.


Il n'y a pas de différence entre les deux string, cependant, semble être l'option privilégiée lorsque l'on considère le code source d'autres développeurs.


Il n'y a pas de différence.

Le mot clé C # stringcorrespond au type .NET System.String- il s'agit d'un alias qui respecte les conventions de dénomination du langage.

De même, les intcartes pour System.Int32.


La string minuscule est un alias pour System.String . Ils sont les mêmes en C# .

Il existe un débat sur l'opportunité d'utiliser les types de types System ( System.Int32 , System.String , etc.) ou les C# aliases ( int , string , etc.). Personnellement, je pense que vous devriez utiliser les C# aliases , mais ce n’est que ma préférence personnelle.


String n'est pas un mot clé et peut être utilisé comme identifiant, alors que string est un mot clé et ne peut pas être utilisé comme identifiant. Et du point de vue fonctionnel, les deux sont identiques.


string est juste un alias pour System.String . Le compilateur les traitera de manière identique.

La seule différence pratique est la coloration syntaxique que vous mentionnez, et que vous devez écrire using System si vous utilisez String .


chaîne est un mot clé et vous ne pouvez pas utiliser chaîne comme identifiant.

String n'est pas un mot clé et vous pouvez l'utiliser comme identifiant:

Exemple

string String = "I am a string";

Le mot clé stringest un alias car, System.Stringmis à part le mot clé problème, les deux sont exactement équivalents.

 typeof(string) == typeof(String) == typeof(System.String)

C'est une question de convention, vraiment. string ressemble plus au style C / C ++. La convention générale consiste à utiliser les raccourcis fournis par la langue choisie (int / Int pour Int32 ). Cela vaut pour "objet" et decimal aussi.

Théoriquement, cela pourrait aider à transférer du code dans un futur standard 64 bits dans lequel "int" pourrait signifier Int64, mais ce n'est pas le point, et je m'attendrais à ce que tout assistant de mise à niveau modifie les intréférences de Int32toute façon pour être sûr.


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

En ce qui concerne les directives, il est généralement recommandé d’utiliser une 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 indications dans ce domaine ont peut-être changé, car StyleCop impose désormais l'utilisation des alias spécifiques à C #.


Arriver en retard à la fête: j'utilise les types CLR 100% du temps (enfin, sauf si je suis obligé d'utiliser le type C #, mais je ne me souviens pas de la date de la dernière fois).

J'ai commencé à faire cela il y a des années, selon les livres CLR de Ritchie. Il était logique pour moi que tous les langages CLR doivent en fin de compte pouvoir prendre en charge l'ensemble des types de CLR. Par conséquent, l'utilisation des types de CLR vous-même fournit un code plus clair et éventuellement plus "réutilisable".

Maintenant que je le fais depuis des années, c'est une habitude et j'aime la coloration que VS montre pour les types CLR.

Le seul inconvénient réel est que l'auto-complétion utilise le type C #. Je finis donc par ressaisir les types générés automatiquement pour spécifier le type CLR.

De plus, maintenant, quand je vois "int" ou "string", cela me semble vraiment faux, comme si je regardais le code C des années 1970.



Utiliser un RegEx est un moyen simple de faire ceci:

Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);




c# .net string types alias