උදාහරණය ( නඩුව සටහන් කරන්න ):

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

එක් එක් භාවිතය සඳහා මාර්ගෝපදේශ මොනවාද? වෙනස්කම් මොනවාද?

stringසඳහා C # හි අන්වර්ථයකි System.String.
එබැවින් තාක්ෂණික වශයෙන් කිසිදු වෙනසක් නොමැත. එය int එදිරිව System.Int32 .

මාර්ගෝපදේශ වලට අනුව, stringඔබ වස්තුවක් ගැන සඳහන් කරන ඕනෑම වේලාවක භාවිතා කිරීම සාමාන්‍යයෙන් නිර්දේශ කෙරේ .

උදා

string place = "world";

ඒ හා සමානව, Stringඔබට විශේෂයෙන් පන්තියට යොමු වීමට අවශ්‍ය නම් එය භාවිතා කිරීම සාමාන්‍යයෙන් නිර්දේශ කෙරේ .

උදා

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

මයික්‍රොසොෆ්ට් ඔවුන්ගේ උදාහරණ වල භාවිතා කිරීමට පෙළඹෙන විලාසය මෙයයි .

ස්ටයිල්කොප් දැන් සී # විශේෂිත අන්වර්ථ නාම භාවිතා කිරීම බලාත්මක කරන බැවින් මෙම ප්‍රදේශයේ මග පෙන්වීම වෙනස් වී ඇති බව පෙනේ .

සම්පුර්ණත්වය සඳහා, මෙන්න අදාළ තොරතුරු මොළයක් දමයි ...

අනෙක් අය සඳහන් කර ඇති පරිදි, stringඅන්වර්ථයකි System.String. ඒවා එකම කේතයකට සම්පාදනය කරයි, එබැවින් ක්‍රියාත්මක කිරීමේ වේලාවේ කිසිදු වෙනසක් නොමැත. මෙය C # හි අන්වර්ථයන්ගෙන් එකකි. සම්පූර්ණ ලැයිස්තුව:

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.

පිරිවිතරයේ දී, අගය වර්ගයේ අන්වර්ථයන් "සරල වර්ග" ලෙස හැඳින්වේ. සෑම සරල වර්ගයකම නියත අගයන් සඳහා සාහිත්‍යය භාවිතා කළ හැකිය; වෙනත් කිසිදු වටිනාකමක් ඇති වචනාර්ථයෙන් ආකෘති නොමැත. (මෙය VB සමඟ සසඳන්න, එය DateTimeවචනාර්ථයට ඉඩ සලසයි , ඒ සඳහා අන්වර්ථයක් ද ඇත.)

ඔබ ගැන එක කොන්දේසියන් ඇත ඇති වූ යොමුවීම් භාවිතා කිරීමට: සුවිශේෂව ක නිඛිල ගේ යටින් වර්ගය නියම විට. උදාහරණයක් වශයෙන්:

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

මහ බඩවැල ද විය යුතුය පසු කොටසක් - ඒක පිරිවිතර නිර්වචනය නිඛිල ප්රකාශ මාර්ගය පිළිබඳ කාරණයක් වේ අවියෝජනීය-වර්ගය එක් සංකේත වන නිෂ්පාදනය, sbyte, byte, short, ushort, int, uint, long, ulong, charඑය විරුද්ධ ලෙස ... වර්ගය ලෙස නිෂ්පාදනය උදාහරණයක් ලෙස විචල්‍ය ප්‍රකාශන භාවිතා කරයි. එය වෙනත් වෙනසක් දක්වන්නේ නැත.

අවසාන වශයෙන්, එය භාවිතා කළ යුතු විට: පුද්ගලිකව මම ක්‍රියාත්මක කිරීම සඳහා සෑම තැනකම අන්වර්ථ නාම භාවිතා කරමි, නමුත් ඕනෑම API සඳහා CLR වර්ගය. ක්‍රියාවට නැංවීමේදී ඔබ භාවිතා කරන දේ එතරම් වැදගත් නැත - ඔබේ කණ්ඩායම අතර අනුකූලතාව හොඳයි, නමුත් වෙන කිසිවෙකු එය ගණන් ගන්නේ නැත. අනෙක් අතට, ඔබ API එකක වර්ගයක් ගැන සඳහන් කරන්නේ නම්, ඔබ එය භාෂා-මධ්‍යස්ථ ආකාරයකින් සිදු කිරීම ඇත්තෙන්ම වැදගත් ය. හැඳින්වෙන ක්‍රමයක් ReadInt32නිසැක ය, එහෙත් හැඳින්වෙන ක්‍රමයකට ReadIntඅර්ථ නිරූපණය අවශ්‍ය වේ. අමතන්නාට උදාහරණයක් ලෙස intඅන්වර්ථයක් අර්ථ දක්වන භාෂාවක් භාවිතා කළ හැකිය Int16. මෙම .NET රාමුව නිර්මාණකරුවන් මෙම රටාව, අතුරුදහන් වීම 'තුළ හොඳ උදාහරණ අනුගමනය BitConverter, BinaryReaderහා Convertපන්ති.

