[C#] सी # में स्ट्रिंग और स्ट्रिंग के बीच क्या अंतर है?


Answers

सिर्फ पूर्णता के लिए, यहां संबंधित जानकारी का मस्तिष्क डंप है ...

जैसा कि अन्य ने नोट किया है, string System.String लिए एक उपनाम है। string । वे एक ही कोड को संकलित करते हैं, इसलिए निष्पादन समय पर कोई अंतर नहीं होता है। यह सी # में उपनामों में से एक है। पूरी सूची है:

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

string और object अलावा, उपनाम सभी प्रकार के मूल्यों के लिए हैं। decimal एक मान प्रकार है, लेकिन सीएलआर में एक आदिम प्रकार नहीं है। एकमात्र आदिम प्रकार जिसमें उपनाम नहीं है System.IntPtr

Spec में, मान प्रकार उपनाम "सरल प्रकार" के रूप में जाना जाता है। प्रत्येक साधारण प्रकार के निरंतर मूल्यों के लिए साहित्य का उपयोग किया जा सकता है; कोई अन्य मूल्य प्रकार के शाब्दिक रूप उपलब्ध नहीं हैं। (वीबी के साथ इसकी तुलना करें, जो DateTime अक्षरों की अनुमति देता है, और इसके लिए भी उपनाम है।)

एक परिस्थिति है जिसमें आपको उपनामों का उपयोग करना होता है: जब एक enum के अंतर्निहित प्रकार को स्पष्ट रूप से निर्दिष्ट करते हैं। उदाहरण के लिए:

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

यह सिर्फ एक बात है कि spec enum घोषणाओं को परिभाषित करता है - कोलन के बाद हिस्सा अभिन्न प्रकार का उत्पादन होना चाहिए, जो कि sbyte , byte , short , ushort , int , uint , long , ulong , char का एक टोकन है। .. उदाहरण के लिए परिवर्तनीय घोषणाओं द्वारा उपयोग किए जाने वाले प्रकार के उत्पादन के विपरीत। यह किसी भी अन्य अंतर का संकेत नहीं देता है।

अंत में, जब इसका उपयोग करने की बात आती है: व्यक्तिगत रूप से मैं कार्यान्वयन के लिए हर जगह उपनाम का उपयोग करता हूं, लेकिन किसी भी एपीआई के लिए सीएलआर प्रकार का उपयोग करता हूं। यह वास्तव में बहुत अधिक मायने रखता नहीं है जो आप कार्यान्वयन के मामले में उपयोग करते हैं - आपकी टीम के बीच स्थिरता अच्छी है, लेकिन कोई और देखभाल करने वाला नहीं है। दूसरी ओर, यह वास्तव में महत्वपूर्ण है कि यदि आप एक एपीआई में एक प्रकार का संदर्भ देते हैं, तो आप एक भाषा तटस्थ तरीके से ऐसा करते हैं। ReadInt32 नामक एक विधि स्पष्ट है, जबकि ReadInt नामक एक विधि को व्याख्या की आवश्यकता होती है। कॉलर एक ऐसी भाषा का उपयोग कर सकता है जो उदाहरण के लिए Int16 लिए एक int उपनाम परिभाषित करता है। .NET फ्रेमवर्क डिजाइनरों ने इस पैटर्न का पालन किया है, BitConverter , BinaryReader और Convert क्लास में अच्छे उदाहरण हैं।

Question

उदाहरण ( मामले को नोट करें ):

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

प्रत्येक के उपयोग के लिए दिशानिर्देश क्या हैं? और मतभेद क्या हैं?




string और String सभी तरीकों से समान हैं (अपरकेस "एस" को छोड़कर)। किसी भी तरह के प्रदर्शन प्रभाव नहीं हैं।

सिंटैक्स हाइलाइटिंग के कारण अधिकांश परियोजनाओं में लोअरकेस string को प्राथमिकता दी जाती है




पार्टी के लिए देर से आ रहा है: मैं सीएलआर प्रकारों का 100% समय का उपयोग करता हूं (ठीक है, अगर सी # प्रकार का उपयोग करने के लिए मजबूर किया गया है, लेकिन मुझे याद नहीं है कि आखिरी बार कब था)।

रिची द्वारा सीएलआर किताबों के अनुसार, मैंने मूल रूप से इस साल पहले ऐसा करना शुरू कर दिया था। मुझे यह समझ में आया कि सभी सीएलआर भाषाओं को अंततः सीएलआर प्रकारों के सेट का समर्थन करने में सक्षम होना चाहिए, इसलिए सीएलआर प्रकारों का उपयोग करके आप स्पष्ट, और संभवतः अधिक "पुन: प्रयोज्य" कोड प्रदान करते हैं।

अब जब मैं इसे सालों से कर रहा हूं, यह एक आदत है और मुझे रंग पसंद है कि वीएस सीएलआर प्रकारों के लिए दिखाता है।

एकमात्र असली डाउनर यह है कि स्वतः पूर्ण सी # प्रकार का उपयोग करता है, इसलिए मैं इसके बजाय सीएलआर प्रकार निर्दिष्ट करने के लिए स्वचालित रूप से जेनरेट किए गए प्रकारों को फिर से लिखना समाप्त करता हूं।

इसके अलावा, अब, जब मैं "int" या "string" देखता हूं, तो यह वास्तव में मेरे लिए वास्तव में गलत लगता है, जैसे कि मैं 1 9 70 के सी कोड को देख रहा हूं।




System.String लिए लोअर केस string एक उपनाम है। string । वे C# में समान हैं।

इस पर बहस है कि आपको सिस्टम प्रकार ( System.Int32 , System.String , आदि) प्रकार या C# aliases ( int , string , आदि) का उपयोग करना चाहिए या नहीं। मैं व्यक्तिगत रूप से मानता हूं कि आपको C# aliases उपयोग करना चाहिए, लेकिन यह सिर्फ मेरी निजी वरीयता है।




System.String .NET स्ट्रिंग क्लास है - C # string में System.String लिए उपनाम है - इसलिए उपयोग में वे समान हैं।

दिशानिर्देशों के लिए मैं बहुत परेशान नहीं होता हूं और जो कुछ भी आपको लगता है उसका उपयोग करें - जीवन में और भी महत्वपूर्ण चीजें हैं और कोड वैसे भी वही होगा।

यदि आप स्वयं को ऐसे सिस्टम बनाते हैं जहां आप उपयोग कर रहे पूर्णांक के आकार को निर्दिष्ट करना आवश्यक है और इसलिए Int16 , Int32 , UInt16 , UInt32 आदि का उपयोग करना चाहते हैं तो String का उपयोग करने के लिए यह और अधिक प्राकृतिक लग सकता है - और अलग-अलग के बीच घूमते समय .NET भाषाओं से यह चीजों को और अधिक समझने योग्य बना सकता है - अन्यथा मैं स्ट्रिंग और int का उपयोग करूंगा।




यह वास्तव में सम्मेलन का मामला है। "स्ट्रिंग" बस सी / सी ++ शैली की तरह दिखता है। सामान्य सम्मेलन आपके चुने हुए भाषा द्वारा प्रदान किए गए शॉर्टकट का उपयोग करना है (int32 के लिए int / int)। यह "ऑब्जेक्ट" और "दशमलव" के लिए भी जाता है।

सैद्धांतिक रूप से यह कुछ भविष्य में 64-बिट मानक में कोड कोड करने में मदद कर सकता है जिसमें "int" का अर्थ इंट 64 हो सकता है, लेकिन यह बात नहीं है, और मैं उम्मीद करता हूं कि किसी भी अपग्रेड विज़ार्ड को "Int32" के किसी भी "int" संदर्भ को बदलने के लिए सुरक्षित रहना।




स्ट्रिंग ( System.String ) बेस क्लास लाइब्रेरी में एक कक्षा है। स्ट्रिंग (लोअर केस) सी # में एक आरक्षित काम है जो System.String के लिए उपनाम है। Int32 बनाम int एक समान स्थिति है जैसे Boolean vs. bool । ये सी # भाषा विशिष्ट कीवर्ड आपको सी के समान शैली में प्राइमेटिव घोषित करने में सक्षम बनाता है।




There is no difference between the two - string , however, appears to be the preferred option when considering other developers' source code.




6 साल और 5 महीने (विलंब) के बाद नया जवाब।

While string is a reserved C# keyword that always has a fixed meaning, String is just an ordinary identifier which could refer to anything. Depending on members of the current type, the current namespace and the applied using directives and their placement, String could be a value or a type distinct from global::System.String .

I shall provide two examples where using directives will not help .

First, when String is a value of the current type (or a local variable):

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

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

The above will not compile because IEnumerable<> does not have a non-static member called Format , and no extension methods apply. In the above case, it may still be possible to use String in other contexts where a type is the only possibility syntactically. For example String local = "Hi mum!"; could be OK (depending on namespace and using directives).

Worse: Saying String.Concat(someSequence) will likely (depending on using s) go to the Linq extension method Enumerable.Concat . It will not go to the static method string.Concat .

Secondly, when String is another type , nested inside the current type:

class MyPiano
{
  protected class String
  {
  }

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

Neither statement in the Example method compiles. Here String is always a piano string , MyPiano.String . No member ( static or not) Format exists on it (or is inherited from its base class). And the value "Goodbye" cannot be converted into it.




अन्य प्रोग्रामर के बीच सामान्य प्रैक्टिस के विपरीत, मैं String पर string पसंद करता हूं, इस तथ्य को हाइलाइट करने के लिए कि String एक संदर्भ प्रकार है, जैसा कि जॉन स्कीट ने उल्लेख किया था।




यह यूट्यूब वीडियो व्यावहारिक रूप से प्रदर्शित करता है कि वे कैसे भिन्न होते हैं।

लेकिन अब एक लंबे पाठ के जवाब के लिए।

जब हम .NET बारे में बात करते हैं तो दो अलग-अलग चीजें होती हैं जिनमें एक .NET ढांचा होता है और दूसरी भाषाएं होती हैं ( C# , VB.NET आदि) जो उस ढांचे का उपयोग करती हैं।

" System.String " उर्फ ​​"स्ट्रिंग" (पूंजी "एस") एक .NET फ्रेमवर्क डेटा प्रकार है जबकि "स्ट्रिंग" एक C# डेटा प्रकार है।

संक्षेप में "स्ट्रिंग" एक उपनाम ("स्ट्रिंग" के अलग-अलग नामों के साथ कहा जाता है)। तो तकनीकी रूप से नीचे दिए गए कोड कथन दोनों एक ही आउटपुट देंगे।

String s = "I am String";

या

string s = "I am String";

इसी तरह नीचे दिखाए गए अनुसार अन्य सी # डेटा प्रकार के लिए उपनाम हैं: -

ऑब्जेक्ट: System.Object ऑब्जेक्ट, स्ट्रिंग: System.Object । स्ट्रिंग, बूल: सिस्टम। बुलीयन, बाइट: सिस्टम। बाइट, एसबीटीई: सिस्टम। बाइट, लघु: सिस्टम.इन्ट 16 और इसी तरह

अब प्रोग्रामर के दृष्टिकोण से मिलियन डॉलर का सवाल तो "स्ट्रिंग" और "स्ट्रिंग" का उपयोग कब करें?

भ्रम से बचने के लिए पहली बात लगातार उनमें से एक का उपयोग करें। लेकिन जब आप परिवर्तनीय घोषणा करते हैं तो सर्वोत्तम प्रथाओं से परिप्रेक्ष्य से "स्ट्रिंग" (छोटे "एस") का उपयोग करना अच्छा होता है और जब आप इसे कक्षा के नाम के रूप में उपयोग कर रहे हैं तो "स्ट्रिंग" (पूंजी "एस") को प्राथमिकता दी जाती है।

नीचे दिए गए कोड में बाएं हाथ की तरफ एक परिवर्तनीय घोषणा है और इसे "स्ट्रिंग" का उपयोग करके घोषित किया गया है। दायीं तरफ हम एक विधि बुला रहे हैं इसलिए "स्ट्रिंग" अधिक समझदार है।

string s = String.ToUpper() ;



Yes, that's no difference between them, just like the bool and Boolean .




सी # में प्रदत्त प्रकार उपनामों का उपयोग करने के बारे में मैंने कभी भी सबसे अच्छा जवाब सुना है, जेफरी रिचटर से उनकी पुस्तक सीएलआर वाया सी # में आता है । यहां उनके 3 कारण हैं:

  • मैंने कई डेवलपर्स को उलझन में देखा है, यह नहीं जानते कि उनके कोड में स्ट्रिंग या स्ट्रिंग का उपयोग करना है या नहीं। चूंकि सी # स्ट्रिंग (एक कीवर्ड) मानचित्र में बिल्कुल सिस्टम। स्ट्रिंग (एक एफसीएल प्रकार) में कोई अंतर नहीं होता है और इसका उपयोग भी किया जा सकता है।
  • सी # में, लंबे नक्शे को System.Int64 पर , लेकिन एक अलग प्रोग्रामिंग भाषा में, लंबे समय तक Int16 या Int32 पर नक्शा लगा सकता है। वास्तव में, सी ++ / सीएलआई वास्तव में एक इंट 32 के रूप में लंबे समय तक इलाज करता है। एक भाषा में कोई भी स्रोत कोड पढ़ने से कोड के इरादे को आसानी से गलत तरीके से परिभाषित किया जा सकता है यदि उसे किसी अन्य प्रोग्रामिंग भाषा में प्रोग्रामिंग के लिए उपयोग किया जाता है। वास्तव में, अधिकांश भाषाएं एक कीवर्ड के रूप में लंबे समय तक भी इलाज नहीं करतीं और इसका उपयोग करने वाले कोड को संकलित नहीं करतीं।
  • एफसीएल में कई विधियां हैं जिनके प्रकार के नाम उनके विधि नामों के हिस्से के रूप में हैं। उदाहरण के लिए, BinaryReader प्रकार ReadBoolean , ReadInt32 , ReadSingle , और इसी तरह के तरीके प्रदान करता है, और System.Convert प्रकार ToBoolean , ToInt32 , ToSingle , आदि जैसे तरीकों की पेशकश करता है। हालांकि निम्नलिखित कोड लिखना कानूनी है, फ्लोट वाली रेखा मेरे लिए बहुत अप्राकृतिक महसूस करती है, और यह स्पष्ट नहीं है कि रेखा सही है:
BinaryReader br = new BinaryReader(...);
float val  = br.ReadSingle(); // Ok, but feels unnatural
Single val = br.ReadSingle(); // OK and feels good

इसलिए यह अब आपके पास है। मुझे लगता है कि ये सभी वास्तव में अच्छे अंक हैं। हालांकि, मुझे अपने कोड में जेफरी की सलाह का उपयोग करके खुद को नहीं मिला। हो सकता है कि मैं अपने सी # दुनिया में भी फंस गया हूं लेकिन मैं अपना कोड फ्रेमवर्क कोड की तरह दिखने की कोशिश कर रहा हूं।




एक अंतर है - आप using System; बिना String उपयोग नहीं कर सकते using System; पहले से।




जैसा कि अन्य लोग कह रहे हैं, वे वही हैं। स्टाइलकॉप नियम, डिफ़ॉल्ट रूप से, string का उपयोग करने के लिए आपको सी # कोड शैली के सर्वोत्तम अभ्यास के रूप में उपयोग करने के लिए लागू करेंगे, सिवाय इसके कि सिस्टम को संदर्भित करते समय। string , String.Join , String.Concat , आदि जैसे स्थिर फ़ंक्शंस ...




Links