.net {} - Qual è la differenza tra stringa e stringa in C#?




${} with (25)

Esempio ( notare il caso ):

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

Quali sono le linee guida per l'uso di ciascuno? E quali sono le differenze ?


Answers

C'è una differenza : non è possibile utilizzare String senza using System; in anticipo.


string e String sono identiche in tutti i modi (eccetto la "S" maiuscola). Non ci sono implicazioni di performance in entrambi i casi.

La string minuscola è preferita nella maggior parte dei progetti a causa dell'evidenziazione della sintassi


String ( System.String ) è una classe nella libreria della classe base. string (minuscolo) è un'opera riservata in C # che è un alias per System.String. Int32 vs int è una situazione simile a quella di Boolean vs. bool . Queste parole chiave specifiche del linguaggio C # ti consentono di dichiarare le primitive in uno stile simile a C.


Preferisco i tipi .NET maiuscolo (piuttosto che gli alias) per motivi di formattazione. I tipi .NET sono colorati come gli altri tipi di oggetto (i tipi di valore sono oggetti appropriati, dopo tutto).

Le parole chiave condizionali e di controllo (come if , switch e return ) sono in minuscolo e di colore blu scuro (impostazione predefinita). E preferirei non avere il disaccordo in uso e formato.

Tenere conto:

String someString; 
string anotherString; 

string è una parola riservata, ma String è solo un nome di classe. Ciò significa che la string non può essere utilizzata come nome di variabile da sola.

Se per qualche motivo volevi una variabile chiamata stringa , vedresti solo la prima di queste compilazioni:

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

Se vuoi veramente un nome di variabile chiamato string puoi usare @ come prefisso:

StringBuilder @string = new StringBuilder();

Un'altra differenza fondamentale: li evidenzia in modo diverso.


È stato coperto sopra; tuttavia, non è possibile utilizzare la string in reflection; devi usare String .


C'è una citazione su questo problema dal libro di Daniel Solis .

Tutti i tipi predefiniti sono mappati direttamente ai tipi .NET sottostanti. I nomi di tipo C # (stringa) sono semplicemente alias per i tipi .NET (String o System.String), quindi l'utilizzo dei nomi .NET funziona in modo sintattico, sebbene ciò sia scoraggiato. All'interno di un programma C #, dovresti usare i nomi C # piuttosto che i nomi .NET.


string è una parola chiave e non è possibile utilizzare la stringa come identificatore.

La stringa non è una parola chiave e puoi utilizzarla come identificatore:

Esempio

string String = "I am a string";

La parola chiave stringè un alias a System.Stringparte il problema della parola chiave, i due sono esattamente equivalenti.

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

C # è un linguaggio che viene utilizzato insieme al CLR.

string è un tipo in C #.

System.String è un tipo nel CLR.

Quando si utilizza C # insieme alla string CLR verrà mappato a System.String .

In teoria, è possibile implementare un compilatore C # che ha generato un bytecode Java. Un'implementazione ragionevole di questo compilatore probabilmente java.lang.String string a java.lang.String per interagire con la libreria runtime Java.


Entrambi sono uguali. Ma dal punto di vista delle linee guida per la codifica è meglio usare una string anziché una String . Questo è ciò che generalmente usano gli sviluppatori. ad esempio invece di usare Int32 usiamo int come int è alias di Int32

FYI "La stringa di parole chiave è semplicemente un alias per la classe predefinita System.String ." - C # Language Specification 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx


Non c'è differenza.

La string parole chiave C # viene mappata al tipo .NET System.String - è un alias che mantiene le convenzioni di denominazione della lingua.

Allo stesso modo, int esegue il mapping a System.Int32 .


String sta per System.String ed è un tipo di .NET Framework. string è un alias nel linguaggio C # per System.String . Entrambi sono compilati in System.String in IL (Intermediate Language), quindi non c'è differenza. Scegli quello che ti piace e usalo. Se esegui il codice in C #, preferirei la string quanto è un alias di tipo C # e ben noto dai programmatori C #.

Posso dire lo stesso di ( int , System.Int32 ) ecc.


