Örnek (durumu not edin ):

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

Her birinin kullanımına ilişkin yönergeler nelerdir? Farklılıklar nelerdir?

string, C # için bir takma addır System.String.
Yani teknik olarak hiçbir fark yok. Sanki int vs. System.Int32 .

Kurallara göre, genellikle stringbir nesneye atıfta bulunduğunuz her an kullanılması önerilir .

Örneğin

string place = "world";

Aynı şekilde, Stringözellikle sınıfa başvurmanız gerekiyorsa, genellikle kullanılması tavsiye edilir .

Örneğin

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

Bu, Microsoft'un örneklerinde kullanma eğilimindedir .

StyleCop artık C #'a özgü takma adların kullanımını zorunlu kıldığından , bu alandaki rehberliğin değişmiş olabileceği anlaşılmaktadır .

Sadece bütünlük adına, işte ilgili bilgilerin bir beyin dökümü ...

Diğerlerinin belirttiği gibi, stringiçin bir takma addır System.String. Aynı kodu derlerler, bu yüzden yürütme zamanında herhangi bir fark yoktur. Bu C # 'daki takma adlardan sadece biridir. Tam liste:

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

Bunun dışında stringve object, takma adlar değer türleri için tüm vardır. decimalbir değer türüdür, ancak CLR'de ilkel bir tür değildir. Takma adı olmayan tek ilkel tür System.IntPtr.

Spesifikasyonda, değer türü takma adları "basit türler" olarak bilinir. Değişmez değerler her basit türün sabit değerleri için kullanılabilir; başka hiçbir değer türünün gerçek formu yoktur. (Bunu, DateTimedeğişmez değerlere izin veren ve bunun için bir takma adı olan VB ile karşılaştırın .)

Takma adları kullanmanız gereken bir durum vardır : bir enum'un altında yatan türü açıkça belirtirken . Örneğin:

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

Bu şekilde meselesi Spec tanımlar enum bildirimleri var - kolon sonra parçası olmak zorunda ayrılmaz tipi bir belirteç olan üretim, sbyte, byte, short, ushort, int, uint, long, ulong, char... bir karşıt olarak tip üretim olarak örneğin değişken bildirimleri tarafından kullanılır. Başka bir fark belirtmez.

Son olarak, hangi kullanım söz konusu olduğunda: kişisel olarak uygulama için her yerde takma adları kullanıyorum, ancak herhangi bir API için CLR türü. Uygulama açısından hangisini kullandığınız gerçekten çok önemli değil - ekibiniz arasındaki tutarlılık iyi, ancak kimse ilgilenmeyecek. Öte yandan, bir API'daki bir türe başvurursanız, bunu dilden bağımsız bir şekilde yapmanız gerçekten önemlidir. Denilen bir yöntem ReadInt32açıktır, oysa denilen bir yöntem ReadIntyorum gerektirir. Arayan , örneğin bir inttakma ad tanımlayan bir dil kullanıyor olabilir Int16. .NET framework tasarımcıları, bu deseni izlemiştir iyi örnekler olmak BitConverter, BinaryReaderve Convertsınıflar.

Stringkısaltmasıdır System.Stringve bir .NET Framework türüdür. için C # dilinde stringbir takma addırSystem.String . Her ikisi de System.StringIL'de (Orta Dil) derlenmiştir , bu yüzden fark yoktur. Ne sevdiğini seç ve kullan. C # kodlarsanız, ben stringC # türü takma adı ve C # programcılar tarafından bilinen tercih ederim .

( int, System.Int32) Vb. İçin de aynı şeyi söyleyebilirim .

C # 'da sağlanan tür takma adlarını kullanma hakkında duyduğum en iyi cevap, CLR Via C # adlı kitapta Jeffrey Richter'den geliyor . İşte 3 nedeni:

