Quelle est la différence entre String et string en C#?
exemple ( noter le cas ):
string s = "Hello world!";
String s = "Hello world!";
que sont les lignes directrices pour l'utilisation de chacun? Et que sont les différences ?
30 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
vs. System.Int32
.
en ce qui concerne les lignes directrices, il est généralement recommandé d'utiliser string
chaque fois que vous faites référence à un objet.
p.ex.
string place = "world";
de même, je pense qu'il est généralement recommandé d'utiliser String
si vous avez besoin de se référer spécifiquement à la classe.
p.ex.
string greet = String.Format("Hello {0}!", place);
C'est le style que Microsoft tend à utiliser dans leurs exemples .
il semble que les directives dans ce domaine aient changé, puisque StyleCop impose maintenant l'utilisation des alias C# spécifiques.
Juste pour être complet, voici une décharge de cerveau d'informations connexes...
comme d'autres l'ont noté, string
est un alias pour System.String
. Ils compilent avec le même code, donc au moment de l'exécution il n'y a aucune différence. Ce n'est qu'un des alias de C#. La liste complète est la suivante:
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
mis à part string
et object
, les alias sont tous des types de valeurs. 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 de valeur sont connus sous le nom de"types simples". Les lettres peuvent être utilisées pour des valeurs constantes de chaque type simple; aucun autre type de valeur n'a de formes littérales disponibles. (Comparez cela avec VB, qui permet DateTime
littérales, et a un alias pour elle aussi.)
il y a une circonstance dans laquelle vous avez pour utiliser les alias: en spécifiant explicitement le type sous-jacent d'un enum. Par exemple:
public enum Foo : UInt32 {} // Invalid
public enum Bar : uint {} // Valid
c'est juste une question de la façon dont le spec définit les déclarations enum - la partie après le colon doit être la production integral-type , qui est un signe de sbyte
, byte
, short
, ushort
, int
, uint
, long
, ulong
, char
... par opposition à un type production utilisée dans les déclarations variables par exemple. Il n'a pas d'indiquer toute autre différence.
enfin, quand il vient à l'utilisation: personnellement, j'utilise les alias partout pour la mise en œuvre, mais le type CLR pour n'importe quel API. Peu importe ce que vous utilisez en termes de mise en œuvre - la cohérence au sein de votre équipe est agréable, mais personne d'autre ne s'en souciera. D'autre part, il est vraiment important que si vous référence à un type dans une API, vous le faites dans une langue 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 alias int
pour Int16
, par exemple. Les concepteurs du .net framework ont suivi ce modèle, de bons exemples étant dans les classes BitConverter
, BinaryReader
et Convert
.
String
signifie System.String
. string
est un alias dans la langue C# pour System.String
. Les deux sont compilés en System.String
dans IL (langue intermédiaire), il n'y a donc pas de différence. Choisis ce que tu aimes et utilise ça. Si vous codez en C#, je préférerais string
car c'est un alias de type C# et bien connu par les programmeurs de C#.
je peux dire la même chose ( int
, System.Int32
) etc..
la meilleure réponse que j'ai jamais entendu parler de l'utilisation des alias de type fournis dans C# vient 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 faut utiliser string ou String dans leur code. Parce que dans C# la chaîne (un mot-clé) correspond exactement au système.String (un type FCL), il n'y a pas la différence et peuvent être utilisés.
- En C#, long cartes du Système.Int64 , mais dans un autre langage de programmation, long pourrait correspondre à une Int16 ou Int32 . En fait, C++ / CLI traite en fait long comme un Int32 . Une personne lisant le code source dans une langue pourrait facilement mal interpréter l'intention du code si elle était utilisé pour programmer dans un langage de programmation différent. En fait, la plupart des langues ne traiteront même pas long comme un mot clé et ne compileront pas le code qui l'utilise.
- le FCL a beaucoup de méthodes qui ont des noms de type comme partie de leurs noms de méthode. Par exemple, le BinaryReader type offre des méthodes telles que ReadBoolean , ReadInt32 , ReadSingle , et ainsi de suite, et le système .Convertir type offres méthodes telles que ToBoolean , ToInt32 , ToSingle , et ainsi de suite. Bien qu'il soit légal d'écrire le code suivant, la ligne avec float me semble très peu naturelle, 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
Alors voilà. Je pense que ce sont de très bons points. J'ai cependant, ne trouvez pas j'utilise 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 mon code ressembler au Code cadre.
string
est un mot réservé, mais String
est juste un nom de classe.
Cela signifie que string
ne peut pas être utilisé seul comme nom de variable.
si pour une raison quelconque vous vouliez une variable appelée string , vous ne verriez que le premier de ces compilations:
StringBuilder String = new StringBuilder(); // compiles
StringBuilder string = new StringBuilder(); // doesn't compile
si vous voulez vraiment un nom de variable appelé string vous pouvez utiliser @
comme préfixe:
StringBuilder @string = new StringBuilder();
une autre différence critique: le débordement de la pile les met en évidence différemment.
il y a une différence - vous ne pouvez pas utiliser String
sans using System;
à l'avance.
il a été couvert ci-dessus; cependant, vous ne pouvez pas utiliser string
dans la réflexion; vous devez utiliser String
.
System.String
est la classe de chaîne de caractères .NET - dans C# string
est un alias pour System.String
- donc en usage, ils sont les mêmes.
en ce qui concerne les lignes directrices, Je ne m'enliserais pas trop et n'utiliserais que ce que vous voulez - 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 à construire des systèmes où il est nécessaire de spécifier la taille des entiers que vous utilisez et donc ont tendance à utiliser Int16
, Int32
, UInt16
, UInt32
etc. alors il pourrait sembler plus naturel d'utiliser String
- et en se déplaçant entre les différentes langues .net il pourrait rendre les choses plus compréhensibles - autrement, j'utiliserais la chaîne et int.
Je préfère les types capitalisés .NET
(plutôt que les Alias) pour des raisons de formatage. Les types .NET
sont colorés de la même façon que les autres types d'objets (les types de valeur sont des objets appropriés, après tout).
Conditional et control (comme if
, switch
, et return
) sont bleu foncé en minuscules et en couleurs (par défaut). Et je préfère ne pas avoir le désaccord dans l'utilisation et le format.
considérer:
String someString;
string anotherString;
string
et String
sont identiques de toutes les façons (sauf la majuscule "S"). Il n'y a aucune incidence sur les performances.
minuscule string
est préféré dans la plupart des projets en raison de la mise en évidence de la syntaxe
c# est une langue qui est utilisée avec le CLR.
string
est un type en C#.
System.String
est un type du CLR.
lorsque vous utilisez C# avec le CLR string
sera mappé à System.String
.
théoriquement, vous pourriez implémenter un compilateur C# généré Java bytecode. Une implémentation sensée de ce compilateur permettrait probablement de faire correspondre string
à java.lang.String
afin d'interopérer avec la bibliothèque Java runtime.
cette vidéo sur YouTube montre pratiquement comment ils diffèrent.
Mais maintenant, pour une longue réponse textuelle.
quand on parle de .NET
il y a deux choses différentes, l'une est .NET
framework et l'autre il y a des langues ( C#
, VB.NET
etc) qui utilisent ce framework.
" System.String
" A. K. une" chaîne "("s "en majuscule) est un type de données .NET
tandis que" string "est un type de données C#
.
en bref," String "est un alias ( la même chose appelée avec des noms différents) de"string". Donc techniquement les deux énoncés de code ci-dessous donneront le même résultat.
String s = "I am String";
ou
string s = "I am String";
de la même manière qu'il y a des alias pour d'autres c # type de données comme indiqué ci-dessous: -
objet: System.Object
, string: System.String
, bool: System.Boolean
, byte: System.Byte
, sbyte: System.SByte
, bref: System.Int16
et ainsi de suite
maintenant la question du million de dollars du point de vue du programmeur alors quand utiliser "String" et "string"?
première chose pour éviter la confusion, utilisez l'un d'eux de manière cohérente. Mais du point de vue des pratiques exemplaires, faire la déclaration de variable il est bon d'utiliser "string" ( petit "s") et quand vous l'utilisez comme nom de classe alors "String" ( capital "S") est préférable.
dans le code ci-dessous, le côté gauche est une déclaration variable et elle est déclarée en utilisant"string". Sur le côté droit nous appelons une méthode donc "String" est plus raisonnable.
string s = String.ToUpper() ;
string
est juste un alias pour System.String
. Le compilateur les traitera de façon identique.
La seule différence, c'est la coloration syntaxique comme vous le mentionnez, et que vous devez écrire using System
si vous utilisez String
.
minuscule string
est un alias pour System.String
.
Ils sont les mêmes dans C#
.
il y a un débat sur la question de savoir si vous devez utiliser les types de systèmes ( System.Int32
, System.String
, etc.) ou C# aliases
( int
, string
, etc). Je crois personnellement que vous devriez utiliser le C# aliases
, mais c'est juste ma préférence personnelle.
les deux sont identiques. 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 un alias de Int32
pour information
"La chaîne de mots-clés est simplement un alias pour la classe prédéfinie System.String
."- C # Spécification De Langue 4.2.3
http://msdn2.microsoft.com/En-US/library/aa691153.aspx
comme disent les autres, ils sont pareils. Les règles de StyleCop, par défaut, vous obligera à utiliser string
comme un C # code style best practice, sauf lors de la référence System.String
fonctions statiques, telles que String.Format
, String.Join
, String.Concat
, etc...
L'utilisation de types de système rend plus facile à porter entre C# et VB.Net, si vous êtes dans ce genre de chose.
contre 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 Jon Skeet l'a mentionné.
string
est un pseudonyme (ou abréviation) de System.String
. Cela signifie qu'en tapant string
nous avons voulu dire System.String
. Vous pouvez lire plus dans le lien penser: 'string' est un alias/raccourci de système.Chaîne.
String ( System.String
) est une classe de la bibliothèque des classes de base. string (minuscule) est un travail réservé dans C# qui est un alias pour le système.Chaîne. Int32 vs int est une situation similaire à celle de Boolean vs. bool
. Ces mots-clés spécifiques au langage C# vous permettent de déclarer des primitives dans un style similaire à C.
String
n'est pas un mot-clé et il peut être utilisé comme Identificateur alors que string
est un mot-clé et ne peut pas être utilisé comme Identificateur. Et du point de vue de la fonction, les deux sont identiques.
arriver en retard à la fête: j'utilise les types CLR 100% du temps (bien, sauf si forcé à utiliser le type C#, mais je ne me souviens pas de la dernière fois qui était).
j'ai commencé à faire ça il y a des années, comme dans les livres de Ritchie. Il m'a semblé logique que toutes les langues CLR soient finalement capables de supporter l'ensemble des types CLR, donc en utilisant les types CLR vous avez fourni un code plus clair, et peut-être 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 vrai déprimant est que l'auto-complete utilise le type C#, donc je finis par RE-dactylographier les types générés automatiquement pour spécifier le type CLR à la place.
aussi, maintenant, quand je vois "int" ou "string", ça me semble vraiment mal, comme si je regardais le code C de 1970.
je voudrais juste ajouter ceci à la réponse de lfousts, du Livre de Ritchers:
la spécification C# language stipule, "Comme une question de style, l'utilisation de la le mot-clé est préféré à l'utilisation du nom complet du type de système."Je suis en désaccord avec la spécification du langage; je préfèrent utiliser les noms de type FCL et complètement éviter le type primitif nom. En fait, je souhaite que les compilateurs n'a même pas offert le type primitif noms et développeurs forcés l'utilisation de la Les noms de type FCL à la place. Voici mon motifs:
Je n'ai pas eu son opinion avant de lire le paragraphe complet.
C'est une question de convention, vraiment. string
ressemble plus au style C/C++. La convention générale est d'utiliser les raccourcis fournis par la langue de votre choix (int/Int pour Int32
). Cela vaut pour" objet "et decimal
ainsi.
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 n'importe quel assistant de mise à niveau change int
fait référence à Int32
pour être sûr.
Il n'y a pas de différence.
le mot - clé C# string
correspond au type .NET System.String
- c'est un alias qui respecte les conventions de nommage de la langue.
de Même, int
cartes System.Int32
.
Nouvelle réponse après 6 ans et 5 mois (procrastination).
alors que string
est un mot-clé réservé qui a toujours un sens fixe, String
est juste un identifiant ordinaire qui pourrait se référer à n'importe quoi. Selon les membres du type courant, l'espace de noms courant et les directives using
appliquées et leur emplacement, String
pourrait être une valeur ou un type distinct de global::System.String
.
je vais donner deux exemples où using
les directives n'aideront pas .
en premier lieu, lorsque String
est une valeur du type courant (ou une variable locale):
class MySequence<TElement>
{
public IEnumerable<TElement> String { get; set; }
void Example()
{
var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
}
}
ce qui précède ne sera pas compilé car IEnumerable<>
n'a pas de membre non statique appelé Format
, et aucune méthode d'extension ne s'applique. Dans le dans le cas ci-dessus, il peut encore être possible d'utiliser String
dans d'autres contextes où un type est la seule possibilité syntaxiquement. Par exemple String local = "Hi mum!";
pourrait être OK (selon les directives namespace et using
).
pire: dire String.Concat(someSequence)
sera probablement (en fonction de using
s) aller à la méthode D'extension Linq Enumerable.Concat
. Il n'ira pas à la méthode statique string.Concat
.
Deuxièmement, lorsque String
est un autre type , imbriqué dans le type actuel:
class MyPiano
{
protected class String
{
}
void Example()
{
var test1 = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
String test2 = "Goodbye";
}
}
ni l'un ni l'autre des énoncés de la méthode Example
ne sont compilés. Ici String
est toujours un piano chaîne , MyPiano.String
. Aucun membre ( static
ou non) Format
n'existe sur elle (ou est hérité de sa classe de base). Et la valeur "Goodbye"
ne peut pas être convertie en elle.
il y a une citation sur ce numéro de Livre de Daniel Solis .
tous les types prédéfinis sont directement mappés les types .NET sous-jacents. Les noms de type C# (chaîne de caractères) sont simplement des alias pour Les types .NET (String ou System.String), donc en utilisant les noms .NET fonctionne bien syntaxiquement, bien que cela est déconseillé. Dans un programme C#, vous devez utiliser les noms C# plutôt que les noms de .NET.
string est un mot-clé, et vous ne pouvez pas utiliser string comme un identifiant.
Chaîne n'est pas un mot clé, et vous pouvez l'utiliser comme identificateur:
exemple
string String = "I am a string";
le mot clé string
est un alias pour
System.String
mis à part la question des mots clés, les deux sont exactement
équivalent.
typeof(string) == typeof(String) == typeof(System.String)
Oui, il n'y a pas de différence entre eux, tout comme bool
et Boolean
.
il n'y a pas de différence entre les deux - string
, cependant, semble être l'option préférée en considérant le code source d'autres développeurs.