Stringසඳහා කි්රයා System.Stringඅතර එය .NET Framework වර්ගය වේ. සඳහා C # භාෂාවේ stringඅන්වර්ථයකිSystem.String . මේ දෙකම System.StringIL (අතරමැදි භාෂාව) සමඟ සම්පාදනය කර ඇති බැවින් වෙනසක් නැත. ඔබ කැමති දේ තෝරාගෙන එය භාවිතා කරන්න. ඔබ C # හි කේත කරන්නේ නම්, මම කැමතියි stringඑය C # වර්ගයේ අන්වර්ථයක් වන අතර C # ක්‍රමලේඛකයින් විසින් හොඳින් දන්නා කරුණකි.

( int, System.Int32) යනාදිය ගැන මටත් එයම කිව හැකිය .

සී # හි සපයා ඇති ආකාරයේ අන්වර්ථ නාමයන් භාවිතා කිරීම පිළිබඳව මා අසා ඇති හොඳම පිළිතුර ලැබෙන්නේ ජෙෆ්රි රිච්ටර් විසින් ඔහුගේ සීඑල්ආර් වියා සී # පොතේ ය . ඔහුගේ හේතු 3 මෙන්න:

• මම සංවර්ධකයින් රාශියක්, ව්යාකූල භාවිතා කිරීමට ද යන්න නොදැන දැකලා තියෙනවා string හෝ සංගීත ඔවුන්ගේ කේතය දී. C # නූලෙන් (යතුරු පදයක්) හරියටම System.String (FCL වර්ගයක්) වෙත සිතියම් ගත කරන බැවින්, කිසිදු වෙනසක් නොමැති අතර ඒවා භාවිතා කළ හැකිය.
• C # හි, System.Int64 වෙත දිගු සිතියම් , නමුත් වෙනත් ක්‍රමලේඛන භාෂාවකින්, දිගු කාලයක් Int16 හෝ Int32 වෙත සිතියම් ගත කළ හැකිය . ඇත්ත වශයෙන්ම, C ++ / CLI ඇත්ත වශයෙන්ම Int32 ලෙස සලකයි . එක් භාෂාවකින් ප්‍රභව කේත කියවන කෙනෙකුට ඔහු හෝ ඇය වෙනත් ක්‍රමලේඛන භාෂාවකින් ක්‍රමලේඛනය කිරීමට පුරුදු වී සිටියේ නම් කේතයේ අභිප්‍රාය පහසුවෙන් අර්ථ දැක්විය හැකිය. ඇත්ත වශයෙන්ම, බොහෝ භාෂාවන් දිගු කාලයක් යතුරු පදයක් ලෙස සලකන්නේ නැති අතර එය භාවිතා කරන කේත සම්පාදනය නොකරයි.
• එෆ්සීඑල් හි බොහෝ ක්‍රම තිබේ, ඒවායේ ක්‍රම නාමවල කොටසක් ලෙස ටයිප් නම් ඇත. උදාහරණයක් ලෙස, 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

එහෙයින් ඔබට එය තිබේ. මම හිතන්නේ මේ සියල්ල ඇත්තෙන්ම හොඳ කරුණු ය. කෙසේ වෙතත්, මම මගේම කේතයෙන් ජෙෆ්රිගේ උපදෙස් භාවිතා නොකරමි. සමහර විට මම මගේ සී # ලෝකයේ හිර වී ඇති නමුත් මගේ කේතය රාමු කේතය මෙන් පෙනෙන්නට උත්සාහ කරමි.

stringවෙන් කර ඇති වචනයකි, නමුත් Stringඑය පන්තියේ නමකි. මෙයින් අදහස් කරන්නේ stringඑය විචල්‍ය නාමයක් ලෙස භාවිතා කළ නොහැකි බවයි.

කිසියම් හේතුවක් නිසා ඔබට නූල් නම් විචල්‍යයක් අවශ්‍ය නම් , ඔබට පෙනෙනුයේ මෙම සම්පාදනයන්ගෙන් පළමුවැන්න පමණි:

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

ඔබට සැබවින්ම string නමින් විචල්‍ය නමක් අවශ්‍ය නම් ඔබට @උපසර්ගයක් ලෙස භාවිතා කළ හැකිය :

StringBuilder @string = new StringBuilder();

තවත් තීරණාත්මක වෙනසක්: සිරස් පිටාර ගැලීම ඒවා වෙනස් ලෙස ඉස්මතු කරයි.