• Kodlarında dize mi yoksa Dize mi kullanılacağını bilmeden, bir dizi geliştiricinin kafası karıştığını gördüm . C # 'da dize (bir anahtar kelime) tam olarak System.String (FCL türü) ile eşleştiğinden, hiçbir fark yoktur ve her ikisi de kullanılabilir.
• C # 'da uzun System.Int64 ile eşlenir , ancak farklı bir programlama dilinde uzun bir Int16 veya Int32 ile eşlenebilir . Aslında, C ++ / CLI aslında bir Int32 kadar tedavi eder . Bir dilde kaynak kodu okuyan biri, farklı bir programlama dilinde programlamaya alışkınsa, kodun niyetini kolayca yanlış yorumlayabilir. Aslında, çoğu dil uzun süre bir anahtar kelime gibi davranmaz ve onu kullanan kodu derlemez.
• FCL, yöntem adlarının bir parçası olarak tür adlarına sahip birçok yönteme sahiptir. Örneğin, BinaryReader türü ReadBoolean , ReadInt32 , ReadSingle ve benzeri yöntemler sunar ve System.Convert türü ToBoolean , ToInt32 , ToSingle ve benzeri yöntemler sunar . Aşağıdaki kodu yazmak yasal olsa da, şamandıralı çizgi bana çok doğal gelmiyor ve çizginin doğru olduğu belli değil:

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

İşte burada. Bunların hepsi gerçekten iyi noktalar. Ancak, kendi kodumda Jeffrey'nin tavsiyesini kullanarak kendimi bulamıyorum. Belki de C # dünyamda takılıp kaldım ama kodumu çerçeve koduna benzetmeye çalışıyorum.

stringayrılmış bir sözcüktür, ancak Stringyalnızca bir sınıf adıdır. Bu string, tek başına değişken adı olarak kullanılamayacağı anlamına gelir .

Herhangi bir nedenle string adlı bir değişken isteseydiniz , bu derlemelerin yalnızca ilkini görürsünüz:

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

Gerçekten string adında bir değişken adı istiyorsanız @önek olarak kullanabilirsiniz :

StringBuilder @string = new StringBuilder();

Başka bir kritik fark: Yığın Taşması bunları farklı şekilde vurgular.

Tek fark var - sen kullanamazsınız Stringolmadan using System;önceden.

Yukarıda ele alınmıştır; ancak stringyansımada kullanamazsınız ; kullanmalısın String.

System.String.NET dize sınıfıdır - C # stringiçin bir takma addır System.String- kullanımda aynıdır.

Kurallara gelince, çok fazla saplanmayacaktım ve sadece hangisini istersen kullanacağım - hayatta daha önemli şeyler var ve kod yine de aynı olacak.

Eğer kullandığınız tamsayılar boyutunu belirlemek için gereklidir sistemleri bina kendinizi bulmak ve böylece kullanım eğilimi varsa Int16, Int32, UInt16, UInt32vb o zaman kullanmak daha doğal görünebilir String- ve farklı .net dilleri arasında hareket ederken might işleri daha anlaşılır kılmak - aksi takdirde string ve int kullanırdım

.NETBiçimlendirme amacıyla büyük harfli türleri (takma adlar yerine) tercih ederim . .NETTürleri, diğer nesne türleri (değer türleri sonuçta, doğru nesnelerdir) ile aynı renklidir.

Şartlı ve kontrol anahtar kelimeler (gibi if, switchve return) küçük harf ve renkli koyu mavi (varsayılan olarak). Ve kullanım ve format konusunda anlaşmazlığı tercih etmemeyi tercih ederim.

Düşünmek:

String someString; 
string anotherString; 

stringve Stringher şekilde aynıdır (büyük harf "S" hariç). Her iki durumda da herhangi bir performans etkisi yoktur.

stringSözdizimi vurgulaması nedeniyle çoğu projede küçük harf tercih edilir

C #, CLR ile birlikte kullanılan bir dildir.

string C # 'da bir tür.

System.String CLR'de bir türdür.

C # ile birlikte kullanıldığında CLR stringile eşlenir System.String.

