Vraag Wat is het verschil tussen tekenreeks en tekenreeks in C #?


Voorbeeld (let op de zaak):

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

Wat zijn de richtlijnen voor het gebruik van elk? En wat zijn de verschillen?


5345


oorsprong


antwoorden:


string is een alias in C # voor System.String.
Dus technisch gezien is er geen verschil. Het is als int  vs.  System.Int32.

Wat richtlijnen betreft, wordt het over het algemeen aanbevolen om te gebruiken string elke keer dat je naar een object verwijst.

bijv.

string place = "world";

Evenzo denk ik dat het over het algemeen wordt aanbevolen om te gebruiken String als je specifiek naar de klas moet verwijzen.

bijv.

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

Dit is de stijl die Microsoft meestal gebruikt hun voorbeelden.


Het lijkt erop dat de richtlijnen op dit gebied mogelijk zijn veranderd, zoals StyleCop handhaaft nu het gebruik van de C # -specifieke aliassen.


5088



Voor de volledigheid is hier een hersenpuin van gerelateerde informatie ...

Zoals anderen hebben opgemerkt, string is een alias voor System.String. Ze compileren naar dezelfde code, dus bij uitvoering is er geen enkel verschil. Dit is slechts een van de aliassen in C #. De volledige lijst is:

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

Losstaand van string en object, de aliassen zijn allemaal van waardetypes. decimal is een waardetype, maar geen primitief type in de CLR. Het enige primitieve type dat geen alias heeft is System.IntPtr.

In de specificatie staan ​​de aliassen van het waardetype bekend als 'eenvoudige typen'. Letterlijke waarden kunnen worden gebruikt voor constante waarden van elk eenvoudig type; geen andere waardetypen hebben letterlijke vormen beschikbaar. (Vergelijk dit met VB, wat het toestaat DateTime letterlijk, en heeft er ook een alias voor.)

Er is één omstandigheid waarin jij hebben om de aliassen te gebruiken: wanneer expliciet het onderliggende type van een enum wordt gespecificeerd. Bijvoorbeeld:

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

Dat is gewoon een kwestie van de manier waarop de specificatie enum verklaringen definieert - het deel na de dubbele punt moet de zijn integrale type productie, wat een teken is van sbyte, byte, short, ushort, int, uint, long, ulong, char... in tegenstelling tot a type productie zoals gebruikt door bijvoorbeeld variabele declaraties. Het duidt niet op een ander verschil.

Ten slotte, wanneer het gaat gebruiken: persoonlijk gebruik ik de aliassen overal voor de implementatie, maar het CLR-type voor alle API's. Het maakt eigenlijk niet zoveel uit wat je gebruikt in termen van implementatie - consistentie tussen je team is leuk, maar niemand anders zal erom geven. Aan de andere kant is het echt belangrijk dat als u naar een type in een API verwijst, u dit op een taalneutrale manier doet. Een methode genaamd ReadInt32 is ondubbelzinnig, terwijl een methode genaamd ReadInt vereist interpretatie. De beller zou een taal kunnen gebruiken die een definieert int alias voor Int16, bijvoorbeeld. De .NET framework-ontwerpers hebben dit patroon gevolgd, goede voorbeelden zijn in de BitConverter, BinaryReader en Convert klassen.


3031



String betekent System.String en het is een .NET Framework-type. string is een alias in de C # -taal voor System.String. Beiden zijn gecompileerd met System.String in IL(Intermediate Language), dus er is geen verschil. Kies wat je leuk vindt en gebruik dat. Als je in C # codeert, heb ik liever string omdat het een alias van het type C # is en bekend is bij C # -programmeurs.

Ik kan hetzelfde zeggen (int, System.Int32) enz..


607



Het beste antwoord dat ik ooit heb gehoord over het gebruik van de meegeleverde typaliassen in C # komt van Jeffrey Richter in zijn boek CLR via C #. Dit zijn zijn 3 redenen:

  • Ik heb een aantal ontwikkelaars in de war zien komen, niet wetend of ik ze moest gebruiken draad of Draad in hun code. Omdat in C # de tekenreeks (een zoekwoord) exact wordt toegewezen aan System.String (een FCL-type), is er geen verschil en kan deze ook worden gebruikt.
  • In C #, lang kaarten voor System.Int64, maar in een andere programmeertaal, lang zou kunnen toewijzen aan een Int16 of Int32. In feite behandelt C ++ / CLI in feite lang als een Int32. Iemand die de broncode in één taal leest, kan de intentie van de code gemakkelijk verkeerd interpreteren als hij of zij gewend was om in een andere programmeertaal te programmeren. In feite zullen de meeste talen zelfs niet behandelen lang als een sleutelwoord en zal geen code compileren die het gebruikt.
  • De FCL heeft veel methoden die typenamen hebben als onderdeel van hun methode namen. Bijvoorbeeld de BinaryReader type biedt methoden zoals readBoolean, ReadInt32, ReadSingle, enzovoort, en de System.Convert type biedt methoden zoals ToBoolean, ToInt32, ToSingle, enzovoort. Hoewel het legaal is om de volgende code te schrijven, voelt de regel met float me heel onnatuurlijk aan, en het is niet duidelijk dat de regel klopt:
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

Dus daar heb je het. Ik denk dat dit allemaal echt goede punten zijn. Ik merk echter niet dat ik Jeffrey's advies gebruik in mijn eigen code. Misschien zit ik te vast in mijn C # -wereld, maar uiteindelijk probeer ik mijn code eruit te laten zien als de kadercode.


409



string is een gereserveerd woord, maar String is gewoon een klassennaam. Dit betekent dat string kan niet alleen als variabele naam worden gebruikt.

Als u om een ​​of andere reden een variabele genaamd wilt hebben draad, je zou alleen de eerste van deze compilaties zien:

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

Als u echt een variabele naam wilt gebruiken draad je kunt gebruiken @ als een voorvoegsel:

StringBuilder @string = new StringBuilder();

Nog een belangrijk verschil: Stack Overflow benadrukt ze anders.


380



Er is één verschil - je kunt niet gebruiken String zonder using System; vooraf.


327



Het is hierboven behandeld; u kunt echter niet gebruiken string in reflectie; je moet gebruiken String.


269



System.String is de .NET-reeksklasse - in C # string is een alias voor System.String - dus in gebruik zijn ze hetzelfde.

Wat betreft richtlijnen zou ik niet te verzanden en gewoon gebruiken wat je wilt - er zijn belangrijker dingen in het leven en de code zal hoe dan ook hetzelfde zijn.

Als je merkt dat je systemen aan het bouwen bent, is het nodig om de grootte van de gehele getallen die je gebruikt te specificeren en dus te gebruiken Int16, Int32, UInt16, UInt32 etc. dan kan het natuurlijker lijken om te gebruiken String- en bij het navigeren tussen verschillende .net-talen kan het dingen begrijpelijker maken - anders zou ik string en int gebruiken.


204



Ik geef de voorkeur aan gekapitaliseerd .NET typen (in plaats van de aliassen) om opmaakredenen. De .NET typen zijn hetzelfde gekleurd als andere objecttypen (de waardetypen zijn immers de juiste objecten).

Voorwaardelijke en beheersende zoekwoorden (zoals if, switch, en return) zijn kleine letters en donkerblauw gekleurd (standaard). En ik wil liever niet dat het oneens is in gebruik en indeling.

Overwegen:

String someString; 
string anotherString; 

167