La migliore risposta che abbia mai sentito sull'uso degli alias di tipo fornito in C # viene da Jeffrey Richter nel suo libro CLR Via C # . Ecco i suoi 3 motivi:

  • Ho visto un certo numero di sviluppatori confusi, non sapendo se usare string o String nel loro codice. Perché in C # la stringa (una parola chiave) viene mappata esattamente su System.String (un tipo FCL), non vi è alcuna differenza e può essere utilizzato.
  • In C #, mappe lunghe a System.Int64 , ma in un linguaggio di programmazione diverso, long poteva mappare su Int16 o Int32 . In effetti, C ++ / CLI in realtà tratta come un Int32 . Qualcuno che legge il codice sorgente in una lingua potrebbe facilmente interpretare erroneamente l'intenzione del codice se fosse abituato a programmare in un linguaggio di programmazione diverso. In effetti, la maggior parte delle lingue non verrà trattata a lungo come una parola chiave e non verrà compilato il codice che la utilizza.
  • La FCL ha molti metodi che hanno nomi di tipi come parte dei loro nomi di metodi. Ad esempio, il tipo BinaryReader offre metodi come ReadBoolean , ReadInt32 , ReadSingle e così via e il tipo System.Convert offre metodi come ToBoolean , ToInt32 , ToSingle e così via. Sebbene sia legale scrivere il seguente codice, la linea con float mi sembra molto innaturale, e non è ovvio che la linea sia corretta:
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

Così il gioco è fatto. Penso che questi siano davvero ottimi punti. Tuttavia, non mi trovo a usare il consiglio di Jeffrey nel mio codice. Forse sono troppo bloccato nel mio mondo C # ma finisco per cercare di rendere il mio codice simile al codice quadro.


Vorrei solo aggiungere questo alla risposta di lupi, dal libro di Ritchers:

La specifica del linguaggio C # afferma: "Per motivi di stile, l'uso della parola chiave è favorito rispetto all'uso del nome completo del tipo di sistema." Non sono d'accordo con le specifiche della lingua; Preferisco usare i nomi di tipo FCL ed evitare completamente i nomi dei tipi primitivi. In effetti, vorrei che i compilatori non offrissero nemmeno i nomi dei tipi primitivi e gli sviluppatori forzati a usare invece i nomi di tipo FCL. Ecco le mie ragioni:

Non ho avuto la sua opinione prima di aver letto il paragrafo completo.