Teorik olarak, Java bayt kodu oluşturan bir C # derleyicisi uygulayabilirsiniz. Bu derleyici bir mantıklı uygulanması muhtemelen eşlersiniz stringiçin java.lang.StringJava çalışma zamanı kitaplığı ile birlikte çalışan amacıyla.

Bu YouTube videosu pratikte nasıl farklı olduklarını gösterir.

Ama şimdi uzun bir metin cevabı için.

Biz bahsederken .NETiki farklı şey var bir tane var .NETçerçeve ve diğer diller (vardır C#, VB.NETo çerçeveyi kullanmak vs).

" System.String" aka "String" (büyük "S") bir .NETçerçeve veri türüdür, "string" ise bir C#veri türüdür.

Kısacası "String", "string" ifadesinin bir takma adıdır (farklı adlarla aynı addır). Teknik olarak aşağıdaki kod ifadelerinin her ikisi de aynı çıktıyı verecektir.

String s = "I am String";

veya

string s = "I am String";

Aynı şekilde, aşağıda gösterildiği gibi diğer c # veri türü için takma adlar vardır: -

object:, System.Objectstring:, System.Stringbool:, System.Booleanbayt:, System.Bytesbyte:, System.SByteshort: System.Int16vb.

Şimdi programcının bakış açısından milyon dolarlık soru Peki ne zaman "String" ve "string" kullanılır?

Karışıklıktan kaçınmak için ilk şey, bunlardan birini sürekli kullanın. Ancak en iyi uygulamalar perspektifinden, değişken bildirimi yaptığınızda "string" (küçük "s") kullanmak iyidir ve sınıf adı olarak kullandığınızda "String" (capital "S") tercih edilir.

Aşağıdaki kodda sol taraf bir değişken bildirgesidir ve "string" kullanılarak bildirilmiştir. Sağ tarafta "String" daha mantıklı bir yöntem çağırıyoruz.

string s = String.ToUpper() ;

Küçük harf stringbir takma addır System.String. Onlar aynı C#.

Sistem türleri (kullanmak gerekip gerekmediği konusunda bir tartışma var System.Int32, System.Stringvs.) tipleri veya C# aliases( int, string, vs). Kişisel olarak kullanmanız gerektiğine inanıyorum C# aliases, ama bu sadece benim kişisel tercihim.

stringsadece bir takma addır System.String. Derleyici onlara aynı şekilde davranacaktır.

Sadece pratik fark söz olarak vurgulama sözdizimi ve yazma gerektiğini using Systemkullanırsanız String.

İkisi de aynı. Ancak kodlama yönergeleri bakış açısından, bunun stringyerine kullanmak daha iyidir String. Genellikle geliştiriciler bunu kullanır. ör. takma ad olarak Int32kullanmak yerineintintInt32

FYI “Anahtar kelime dizesi, sadece önceden tanımlanmış sınıf için bir takma addır System.String.” - C # Dil Özellikleri 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

Diğerlerinin söylediği gibi, onlar aynı. StyleCop kuralları, varsayılan olarak, kullanmak zorunlu kılar stringC # kodu stili olarak başvuran dışında en iyi uygulamaları, System.Stringgibi statik işlevleri String.Format, String.Join, String.Concat, vb ...

6 yıl 5 ay sonra yeni cevap (erteleme).

Her stringzaman sabit bir anlamı olan ayrılmış bir C # anahtar kelime olsa da , herhangi bir şeye atıfta bulunabilecek Stringsıradan bir tanımlayıcıdır . Geçerli türün üyelerine bağlı olarak, geçerli ad alanı ve uygulanan usingyönergeler ve bunların yerleşimi, Stringfarklı bir değer veya tür olabilir global::System.String.

usingDirektiflerin yardımcı olmayacağı iki örnek vereceğim .

İlk olarak, bir Stringa, değer akım tipi (veya yerel bir değişken) ait:

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

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

Yukarıdaki derlenmeyecektir, çünkü IEnumerable<>çağrılan statik olmayan bir üyesi Formatyoktur ve hiçbir uzantı yöntemi uygulanmaz. Yukarıdaki durumda, Stringbir tipin sözdizimsel olarak tek olasılık olduğu başka bağlamlarda da kullanılabilir . Örneğin String local = "Hi mum!";, Tamam olabilir (ad alanına ve usingdirektiflere bağlı olarak ).

Daha kötüsü: Söylemek String.Concat(someSequence)büyük olasılıkla ( usings'ye bağlı olarak ) Linq uzatma yöntemine gidecektir Enumerable.Concat. Statik yönteme gitmeyecektir string.Concat.

İkinci olarak, geçerli türün içine yerleştirilmiş Stringbaşka bir tür ne zaman :

class MyPiano
{
  protected class String
  {
  }

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

ExampleYöntemdeki ifadelerin hiçbiri derlenmez. İşte Stringbir piyano daima dize , MyPiano.String. Üzerinde üye yok ( staticveya yok) Format(veya temel sınıfından miras alınmış). Ve değer "Goodbye"buna dönüştürülemez.

Sistem türlerini kullanmak, bu tür bir şey varsa, C # ve VB.Net arasında bağlantıyı kolaylaştırır.

Başka hangi programcılar arasında yaygın bir uygulama gibi görünüyor karşı, tercihim Stringüzerinde stringsadece gerçeği vurgulamak için StringJon Skeet belirtildiği gibi, bir referans türüdür.

stringadlı kişinin diğer adı (veya stenografi) System.String. Bu, yazarak stringkastettiğimiz anlamına gelir System.String. Think Link'te daha fazla bilgi bulabilirsiniz: 'string', System.String öğesinin bir diğer adı / kısayoludur.

Bunu sadece Ritchers kitabından lfousts cevabına eklemek istiyorum:

C # dil belirtimi, “Bir stil meselesi olarak, tam sistem türü adının kullanılması yerine anahtar kelimenin kullanılması tercih edilir.” Dil şartnamesine katılmıyorum; FCL tür adlarını kullanmayı ve ilkel tür adlarından tamamen kaçınmayı tercih ederim. Aslında, derleyicilerin ilkel tip isimleri ve geliştiricileri FCL tip isimlerini kullanmaya zorlamadım. İşte nedenlerim:

• Kodlarında dize mi yoksa Dize mi kullanılacağını bilmeden, bir dizi geliştiricinin kafası karıştığını gördüm . C # dizgisinde (bir anahtar kelime) System.String (FCL türü) ile tam olarak eşleştiği için fark yoktur ve her ikisi de kullanılabilir. Benzer şekilde, bazı geliştiriciler söylediğini duymuştum int uygulaması 32-bit işletim sistemi çalıştıran bir 32 bit tam sayı ve uygulamanın 64-bit işletim sistemi üzerinde çalışan 64 bitlik tamsayı temsil ettiğini. Bu ifade kesinlikle yanlıştır: C # 'da, int her zaman System.Int32 ile eşleşir ve bu nedenle kodun çalıştığı işletim sistemine bakılmaksızın 32 bitlik bir tamsayıyı temsil eder. Programcılar kullanırsaInt32 kodlarında, bu potansiyel karışıklık da ortadan kaldırılır.

• C # 'da uzun System.Int64 ile eşlenir , ancak farklı bir programlama dilinde uzun bir Int16 veya Int32 ile eşlenebilir . Aslında, C ++ / CLI bir Int32 kadar uzun davranır . Bir dilde kaynak kodu okuyan biri, farklı bir programlama dilinde programlamaya alışkınsa, kodun niyetini kolayca yanlış yorumlayabilir. Aslında, çoğu dil uzun süre bir anahtar kelime gibi davranmaz ve onu kullanan kodu derlemez.

• FCL, yöntem adlarının bir parçası olarak tür adlarına sahip birçok yönteme sahiptir. Örneğin, BinaryReader türü ReadBoolean , ReadInt32 , ReadSingle vb. Yöntemler sunar ve System.Convert türü ToBoolean , ToInt32 , ToSingle vb. Yöntemler sunar . Aşağıdaki kodu yazmak yasal olsa da, şamandıralı çizgi bana çok doğal gelmiyor ve çizginin doğru olduğu belli değil:

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

• C # kullanan birçok programcı, CLR'ye karşı diğer programlama dillerinin kullanılabileceğini unutmaya eğilimlidir ve bu nedenle C # mekanizmaları sınıf kitaplığı koduna girer. Örneğin, Microsoft'un FCL neredeyse sadece C # ile yazılmış ve FCL takımında geliştiriciler artık kütüphane böyle içine yöntemler girmiştik Array s’ GetLongLength bir döndüren, Int64 bir olan değeri uzun C gibi (diğer dillerde C # ancak ++ / CLI). Bir başka örnek ise System.Linq.Enumerable sitesindeki LongCount yöntemi.

Paragrafın tamamını okumadan önce fikrini alamadım.

String ( System.String), temel sınıf kitaplığındaki bir sınıftır. string (küçük harf) C # içinde System.String için bir diğer ad olan ayrılmış bir çalışmadır. Int32 vs int de benzer bir durumdur Boolean vs. bool. Bu C # diline özgü anahtar kelimeler, C'ye benzer bir stilde ilkelleri bildirmenize olanak tanır.

Stringbir anahtar kelime değildir ve Tanımlayıcı olarak kullanılabilirken stringbir anahtar kelime olup, Tanımlayıcı olarak kullanılamaz. Ve fonksiyon açısından her ikisi de aynıdır.

Gerçekten bir kongre meselesi. stringsadece C / C ++ stiline benziyor. Genel kural, seçtiğiniz dilin sağladığı kısayolları kullanmaktır (int / Int için Int32). Bu "nesne" için decimalde geçerlidir.

Teorik olarak bu, kodun "int" anlamına gelebilecek gelecekteki 64 bitlik bir standarda bağlanmasına yardımcı olabilir Int64, ancak bu nokta değildir ve herhangi bir yükseltme sihirbazının herhangi bir intreferansı Int32güvenli bir şekilde değiştirmesini beklerim.

Partiye geç geliyor: CLR tiplerini% 100 kullanıyorum (C # tipini kullanmaya zorlanmadığı sürece , ama son ne zaman olduğunu hatırlamıyorum).

Başlangıçta bu sene önce, Ritchie'nin CLR kitaplarına göre yapmaya başladım. Tüm CLR dillerinin nihayetinde CLR türleri kümesini destekleyebilmeleri mantıklıydı, bu yüzden CLR türlerini kullanarak kendiniz daha net ve muhtemelen daha fazla "yeniden kullanılabilir" kod sağladınız.

Şimdi bunu yıllardır yapıyorum, bu bir alışkanlık ve VS'nin CLR türleri için gösterdiği rengi seviyorum.

Tek gerçek downer, otomatik tamamlamanın C # türünü kullanmasıdır, bu nedenle CLR türünü belirtmek için otomatik olarak oluşturulan türleri yeniden yazarım.

Ayrıca, şimdi, "int" veya "string" i gördüğümde, 1970'lerin C koduna baktığımda bana çok yanlış geliyor.

Fark yok.

C # anahtar sözcüğü string.NET türüyle eşleşir System.String- dilin adlandırma kurallarını koruyan bir diğer addır.

Benzer şekilde, ile inteşleşir System.Int32.

Bu konuda Daniel Solis'in kitabından bir alıntı var .

Önceden tanımlanmış tüm türler doğrudan altta yatan .NET türleriyle eşlenir. C # türü adları (dize), .NET türleri (Dize veya System.String) için basitçe takma adlardır, bu nedenle, bu önerilmez, ancak .NET adlarını kullanmak sözdizimsel olarak iyi çalışır. Bir C # programında, .NET adları yerine C # adlarını kullanmalısınız.

string bir anahtar kelimedir ve string'i tanımlayıcı olarak kullanamazsınız.

Dize bir anahtar kelime değildir ve bunu tanımlayıcı olarak kullanabilirsiniz:

Misal

string String = "I am a string";

Anahtar kelime string , System.Stringanahtar kelime sorunundan başka bir takma addır, ikisi tam olarak eşdeğerdir.

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

Evet, aralarında fark yok, tıpkı boolve gibi Boolean.

@JaredPar (C # derleyicisi ve üretken SO kullanıcısı üzerinde bir geliştirici!) Bu konuda harika bir blog yazısı yazdı . Bence burada paylaşmaya değer. Konumuzla ilgili güzel bir bakış açısı.

stringvs. Stringbir stil tartışması değildir

[...]

Anahtar kelimenin stringC # 'da somut bir anlamı vardır. System.StringÇekirdek çalışma zamanı derlemesinde bulunan türdür . Çalışma zamanı, bu türü özünde anlar ve geliştiricilerin .NET'te dizeler için beklediği yetenekleri sağlar. Varlığı C # için o kadar kritiktir ki, bu tür yoksa, derleyici bir kod satırını ayrıştırmaya çalışmadan önce çıkacaktır. Bu nedenle stringC # kodunda kesin, açık bir anlamı vardır.

Tanımlayıcının StringC # 'da somut bir anlamı yoktur. Bu gibi tüm İsmi arama kuralları geçer bir tanımlayıcı olan Widget, Studentvb ... Bu dizeye bağlamak olabilir ya da başka bir montaj tamamen, amaçları daha tamamen farklı olabilir bir tip bağlamak olabilir string. Daha kötüsü, kod gibi bir şekilde tanımlanabilir String s = "hello"; derlemeye devam etti.

class TricksterString { 
  void Example() {
    String s = "Hello World"; // Okay but probably not what you expect.
  }
}

class String {
  public static implicit operator String(string s) => null;
}

Gerçek anlamı Stringher zaman ad çözümlemesine bağlı olacaktır. Bu, projedeki tüm kaynak dosyalara ve başvurulan tüm derlemelerde tanımlanan tüm türlere bağlı olduğu anlamına gelir. Kısacası bunun ne anlama geldiğini bilmek biraz bağlam gerektirir .

Gerçek vakaların büyük çoğunluğunda olduğu Stringve stringaynı tip bağlanacaktır. Ancak Stringyine de kullanmak , geliştiricilerin programlarını tek bir doğru cevabın olduğu yerlerde yorumlamaya bıraktığı anlamına gelir. Ne zaman Stringyanlış tip bağlamak gelmez bu derleyici takımında hataları dosyalama ve genellikle kullanılarak kaydedilmiş olabilirdi zaman israf, saatlerce ayıklama geliştiriciler bırakabilir string.

Farkı görselleştirmenin başka bir yolu da bu örnektir:

string s1 = 42; // Errors 100% of the time  
String s2 = 42; // Might error, might not, depends on the code

Birçoğu, bu teknik olarak doğru bilgiler Stringolsa da, kod tabanının bu adın bir türünü tanımlaması son derece nadir olduğu için kullanımın hala iyi olduğunu iddia edecektir . Veya Stringtanımlandığında, kötü bir kod tabanının bir işareti.

[...]

Bunu göreceksiniz Stringbu kütüphaneler herhangi biri için ... vb yansıma yardımcıları, seri hale kütüphaneleri, lexers, protokoller: tamamen geçerli amaçlarla için tanımlanan Stringvs stringkod kullanıldığı yere bağlı olarak gerçek sonuçlar doğurur.

Tartışmaya Stringkarşı stringtartışmayı gördüğünüzde bunun tarz değil anlambilim ile ilgili olduğunu unutmayın. Dize seçmek, kod tabanınıza net bir anlam kazandırır. Seçim Stringyanlış değil ama gelecekte sürprizlere kapı açıyor.

Not: Blog gönderisinin çoğunu arşiv amacıyla kopyaladım / yapıştırdım. Bazı bölümleri görmezden geliyorum, bu yüzden atlayabilir ve mümkünse blog gönderisini okumanızı tavsiye ederim .