එක් වෙනසක් ඇත - ඔබට කලින් Stringනොමැතිව භාවිතා කළ නොහැක using System;.

එය ඉහළින් ආවරණය කර ඇත; කෙසේ වෙතත්, ඔබට stringපරාවර්තනය සඳහා භාවිතා කළ නොහැක ; ඔබ භාවිතා කළ යුතුයි String.

System.String.NET string class - C # stringහි අන්වර්ථයකි System.String- එබැවින් භාවිතයේ දී ඒවා සමාන වේ.

මාර්ගෝපදේශ සම්බන්ධයෙන් ගත් කල, මම එතරම් ව්‍යාකූල නොවී ඔබට හැඟෙන ඕනෑම දෙයක් භාවිතා නොකරමි - ජීවිතයේ වඩා වැදගත් දේවල් ඇති අතර කේතය කෙසේ හෝ සමාන වනු ඇත.

ඔබ ගොඩ එය ඔබ භාවිතා කරන පූර්ණ සංඛ්යා ප්රමාණය නියම එසේ භාවිතය නැඹුරු කිරීමට අත්යවශ්ය වන අවස්ථාවක පද්ධති සොයා නම් Int16, Int32, UInt16, UInt32ආදිය පසුව එය භාවිතා කිරීමට වඩා ස්වාභාවික දිස් විය String- හා සමහරවිට වෙනස් .net භාෂා අතර පමණ ගමන් කරන විට දේවල් වඩාත් තේරුම් ගත හැකි පරිදි සකසන්න - එසේ නොමැතිනම් මම නූල් සහ int භාවිතා කරමි.

.NETආකෘතිකරණ හේතූන් මත මම ප්‍රාග්ධනීකෘත වර්ග වලට (අන්වර්ථයන්ට වඩා) කැමතියි . මෙම .NETවර්ග වෙනත් වස්තුවක් වර්ග (වර්ග සියලු පසු, නිසි වස්තූන් වන වටිනාකම) මෙන් ම වර්ණ කර ඇත.

කොන්දේසි සහිත සහ පාලන වචන (වැනි if, switchසහ return) කුඩා අකුරු සහ තද තද නිල් (පෙරනිමියෙන්) වේ. භාවිතයේ සහ ආකෘතියේ එකඟ නොවීමක් මට නැත.

සලකා බලන්න:

String someString; 
string anotherString; 

stringසහ Stringසෑම ආකාරයකින්ම සමාන වේ (ලොකු අකුර "එස්" හැර). එක් ආකාරයකින් කාර්ය සාධන ඇඟවුම් නොමැත.

stringසින්ටැක්ස් ඉස්මතු කිරීම නිසා බොහෝ ව්‍යාපෘති වල සිම්පල් වඩාත් කැමති වේ

සී # යනු සීඑල්ආර් සමඟ එක්ව භාවිතා වන භාෂාවකි.

string C # හි වර්ගයකි.

System.String සීඑල්ආර් හි වර්ගයකි.

ඔබ C # භාවිතා කරන විට CLR stringසමඟ සිතියම් ගත වේ System.String.

න්‍යායාත්මකව, ඔබට ජාවා බයිට් කේතය ජනනය කරන C # -compiler ක්‍රියාත්මක කළ හැකිය. මෙම සම්පාදකයා බුද්ධිමත්ව ක්‍රියාත්මක කිරීම බොහෝ විට ජාවා ධාවන කාල පුස්තකාලය සමඟ අන්තර් ක්‍රියා කිරීම සඳහා සිතියම් ගත stringකරයි java.lang.String.

මෙම යූ ටියුබ් වීඩියෝව ප්‍රායෝගිකව ඒවා වෙනස් වන ආකාරය පෙන්නුම් කරයි.

නමුත් දැන් දිගු පා answer මය පිළිතුරක් සඳහා.