Arriva tardi alla festa: uso i tipi CLR il 100% delle volte (beh, tranne se è forzato ad usare il tipo C #, ma non ricordo quando è stata l'ultima volta).

Originariamente ho iniziato a farlo anni fa, come da libri di CLR di Ritchie. Per me era logico che tutti i linguaggi CLR dovessero essere in grado di supportare l'insieme di tipi CLR, quindi l'utilizzo dei tipi CLR forniva un codice più chiaro e probabilmente più "riutilizzabile".

Ora che lo faccio da anni, è un'abitudine e mi piace la colorazione che VS mostra per i tipi CLR.

L'unico vero downer è che il completamento automatico utilizza il tipo C #, quindi ricomincio a digitare nuovamente i tipi generati automaticamente per specificare il tipo CLR.

Inoltre, ora, quando vedo "int" o "string", mi sembra davvero sbagliato, come se guardassi il codice C degli anni '70.


L'uso dei tipi di sistema semplifica il porting tra C # e VB.Net, se ti piace questo genere di cose.


Come dicono gli altri, sono uguali. Le regole StyleCop, per impostazione predefinita, impongono l'utilizzo della string come best practice per lo stile del codice C #, tranne quando si fa riferimento alle funzioni statiche System.String , come String.Format , String.Join , String.Concat , ecc.


Questo video di YouTube dimostra praticamente come si differenziano.

Ma ora per una lunga risposta testuale.

Quando parliamo di .NET ci sono due cose diverse una che è .NET framework e l'altra ci sono linguaggi ( C# , VB.NET ecc.) Che usano quel framework.

" System.String " alias "String" (maiuscola "S") è un tipo di dati framework .NET mentre "string" è un tipo di dati C# .

In breve "String" è un alias (la stessa cosa chiamata con nomi diversi) di "string". Quindi tecnicamente entrambe le istruzioni sotto riportate daranno lo stesso risultato.

String s = "I am String";

o

string s = "I am String";

Allo stesso modo ci sono alias per altri tipi di dati c # come mostrato di seguito: -

oggetto: System.Object , stringa: System.String , bool: System.Boolean , byte: System.Byte , sbyte: System.SByte , short: System.Int16 e così via

Ora la domanda da un milione di dollari dal punto di vista del programmatore Quindi quando usare "String" e "string"?

La prima cosa da evitare è usare confusamente uno di essi. Ma dal punto di vista delle migliori pratiche quando si fa la dichiarazione delle variabili è bene usare "string" (piccola "s") e quando lo si utilizza come nome di classe, viene preferito "String" (maiuscola "S").

Nel codice seguente il lato sinistro è una dichiarazione di variabile e ha dichiarato di usare "stringa". Sul lato destro stiamo chiamando un metodo in modo che "String" sia più ragionevole.

string s = String.ToUpper() ;

string è solo un alias per System.String . Il compilatore li tratterà in modo identico.

L'unica differenza pratica è l'evidenziazione della sintassi mentre menzioni e che devi scrivere using System se usi String .


Contro quella che sembra essere una pratica comune tra gli altri programmatori, preferisco String over string , solo per sottolineare il fatto che String è un tipo di riferimento, come ha detto Jon Skeet.


System.String è la classe di stringa .NET - in C # la string è un alias per System.String - così in uso sono gli stessi.

Per quanto riguarda le linee guida, non mi sento troppo impantanato e uso solo quello che vuoi - ci sono cose più importanti nella vita e il codice sarà lo stesso comunque.

Se vi trovate a costruire sistemi dove è necessario specificare la dimensione degli interi che state usando e quindi tendete a usare Int16 , Int32 , UInt16 , UInt32 ecc. Allora potrebbe sembrare più naturale usare String - e quando ci si muove tra diversi .net lingue potrebbe rendere le cose più comprensibili - altrimenti userei string e int.


È una questione di convenzioni, davvero. string sembra più simile allo stile C / C ++. La convenzione generale è quella di utilizzare qualsiasi scorciatoia fornita dalla lingua scelta (int / Int per Int32 ). Questo vale anche per "oggetto" e decimal .

Teoricamente questo potrebbe aiutare a portare il codice in qualche futuro standard a 64 bit in cui "int" potrebbe significare Int64 , ma non è questo il punto, e mi aspetto che qualsiasi procedura guidata di aggiornamento modifichi qualsiasi riferimento int a Int32 comunque per sicurezza.


string è un alias in C # per System.String .
Quindi tecnicamente, non c'è differenza. È come int vs. System.Int32 .

Per quanto riguarda le linee guida, in genere è consigliabile utilizzare la string ogni volta che si fa riferimento a un oggetto.

per esempio

string place = "world";

Allo stesso modo, penso che sia generalmente raccomandato l'utilizzo di String se è necessario fare riferimento in modo specifico alla classe.

per esempio

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

Questo è lo stile che Microsoft tende a utilizzare nei loro esempi .

Sembra che la guida in quest'area possa essere cambiata, in quanto StyleCop ora impone l'uso degli alias specifici di C #.


La string minuscolo è un alias per System.String . Sono uguali in C# .

Si discute se utilizzare i tipi di sistema ( System.Int32 , System.String , ecc.) O gli C# aliases ( int , string , ecc.). Personalmente credo che dovresti usare gli C# aliases , ma questa è solo la mia preferenza personale.


I metodi astratti sono sempre virtuali. Non possono avere un'implementazione.

Questa è la differenza principale.

Fondamentalmente, si userebbe un metodo virtuale se si ha l'implementazione 'predefinita' di esso e si desidera consentire ai discendenti di cambiare il suo comportamento.

Con un metodo astratto, costringi i discendenti a fornire un'implementazione.





c# .net string types alias