Jaka jest różnica między String a string w C#?

Tak dla kompletności, oto zrzut mózgów powiązanych informacji...

Jak zauważyli inni, string jest aliasem dla System.String. Kompilują się do tego samego kodu, więc w czasie wykonywania nie ma żadnej różnicy. To tylko jeden z aliasów w C#. Pełna lista to:

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

Oprócz string i object Wszystkie aliasy należą do typów wartości. decimal jest typem wartości, ale nie prymitywnym typem w CLR. Jedyny prymitywny typ, który nie ma aliasu is System.IntPtr.

W specyfikacji aliasy typów wartości są znane jako "typy proste". Literały mogą być używane do wartości stałych każdego typu prostego; żadne inne typy wartości nie mają dostępnych form literalnych. (Porównaj to z VB, który pozwala DateTime literały, i ma alias dla niego też.)

Istnieje jedna okoliczność, w której musisz używać aliasów: gdy jawnie określasz podstawowy typ enum. Na przykład:

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

To tylko kwestia sposobu spec definiuje deklaracje enum - częścią po dwukropku musi być Całka typu , która jest jednym z symboli sbyte, byte, short, ushort, int, uint, long, ulong, char... w przeciwieństwie do produkcji typu , używanej np. w deklaracjach zmiennych. To nie wskazuje żadnej innej różnicy.

Wreszcie, jeśli chodzi o użycie: osobiście używam aliasów wszędzie dla implementacji, ale typu CLR dla każdego API. To naprawdę nie ma zbyt dużego znaczenia, którego używasz pod względem implementacji - konsekwencja w zespole jest miła, ale nikogo innego to nie obchodzi. Z drugiej strony, naprawdę ważne jest, aby w interfejsie API odnosić się do typu, robić to w sposób neutralny językowo. Metoda ReadInt32 jest jednoznaczna, podczas gdy metoda ReadInt wymaga interpretacji. Wywołujący może używać języka, który definiuje na przykład alias int dla Int16. Projektanci. NET framework podążają za tym wzór, dobre przykłady są w BitConverter, BinaryReader i Convert klasy.

String oznacza System.String i jest to typ. NET Framework. string jest aliasem w języku C # dla System.String. Oba są zestawione do System.String w IL (język pośredni), więc nie ma różnicy. Wybierz to, co lubisz i wykorzystaj to. Jeśli kodujesz w C#, wolałbym string, ponieważ jest to alias Typu C# i dobrze znany przez programistów C#.

Mogę powiedzieć to samo o (int, System.Int32) itd..

Najlepsza odpowiedź jaką kiedykolwiek słyszałem o używaniu podanych aliasów typu w C# pochodzi od Jeffreya Richtera w jego książce CLR Via C#. Oto jego 3 powody:

• widziałem wielu programistów zdezorientowanych, nie wiedząc, czy używać stringczy String w swoim kodzie. Ponieważ w C# ciąg znaków (słowo kluczowe) mapuje dokładnie do systemu.String (Typ FCL), nie ma różnicy i można użyć obu.
• W C#, long mapuje do System.Int64 , ale w innym języku programowania, long może mapować do Int16 lub Int32 . W rzeczywistości C++/CLI w rzeczywistości traktuje long jako Int32. Ktoś czytający kod źródłowy w jednym języku mógłby łatwo błędnie zinterpretować zamiar kodu, gdyby był przyzwyczajony do programowania w innym języku programowania. W rzeczywistości większość języków nie traktuje nawet long jako słowa kluczowego i nie kompiluje kodu, który go używa.
• FCL ma wiele metody, które mają nazwy typów jako część nazw metod. Na przykład typ BinaryReader oferuje metody takie jak ReadBoolean, ReadInt32, ReadSingle , i tak dalej, oraz system .Convert type offers methods such as ToBoolean, ToInt32, ToSingle , i tak dalej. Chociaż jest legalne, aby napisać następujący kod, linia z float wydaje mi się bardzo nienaturalne, i nie jest oczywiste, że linia jest poprawna: {]}

BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // OK, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