අපි ගැන කතා කරන විට .NETවිවිධ දේවල් දෙකක් එක් වේ පවතී .NETරාමුව සහ වෙනත් භාෂා (ඇත C#, VB.NETබව රාමුව භාවිතා කරන ආදිය).

" System.String" aka "String" (ප්‍රාග්ධනය "S") යනු .NETරාමු දත්ත වර්ගයක් වන අතර "string" යනු C#දත්ත වර්ගයකි.

කෙටියෙන් කිවහොත් “නූල්” යනු “නූල්” හි අන්වර්ථයකි (එකම නම විවිධ නම් වලින් හැඳින්වේ). එබැවින් තාක්ෂණික වශයෙන් පහත කේත ප්‍රකාශ දෙකම එකම ප්‍රතිදානයක් ලබා දෙනු ඇත.

String s = "I am String";

හෝ

string s = "I am String";

පහත දැක්වෙන ආකාරයට වෙනත් c # දත්ත වර්ග සඳහා අන්වර්ථ නාමයන් ඇත: -

වස්තුව: System.Object, නූල්: System.String, bool: System.Boolean, බයිට: System.Byte, sbyte: System.SByteකෙටි: System.Int16හා එසේ මත

දැන් ක්‍රමලේඛකයාගේ දෘෂ්ටි කෝණයෙන් ඩොලර් මිලියනයක ප්‍රශ්නය එසේ නම් “නූල්” සහ “නූල්” භාවිතා කරන්නේ කවදාද?

ව්යාකූලත්වය වළක්වා ගත යුතු පළමු දෙය ඒවායින් එකක් නිරන්තරයෙන් භාවිතා කරන්න. නමුත් හොඳ භාවිතයන් දෙස බලන විට ඔබ විචල්‍ය ප්‍රකාශයක් කරන විට “නූල්” (කුඩා “ය”) භාවිතා කිරීම හොඳ වන අතර ඔබ එය පන්ති නාමයක් ලෙස භාවිතා කරන විට “නූල්” (ප්‍රාග්ධනය “එස්”) වඩාත් සුදුසු වේ.

පහත කේතයෙහි වම් පස විචල්‍ය ප්‍රකාශයක් වන අතර එය "නූල්" භාවිතයෙන් ප්‍රකාශයට පත් කරන ලදි. දකුණු පසින් අපි ක්‍රමයක් අමතන්නෙමු, එබැවින් "නූල්" වඩාත් සංවේදී වේ.

string s = String.ToUpper() ;

පහළ නඩුව stringසඳහා අන්වර්ථයකි System.String. ඔවුන් තුළ සමාන වේ C#.

ඔබ පද්ධතිය වර්ග (භාවිතා කළ යුතු ද යන්න පිලිබඳ විවාදයක් තියෙනවා System.Int32, System.String, ආදිය) වර්ග හෝ C# aliases( int, string, ආදිය). මම පෞද්ගලිකව විශ්වාස කරන්නේ ඔබ එය භාවිතා කළ යුතු බවයි C# aliases, නමුත් එය මගේ පෞද්ගලික මනාපය පමණි.

stringසඳහා අන්වර්ථයකි System.String. සම්පාදකයා ඔවුන්ට එක හා සමානව සලකනු ඇත.

එකම ප්‍රායෝගික වෙනස වන්නේ ඔබ සඳහන් කළ පරිදි සින්ටැක්ස් ඉස්මතු කිරීමයි using System, ඔබ භාවිතා කරන්නේ නම් ලිවිය යුතුය String.

දෙකම එක හා සමානයි. නමුත් කේතකරණ මාර්ගෝපදේශ දෘෂ්ටිකෝණයෙන් ඒ stringවෙනුවට භාවිතා කිරීම වඩා හොඳය String. සාමාන්‍යයෙන් සංවර්ධකයින් භාවිතා කරන්නේ මෙයයි. උදා: Int32අප භාවිතා intකරන intඅන්වර්ථය ලෙස භාවිතා කරනවා වෙනුවටInt32

FYI “මූලික වචන මාලාව හුදෙක් පූර්ව නිශ්චිත පන්තියේ අන්වර්ථයකි System.String.” - සී # භාෂා පිරිවිතර 4.2.3 http://msdn2.microsoft.com/En-US/library/aa691153.aspx

අනෙක් අය පවසන පරිදි, ඔවුන් සමාන ය. StyleCop රීති, පෙරනිමියෙන්, ඔබ භාවිතා කිරීමට ක්රියාත්මක වනු ඇත stringසී # කේතය ශෛලිය හොඳම ක්රමවේදයක් ලෙස, පිලිබඳව සඳහන් කරන විට හැර System.Stringවැනි ස්ථිතික කටයුතු, String.Format, String.Join, String.Concatආදිය, ...

අවුරුදු 6 යි මාස 5 කට පසු නව පිළිතුරක් (කල් දැමීම).

අතර stringහැම විටම ස්ථාවර අර්ථය ඇති බව රක්ෂිත C # ඉඟි පද වන අතර, Stringහුදෙක් සාමාන්ය වේ හඳුනාගැනීමේ දෙයක් වෙත යොමු වන්න හැකි. වත්මන් වර්ගයේ සාමාජිකයන් මත පදනම්ව, වත්මන් නාම අවකාශය සහ ව්‍යවහාරික usingවිධානයන් සහ ඒවා ස්ථානගත කිරීම, Stringවටිනාකමක් හෝ වර්ගයක් විය හැකිය global::System.String.

usingවිධානයන් උදව් නොකරන උදාහරණ දෙකක් මම දෙන්නෙමි .

පළමුව, විට Stringයනු අගය වත්මන් වර්ගය (හෝ දේශීය විචල්ය) ක:

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

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

IEnumerable<>ස්ථිතික නොවන සාමාජිකයෙකු නොමැති නිසා ඉහත සඳහන් දෑ සම්පාදනය නොකෙරෙන අතර දීර් Formatextension කිරීමේ ක්‍රම අදාළ නොවේ. ඉහත අවස්ථාවෙහිදී, වර්ගයක් එකම වාක්‍ය ඛණ්ඩයක් වන Stringවෙනත් සන්දර්භයන්හි භාවිතා කිරීමට තවමත් හැකි විය හැකිය . උදාහරණයක් ලෙස හරි විය හැකිය (නාම අවකාශය සහ විධානයන් මත පදනම්ව ).String local = "Hi mum!";using

නරකම: කීම String.Concat(someSequence)බොහෝ විට ( usings මත පදනම්ව ) ලින්ක් දිගු කිරීමේ ක්‍රමයට යයි Enumerable.Concat. එය ස්ථිතික ක්‍රමයට නොයනු ඇත string.Concat.

දෙවනුව, Stringවෙනත් වර්ගයක් වන විට , වත්මන් වර්ගය තුළ කූඩු කර ඇත:

class MyPiano
{
  protected class String
  {
  }

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

Exampleක්‍රමයේ කිසිදු ප්‍රකාශයක් සම්පාදනය නොකරයි. මෙන්න Stringසෑම විටම පියානෝ නූලක් , MyPiano.String. එහි කිසිදු සාමාජිකයෙක් ( staticහෝ නැත) නොපවතී Format(හෝ එහි මූලික පන්තියෙන් උරුම වී ඇත). වටිනාකම "Goodbye"එය බවට පරිවර්තනය කළ නොහැක.

පද්ධති වර්ග භාවිතා කිරීම මඟින් ඔබ C # සහ VB.Net අතර වරාය කිරීම පහසු කරයි.

වෙනත් වැඩසටහන්කරුවන් අතර සාමාන්ය සිරිතකි බව පෙනේ දේ එරෙහිව, මම කැමති Stringකට stringපමණක් බව අවධාරණය කිරීමට Stringසැඳහුම වර්ගය වන අතර, ජෝන් Skeet සඳහන් පරිදි.

stringහි අන්වර්ථයකි (හෝ කෙටිමං) System.String. ඒ කියන්නේ stringඅපි ටයිප් කිරීමෙන් අදහස් System.Stringකළා. සිතීමේ සබැඳියෙන් ඔබට තවත් කියවිය හැකිය: 'string' යනු System.String හි අන්වර්ථය / කෙටිකතාවකි.

රිචර්ස් පොතෙන් මම මෙය උත්තරයට එකතු කිරීමට කැමතියි:

සී # භාෂා පිරිවිතරයේ මෙසේ සඳහන් වේ, “ශෛලියක් ලෙස, සම්පූර්ණ පද්ධති වර්ගයේ නම භාවිතා කිරීමට වඩා මූලික පදය භාවිතා කිරීමට කැමැත්තක් දක්වයි.” භාෂා පිරිවිතරයට මම එකඟ නොවෙමි; මම කැමතියි එෆ්සීඑල් වර්ගයේ නම් භාවිතා කිරීමට සහ ප්‍රාථමික වර්ගයේ නම් සම්පූර්ණයෙන්ම මග හැරීමට. ඇත්ත වශයෙන්ම, සම්පාදකයින් විසින් ප්‍රාථමික වර්ගයේ නම් පවා ලබා නොදුන් අතර ඒ වෙනුවට FCL වර්ගයේ නම් භාවිතා කිරීමට සංවර්ධකයින්ට බල කෙරුනි. මෙන්න මගේ හේතු:

• මම සංවර්ධකයින් රාශියක්, ව්යාකූල භාවිතා කිරීමට ද යන්න නොදැන දැකලා තියෙනවා string හෝ සංගීත ඔවුන්ගේ කේතය දී. C # string (keyword) හි හරියටම System.String (FCL වර්ගයක්) වෙත සිතියම් ගත කරන බැවින්, කිසිදු වෙනසක් නොමැති අතර ඒවා භාවිතා කළ හැකිය. ඒ හා සමානව, සමහර සංවර්ධකයින් පවසන්නේ 32-බිට් මෙහෙයුම් පද්ධතියක යෙදුම ක්‍රියාත්මක වන විට int 32-bit පූර්ණ සංඛ්‍යාවක් නියෝජනය කරන බවත් යෙදුම 64-bit මෙහෙයුම් පද්ධතියක් මත ක්‍රියාත්මක වන විට එය 64-bit පූර්ණ සංඛ්‍යාවක් නියෝජනය කරන බවත්ය. මෙම ප්‍රකාශය මුළුමනින්ම අසත්‍යයකි: C # හි, int සෑම විටම System.Int32 වෙත සිතියම් ගත කරයි , එබැවින් කේතය ක්‍රියාත්මක වන මෙහෙයුම් පද්ධතිය නොසලකා එය බිටු 32 ක පූර්ණ සංඛ්‍යාවක් නිරූපණය කරයි. ක්‍රමලේඛකයින් භාවිතා කරන්නේ නම්ඔවුන්ගේ කේතයේ Int32 , එවිට මෙම විභව ව්‍යාකූලත්වය ද ඉවත් කරනු ලැබේ.

• C # හි, System.Int64 වෙත දිගු සිතියම් , නමුත් වෙනත් ක්‍රමලේඛන භාෂාවකින්, දිගු කාලයක් Int16 හෝ Int32 වෙත සිතියම් ගත කළ හැකිය . ඇත්ත වශයෙන්ම, C ++ / පාබල සංග්රහ කරන්නේ දිගු ලෙස Int32 . එක් භාෂාවකින් ප්‍රභව කේත කියවන කෙනෙකුට ඔහු හෝ ඇය වෙනත් ක්‍රමලේඛන භාෂාවකින් ක්‍රමලේඛනය කිරීමට පුරුදු වී සිටියේ නම් කේතයේ අභිප්‍රාය පහසුවෙන් අර්ථ දැක්විය හැකිය. ඇත්ත වශයෙන්ම, බොහෝ භාෂාවන් දිගු කාලයක් යතුරු පදයක් ලෙස සලකන්නේ නැති අතර එය භාවිතා කරන කේත සම්පාදනය නොකරයි.

• එෆ්සීඑල් හි බොහෝ ක්‍රම තිබේ, ඒවායේ ක්‍රම නාමවල කොටසක් ලෙස ටයිප් නම් ඇත. උදාහරණයක් ලෙස, 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

• සී # භාවිතා කරන බොහෝ ක්‍රමලේඛකයින් සීඑල්ආර්ට එරෙහිව වෙනත් ක්‍රමලේඛන භාෂා භාවිතා කළ හැකි බව අමතක කිරීමට නැඹුරු වන අතර, මේ නිසා සී # -වාදයන් පන්ති පුස්තකාල කේතයට රිංගයි. උදාහරණයක් ලෙස, Microsoft හි FCL පාහේ මෙම FCL කණ්ඩායම C # හා සංවර්ධකයන් ලියා ඇත දැන් වැනි පුස්තකාල බවට ක්රම හඳුන්වා දී ඇත Array ගේ GetLongLength ක නැවත වන Int64 වූ බව අගය දිගු C # ගැන නමුත් සී වැනි වෙනත් භාෂා (දී ++ / CLI). තවත් උදාහරණයක් වන්නේ System.Linq.Enumerable ’s LongCount ක්‍රමයයි.

සම්පූර්ණ ඡේදය කියවීමට පෙර මට ඔහුගේ මතය ලැබුණේ නැත.

නූල් ( System.String) යනු මූලික පන්ති පුස්තකාලයේ පන්තියකි. string (සිම්පල්) යනු C # හි වෙන් කර ඇති කෘතියක් වන අතර එය System.String සඳහා අන්වර්ථයකි. Int32 vs int සමාන තත්වයකි Boolean vs. bool. මෙම C # භාෂා විශේෂිත වචන මඟින් C ට සමාන ශෛලියකින් ප්‍රාථමික ප්‍රකාශ කිරීමට ඔබට හැකි වේ.

Stringඑය මූල පදයක් නොවන අතර එය හදුනාගැනීමක් ලෙස භාවිතා කළ හැකි අතර එය මූලික පදයක් වන අතර එය හඳුනාගැනීමක් ලෙස භාවිතා stringකළ නොහැක. ක්‍රියාකාරී දෘෂ්ටි කෝණයෙන් දෙකම එක හා සමානයි.

එය සම්මුතියේ කාරණයක්, ඇත්තෙන්ම. stringසී / සී ++ විලාසිතාව වගේ. පොදු සම්මුතිය නම් ඔබ තෝරාගත් භාෂාව ලබා දී ඇති කෙටිමං භාවිතා කිරීමයි (int / Int for Int32). මෙය "වස්තුව" සඳහා ද decimalවේ.

න්‍යායාත්මකව මෙය "int" යන්නෙන් අදහස් විය හැකි අනාගත 64-බිට් ප්‍රමිතියකට කේත ගෙනයාමට උපකාරී වේ Int64, නමුත් එය එසේ නොවේ, තවද ඕනෑම යාවත්කාලීන විශාරදයක් වෙනස් වනු ඇතැයි මම අපේක්ෂා කරමිintInt32 ආරක්ෂිතව සිටීම සඳහා යොමු කිරීමක් .

සාදයට ප්‍රමාද වීම: මම සීඑල්ආර් වර්ග 100% ක්ම භාවිතා කරමි (හොඳයි, සී # වර්ගය භාවිතා කිරීමට බල කළහොත් හැර , නමුත් අවසන් වරට කවදාදැයි මට මතක නැත).

රිචීගේ සීඑල්ආර් පොත් වලට අනුව මම මුලින් ම මෙය ආරම්භ කළේ මීට වසර ගණනාවකට පෙර ය. සියලුම සීඑල්ආර් භාෂාවන්ට අවසානයේ සීඑල්ආර් වර්ග කට්ටලයට සහය දැක්විය යුතු බව මට හැඟී ගියේය, එබැවින් සීඑල්ආර් වර්ග භාවිතා කිරීමෙන් ඔබට වඩාත් පැහැදිලි සහ නැවත භාවිතා කළ හැකි කේතයක් ලබා දී ඇත.

දැන් මම වසර ගණනාවක් තිස්සේ එය කර ඇති අතර, එය පුරුද්දක් වන අතර සීඑල්ආර් වර්ග සඳහා වීඑස් පෙන්වන වර්ණකයට මම කැමතියි.

එකම සැබෑ පසුබෑම වන්නේ ස්වයංක්‍රීයව C # වර්ගය භාවිතා කිරීමයි, එබැවින් මම ස්වයංක්‍රීයව ජනනය කරන ලද වර්ග නැවත ටයිප් කිරීම වෙනුවට CLR වර්ගය නියම කරමි.

එසේම, දැන්, මම "int" හෝ "string" දකින විට, එය 1970 ගණන්වල C කේතය දෙස බලන්නාක් මෙන් මට ඇත්තෙන්ම වැරදිය.

වෙනසක් නැත.

C # යතුරුපදය string.NET වර්ගයට සිතියම් ගත කරයිSystem.String - එය භාෂාවේ නම් කිරීමේ සම්මුතීන්ට අනුකූල වන අන්වර්ථයකි.

ඒ හා සමානව, intසිතියම් System.Int32.

ඩැනියෙල් සොලිස්ගේ පොතෙන් මේ ප්‍රශ්නය පිළිබඳ උපුටා දැක්වීමක් තිබේ .

සියලුම පූර්ව නිශ්චිත වර්ග සෘජුවම යටින් පවතින .NET වර්ග වලට අනුරූපණය වේ. C # වර්ගයේ නම් (නූල්) යනු .NET වර්ග (String හෝ System.String) සඳහා අන්වර්ථ නාමයකි, එබැවින් .NET නම් භාවිතා කිරීම අධෛර්යමත් වුවද කෘතිමව ක්‍රියා කරයි. C # වැඩසටහනක් තුළ, ඔබ .NET නම් වලට වඩා C # නම් භාවිතා කළ යුතුය.

string යනු මූල පදයක් වන අතර, ඔබට හඳුනාගැනීමක් ලෙස string භාවිතා කළ නොහැක.

නූල් යනු මූල පදයක් නොවන අතර ඔබට එය හඳුනාගැනීමක් ලෙස භාවිතා කළ හැකිය:

උදාහරණයක්

string String = "I am a string";

මූල පදය පදය පසෙකට දැමීම string සඳහා අන්වර්ථයකි System.String, දෙක හරියටම සමාන වේ.

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

ඔව්, ඒ හුදෙක් මෙන් ඔවුන් අතර කිසි වෙනසක් නැහැ boolහා Boolean.

# ජරෙඩ්පාර් (සී # සම්පාදකයාගේ සංවර්ධකයා සහ බහුල SO පරිශීලකයා!) මෙම ගැටලුව පිළිබඳව විශිෂ්ට බ්ලොග් සටහනක් ලිවීය . මම හිතන්නේ එය මෙහි බෙදා ගැනීම වටී. එය අපගේ විෂය පිළිබඳ කදිම ඉදිරිදර්ශනයකි.

stringඑදිරිව Stringවිලාසිතාවේ විවාදයක් නොවේ

[...]

යතුරුපදයට stringC # හි සංයුක්ත අර්ථයක් ඇත. එය System.Stringමූලික ධාවන කාල එකලස් කිරීමේදී පවතින වර්ගයයි . ධාවන කාලය මෙම වර්ගය සහජයෙන්ම තේරුම් ගෙන ඇති අතර .NET හි නූල් සඳහා සංවර්ධකයින් අපේක්ෂා කරන හැකියාවන් සපයයි. එහි පැවැත්ම C # ට ඉතා වැදගත් වන අතර එම වර්ගය නොපවතින විට කේත රේඛාවක් විග්‍රහ කිරීමට උත්සාහ කිරීමට පෙර සම්පාදකයා පිටව යනු ඇත. එබැවින් stringC # කේතයේ නිරවද්‍ය, සැක සහිත අර්ථයක් ඇත.

හඳුනාගැනීමට StringC # හි නිශ්චිත අර්ථයක් නොමැත. එය සියලු නාමය බැලීම නීති හරහා යයි බව හඳුනාගැනීමේ වේ Widget, Studentඑය string බැඳීමට හෝ එය තවත් එකලස් සම්පූර්ණයෙන්ම සිය අරමුණු වඩා සම්පූර්ණයෙන්ම වෙනස් විය හැකිය දී වර්ගය බැඳීමට හැකි විය, ආදිය ... string. වඩාත් නරක ලෙස එය කේතය වැනි ආකාරයකින් අර්ථ දැක්විය හැකිය String s = "hello"; දිගටම සම්පාදනය කළා.

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;
}

එහි සැබෑ අරුත Stringසැමවිටම නම විභේදනය මත රඳා පවතී. එයින් අදහස් වන්නේ එය ව්‍යාපෘතියේ ඇති සියලුම ප්‍රභව ලිපිගොනු සහ සියලු යොමු කරන ලද එකලස් කිරීම් වල අර්ථ දක්වා ඇති සියලු වර්ග මත රඳා පවතී. කෙටියෙන් කිවහොත් එහි තේරුම දැන ගැනීමට තරමක් සන්දර්භය අවශ්‍ය වේ .

බහුතරයක් සිද්ධීන් සම්බන්ධයෙන් එම සැබෑ Stringහා stringඑකම වර්ගයේ බැඳීමට ඇත. Stringනිශ්චල ලෙස භාවිතා කිරීම යන්නෙන් අදහස් කරන්නේ සංවර්ධකයින් එක් නිවැරදි පිළිතුරක් ඇති ස්ථානවල අර්ථ නිරූපණය සඳහා තම වැඩසටහන අතහැර යන බවයි. විට Stringවැරදි වර්ගය බැඳීමට කරන්නේ එය සම්පාදකවරයා කණ්ඩායම දෝෂ ගොනු හා සාමාන්යයෙන් භාවිතා ගැලවීම කර තියෙනවා හැකි බව කාලය නාස්ති, පැය දෝෂහරණ සංවර්ධකයින් තැබිය හැක string.

වෙනස දෘශ්‍යමාන කිරීමට තවත් ක්‍රමයක් මෙම නියැදිය සමඟ ය:

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

බොහෝ අය තර්ක කරනුයේ මෙය තොරතුරු තාක්‍ෂණිකව නිවැරදිව භාවිතා Stringකිරීම තවමත් හොඳ බවය, මන්ද කේත පදනමක් මෙම නාමයේ වර්ගයක් නිර්වචනය කිරීම අතිශයින් දුර්ලභ බැවිනි. නැතහොත් Stringඑය අර්ථ දක්වා ඇති විට එය නරක කේත පදනමේ ලකුණකි.

[...]

Stringඑය සම්පූර්ණයෙන්ම වලංගු අරමුණු ගණනාවක් සඳහා අර්ථ දක්වා ඇති බව ඔබට පෙනෙනු ඇත: පරාවර්තන සහායකයින්, අනුක්‍රමිකකරණ පුස්තකාල, ලෙක්සර්, ප්‍රොටෝකෝල යනාදිය… මෙම ඕනෑම පුස්තකාලයකට Stringඑදිරිව. stringකේතය භාවිතා කරන ස්ථානය අනුව සැබෑ ප්‍රතිවිපාක ඇත.

එබැවින් Stringඑදිරිව එදිරිව stringවිවාදය දුටු විට මතක තබා ගන්න මෙය අර්ථ නිරූපණය ගැන මිස ශෛලිය ගැන නොවේ. නූල් තේරීම ඔබේ කේත පදනමට හොඳ අර්ථයක් ලබා දෙයි. තෝරා ගැනීම Stringවැරදියි නමුත් එය අනාගතයේදී විස්මයන් සඳහා දොර විවෘත කරයි.

සටහන: සංරක්ෂිත හේතුව නිසා මම බොහෝ බ්ලොග් පෝස්ට් පිටපත් / අලවා ඇත. මම සමහර කොටස් නොසලකා හරින අතර, ඔබට හැකි නම් බ්ලොග් පෝස්ට් මඟ හැරීමට මම නිර්දේශ කරමි .