string jest słowem zastrzeżonym, ale {[3] } jest tylko nazwą klasy. Oznacza to, że string nie może być używana jako nazwa zmiennej sama w sobie.

Jeśli z jakiegoś powodu chcesz zmienną o nazwie string, zobaczysz tylko pierwszy z tych kompilacji:

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

Jeśli naprawdę chcesz mieć nazwę zmiennej string możesz użyć @ jako prefiksu:

StringBuilder @string = new StringBuilder();

Kolejna krytyczna różnica: przepełnienie stosu podkreśla je inaczej.

Jest jedna różnica - nie można użyć String Bez using System; wcześniej.

Zostało to omówione powyżej; jednak nie możesz użyć string w odbiciu; musisz użyć String.

System.String czy klasa. NET string-w C# string jest aliasem dla System.String - więc w użyciu są takie same.

Jeśli chodzi o wytyczne, to ja bym się za bardzo nie zagłębił i po prostu użył tego, na co masz ochotę - w życiu są ważniejsze rzeczy, a kod i tak będzie taki sam.

Jeśli znajdujesz się w budowaniu systemów, w których konieczne jest określenie wielkości liczb całkowitych, których używasz, a więc masz tendencję do używania Int16, Int32, UInt16, UInt32 itd. wtedy może wyglądać bardziej naturalnie użyj String - i podczas poruszania się między różnymi językami. Net może to uczynić rzeczy bardziej zrozumiałymi-w przeciwnym razie użyłbym string i int.

Preferuję typy .NET pisane wielką literą (a nie aliasy) ze względów formatowania. Typy .NET są kolorowe tak samo jak inne typy obiektów (typy wartości są przecież obiektami właściwymi).

Słowa kluczowe warunkowe i kontrolne (jak if, switch, i return) są małymi literami i mają kolor ciemnoniebieski (domyślnie). I wolałbym nie mieć różnicy w użyciu i formacie.

Rozważmy:

String someString; 
string anotherString; 

string i String są identyczne pod każdym względem (z wyjątkiem wielkich liter "S"). Nie ma wpływu na wydajność tak czy inaczej.

Małe litery string są preferowane w większości projektów ze względu na podświetlanie składni

C # jest językiem używanym razem z CLR.

string jest typem w C#.

System.String jest typem w CLR.

Gdy używasz C# razem z CLR string zostanie zmapowany do System.String.

Teoretycznie można zaimplementować kompilator C#, który generuje bajt kodu Javy. Sensowna implementacja tego kompilatora prawdopodobnie mapowałaby string na java.lang.String w celu współpracy z Java runtime biblioteka.

Ten filmik z YouTube pokazuje praktycznie, jak się różnią.

Ale teraz długa odpowiedź tekstowa.

Kiedy mówimy o .NET są dwie różne rzeczy, jedna jest .NET framework, a druga języki ( C# , VB.NET etc), które używają tego frameworka.

"System.String" a.K.A "String" (capital "S") jest typem danych .NET framework, podczas gdy "string" jest typem danych C#.

W skrócie " String" jest aliasem (o tej samej nazwie z różnymi nazwami) "string". Więc technicznie obie poniższe instrukcje kodu dadzą ten sam wynik.

String s = "I am String";

Lub

string s = "I am String";

W ten sam sposób istnieją aliasy dla innych typów danych c#, jak pokazano poniżej:-

Obiekt: System.Object, string: System.String, bool: System.Boolean, byte: System.Byte, sbyte: System.SByte, short: System.Int16 i tak dalej

Teraz pytanie o milion dolarów z punktu widzenia programisty więc kiedy używać "String" i "string"?

Pierwszą rzeczą, aby uniknąć nieporozumień, używaj jednego z nich konsekwentnie. Ale z punktu widzenia najlepszych praktyk, kiedy robisz deklarację zmiennej, dobrze jest użyć "string" (Małe "s"), a gdy używasz jej jako nazwy klasy, preferowane jest "String "(Duże" S").

W poniższym kodzie lewa strona jest deklaracją zmiennej i jest zadeklarowana za pomocą "string". Po prawej stronie wywołujemy metodę, więc" String " jest bardziej sensowne.

string s = String.ToUpper() ;

string jest tylko aliasem dla System.String. Kompilator potraktuje je identycznie.

Jedyną praktyczną różnicą jest podświetlanie składni, o którym wspominasz, i to, że musisz napisać using System, Jeśli używasz String.

Małe litery string to alias System.String. Są takie same w C#.

Jest debata, czy należy używać typów systemu (System.Int32, System.String, itd.) rodzaje lub C# aliases (int, string, itp.). Osobiście uważam, że powinieneś użyć C# aliases, ale to tylko moje osobiste preferencje.

Oba są takie same. Ale z punktu widzenia wytycznych kodowania lepiej używać string zamiast String. To jest to, czego zwykle używają deweloperzy. np. zamiast używać Int32 używamy int Ponieważ int jest aliasem Int32

FYI "Łańcuch słów kluczowych jest po prostu aliasem dla predefiniowanej klasy System.String."- Specyfikacja Języka C# 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

Jak mówią inni, są tacy sami. Reguły StyleCop domyślnie wymuszają używanie string jako najlepszej praktyki w stylu kodu C#, z wyjątkiem odwołań do statycznych funkcji System.String, takich jak String.Format, String.Join, String.Concat, itd...

Używanie typów systemowych ułatwia portowanie pomiędzy C# i VB.Net jeśli lubisz takie rzeczy.

Wbrew temu, co wydaje się być powszechną praktyką wśród innych programistów, wolę String niż string, aby podkreślić fakt, że String jest typem odniesienia, jak wspomniał Jon Skeet.

string jest aliasem (lub skrótem) System.String. Oznacza to, że wpisując string mieliśmy na myśli System.String. Możesz przeczytać więcej w Think link: 'string' jest aliasem / skrótem systemu.Sznurek.

String (System.String) jest klasą w bibliotece klas bazowych. string (małe litery) jest zarezerwowaną pracą w C#, która jest aliasem dla systemu.Sznurek. Int32 vs int jest podobna sytuacja jak Boolean vs. bool. Te specyficzne dla języka C# słowa kluczowe umożliwiają deklarowanie prymitywów w stylu podobnym do C.

String nie jest słowem kluczowym i może być użyty jako identyfikator, podczas gdy {[1] } jest słowem kluczowym i nie może być użyty jako identyfikator. I z punktu widzenia funkcji oba są takie same.

Coming late to the party: używam typów CLR w 100% czasu (no chyba, że zmuszony do korzystania z Typu C#, ale nie pamiętam, kiedy ostatni raz to było).

Zacząłem to robić lata temu, zgodnie z CLR books Ritchie. Zrozumiaĺ 'o dla mnie, Ĺźe wszystkie jÄ ™ zyki CLR muszÄ ... byÄ ‡ w stanie obsĹ' ugiwaÄ ‡ zestaw typĂłw CLR, wiÄ ™ c uĹźywajÄ ... C typĂłw CLR podaĺ ' em bardziej czytelny, a moĹźe bardziej "wielokrotnego uĹźycia" kod.

Teraz, gdy robię to od lat, to jest nawyk i podoba mi się kolorystyka, że VS pokazuje dla typów CLR.

Jedyny prawdziwy downer jest to, że auto-complete używa Typu C#, więc kończę ponownie wpisując automatycznie generowane typy, aby określić typ CLR.

Również, teraz, kiedy widzę " int " lub "string", to wygląda naprawdę źle dla mnie, jakbym patrzył na kod C z 1970 roku.

Chciałbym tylko dodać to do lfousts answer, from Ritchers book:

Specyfikacja języka C# stwierdza, "Ze względu na styl, użycie słowo kluczowe jest preferowane w stosunku do pełna nazwa typu systemu."Nie zgadzam się ze specyfikacją języka; I wolą używać nazw typu FCL i całkowicie unikaj prymitywnego typu nazwiska. Faktycznie, życzę aby Kompilatory nie oferował nawet prymitywnego typu nazwy i zmusili deweloperów do korzystania z Nazwy typów FCL zamiast tego. Oto moje uzasadnienie:

Nie dostałem jego opinii zanim przeczytałem cały akapit.

To kwestia konwencji. string wygląda bardziej jak styl C / C++. Ogólna konwencja polega na używaniu dowolnych skrótów podanych przez Ciebie w wybranym języku(int / Int for Int32). Dotyczy to również "obiektu" i decimal.

Teoretycznie mogłoby to pomóc w przeniesieniu kodu do jakiegoś przyszłego 64-bitowego standardu, w którym "int" może oznaczać Int64, ale nie o to chodzi, i spodziewałbym się, że każdy Kreator aktualizacji zmieni wszelkie odniesienia int do Int32 tak dla bezpieczeństwa.

Nie ma żadnej różnicy.

Słowo kluczowe C# string odwzorowuje Typ. NET System.String - jest to alias, który zachowuje konwencje nazewnictwa języka.

Podobnie, int mapuje do System.Int32.

Nowa odpowiedź po 6 latach i 5 miesiącach (zwlekanie).

Podczas gdy string jest zarezerwowanym słowem kluczowym C#, które zawsze ma stałe Znaczenie, String jest zwykłym identyfikatorem , który może odnosić się do wszystkiego. W zależności od elementów bieżącego typu, bieżącej przestrzeni nazw oraz zastosowanych dyrektyw using i ich umiejscowienia, String może być wartością lub typem odmiennym od global::System.String.

Podam dwa przykłady, gdzie using dyrektywy nie będą pomoc .

Pierwszy, gdy String jest wartość typu bieżącego (lub zmiennej lokalnej):

class MySequence<TElement>
{
  public IEnumerable<TElement> String { get; set; }

  void Example()
  {
    var test = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
  }
}

Powyższe nie będzie kompilowane, ponieważ IEnumerable<> nie ma niestatycznego elementu o nazwie Format i nie stosuje się żadnych metod rozszerzeń. W powyższym przypadku nadal może być możliwe użycie String w innych kontekstach, w których Typ jest jedyną możliwą składniowo. Na przykład String local = "Hi mum!"; może być OK (w zależności od przestrzeni nazw i using dyrektywy).

Gorzej: powiedzenie String.Concat(someSequence)prawdopodobnie (w zależności od using s) przejdzie do metody rozszerzenia Linq Enumerable.Concat. Nie przejdzie do metody statycznej string.Concat.

Po drugie, gdy String jest kolejnym Typ, zagnieżdżone wewnątrz bieżącego typu:

class MyPiano
{
  protected class String
  {
  }

  void Example()
  {
    var test1 = String.Format("Hello {0}.", DateTime.Today.DayOfWeek);
    String test2 = "Goodbye";
  }
}

Żadne oświadczenie w metodzie Example nie jest kompilowane. Tutaj String zawsze jest fortepian struna, MyPiano.String. Żaden członek (static lub nie) Format nie istnieje na nim (lub jest dziedziczony z jego klasy bazowej). Oraz wartość "Goodbye" nie może zostać przekonwertowana na nią.

Jest cytat na ten temat z książki Daniela Solisa.

Wszystkie predefiniowane typy są mapowane bezpośrednio do podstawowe typy. NET. Nazwy typu C# (string) są po prostu aliasami dla Typy. NET (String lub System.String), więc używanie nazw. NET działa dobrze składniowo, chociaż to zniechęca. W programie C# powinieneś używać nazw C# zamiast nazw. NET.

String jest słowem kluczowym i nie można go używać jako identyfikatora.

String nie jest słowem kluczowym i można go użyć jako identyfikatora:

Przykład

string String = "I am a string";

Słowo kluczowe {[2] } jest aliasem dla System.String oprócz kwestii słów kluczowych, te dwa są dokładnie odpowiednik.

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

Tak, to nie jest różnica między nimi, tak jak bool i Boolean.

Nie ma różnicy między tymi dwoma - string, jednak wydaje się być preferowaną opcją przy rozważaniu kodu źródłowego innych programistów.