വാക്യഘടന

രണ്ട് ഭാഷകളും സി പ്രോഗ്രാമിംഗ് ഭാഷ ഒരു വാക്യഘടനാ അടിസ്ഥാനമായി ഉപയോഗിക്കുന്നു, പ്രത്യേകിച്ചും, അവർ അതിൽ നിന്ന് മാറ്റങ്ങളില്ലാതെ പാരമ്പര്യമായി സ്വീകരിച്ചു:

• ചുരുണ്ട ബ്രേസുകളുള്ള ഒരു ബ്ലോക്ക് കോഡിന്റെ തുടക്കം/അവസാനം അടയാളപ്പെടുത്തുന്നു;
• ഒട്ടുമിക്ക ബിൽറ്റ്-ഇൻ പ്രവർത്തനങ്ങളുടെയും (അസൈൻമെന്റ്, ഗണിതശാസ്ത്രം, ലോജിക്കൽ, ബിറ്റ്‌വൈസ്, ഇൻക്രിമെന്റ്/ഡിക്രിമെന്റ് ഓപ്പറേഷനുകൾ, ടെർനറി സോപാധിക ഓപ്പറേറ്റർ " ?: »);
• വേരിയബിളുകളും ഫംഗ്‌ഷനുകളും വിവരിക്കുന്നതിനും ഉപയോഗിക്കുന്നതിനുമുള്ള വാക്യഘടന (ഓർഡർ "ടൈപ്പ് നെയിം", മോഡിഫയറുകളുടെ ഉപയോഗം, ഫംഗ്‌ഷനുകൾക്കുള്ള നിർബന്ധിത പരാൻതീസിസ്, ഔപചാരിക പാരാമീറ്ററുകളുടെ വിവരണം);
• എല്ലാ പ്രധാന നിർമ്മാണങ്ങളുടെയും വാക്യഘടന: സോപാധിക ഓപ്പറേറ്റർ, ലൂപ്പുകൾ, മൾട്ടിപ്പിൾ സെലക്ഷൻ ഓപ്പറേറ്റർ;
• നടപടിക്രമങ്ങളുടെ അഭാവം (അവ ശൂന്യമായ തരത്തിലുള്ള പ്രവർത്തനങ്ങളാൽ മാറ്റിസ്ഥാപിക്കപ്പെടുന്നു);
• ബിൽറ്റ്-ഇൻ എലിമെന്ററി തരങ്ങളുടെ പേരുകൾ (ബൂൾ ഒഴികെ, ജാവയിൽ ഈ തരത്തെ ബൂളിയൻ എന്ന് വിളിക്കുന്നു);
• ഒരു അർദ്ധവിരാമം ഉപയോഗിക്കുന്നു
• ... കൂടാതെ നിരവധി ചെറിയ സവിശേഷതകളും.

ഇതെല്ലാം ഒറ്റനോട്ടത്തിൽ ജാവയിലെയും സി # ലെയും പ്രോഗ്രാമുകൾ സി പ്രോഗ്രാമുകളുമായി വളരെ സാമ്യമുള്ളതാണ് എന്ന വസ്തുതയിലേക്ക് നയിക്കുന്നു. രണ്ട് ഭാഷകളും സി (അല്ലെങ്കിൽ C++) ലേക്ക് സമാനമായ വിപുലീകരണങ്ങളും കൂട്ടിച്ചേർക്കലുകളും നടത്തിയിട്ടുണ്ട്, പ്രത്യേകിച്ചും, അക്ഷരമാല വിപുലീകരിച്ചു, പാക്കേജുകൾ, വിവരണങ്ങൾ ഇറക്കുമതി ചെയ്യൽ, കംപൈലേഷൻ യൂണിറ്റുകൾ നിർവചിക്കൽ എന്നിവയെ പിന്തുണയ്ക്കുന്ന സ്വന്തം വാക്യഘടന അവതരിപ്പിച്ചു.

വാക്യഘടനയിലും ധാരാളം വ്യത്യാസങ്ങളുണ്ട്.

വാക്യഘടന	ജാവ	C#
സ്റ്റാറ്റിക് പേരുകൾ ഇറക്കുമതി ചെയ്യുന്നു (ഇറക്കുമതി സ്റ്റാറ്റിക്)	ഒരു ക്ലാസിലെ ചില അല്ലെങ്കിൽ എല്ലാ സ്റ്റാറ്റിക് രീതികളും വേരിയബിളുകളും വെവ്വേറെ ഇറക്കുമതി ചെയ്യാനും ഇറക്കുമതി മൊഡ്യൂളിൽ യോഗ്യതയില്ലാതെ അവയുടെ പേരുകൾ ഉപയോഗിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു.	അസംബ്ലി മാത്രമേ ഇറക്കുമതി ചെയ്തിട്ടുള്ളൂ, ഓരോ തവണയും നിങ്ങൾ ഇറക്കുമതി ചെയ്ത സ്റ്റാറ്റിക് പേരുകൾ ഉപയോഗിക്കുമ്പോൾ ക്ലാസ് വ്യക്തമാക്കണം
സ്ഥിരാങ്കങ്ങൾ സ്വിച്ച് സ്റ്റേറ്റ്മെന്റ്	ഒന്നുകിൽ ഒരു പൂർണ്ണസംഖ്യയോ ഒരു enum തരമോ ആയിരിക്കണം (1.7-ൽ, സ്ട്രിംഗ് ലിറ്ററലുകൾ തരങ്ങളുടെ പട്ടികയിൽ ചേർത്തു)	നിങ്ങൾക്ക് ടെക്സ്റ്റ് സ്ട്രിംഗുകൾ ഉപയോഗിക്കാം
goto ഓപ്പറേറ്റർ	അവർ ഗോട്ടോയുടെ ഉപയോഗം മനപ്പൂർവ്വം ഉപേക്ഷിച്ചു, എന്നിരുന്നാലും, ഒരു ലേബൽ ഉപയോഗിച്ച് അടയാളപ്പെടുത്തുകയും ബ്രേക്ക് ഉപയോഗിക്കുകയും ലേബലിനൊപ്പം ഓപ്പറേറ്റർമാരെ തുടരുകയും ചെയ്തുകൊണ്ട് നെസ്റ്റഡ് ചെയ്തതിൽ നിന്ന് പുറത്തെ ലൂപ്പിലേക്ക് പുറത്തുകടക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു സംവിധാനമുണ്ട് (തുടരുക<метка>;)	goto അതിജീവിച്ചു, ഒരു സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിലെ വ്യത്യസ്‌ത കേസ് ലേബലുകളിലേക്ക് നിയന്ത്രണം കടത്തിവിട്ട് ഒരു നെസ്റ്റഡ് ലൂപ്പിൽ നിന്ന് പുറത്തുകടക്കുക എന്നതാണ് അതിന്റെ പൊതുവായ ഉപയോഗം
സ്ഥിരാങ്കങ്ങൾ	അത്തരത്തിലുള്ള സ്ഥിരാങ്കങ്ങളൊന്നുമില്ല; പകരം, ഫൈനൽ മോഡിഫയറുള്ള സ്റ്റാറ്റിക് ക്ലാസ് വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു - അവയുടെ ഉപയോഗത്തിന്റെ ഫലം തികച്ചും സമാനമാണ്.	ടൈപ്പ് ചെയ്ത കോൺസ്റ്റന്റിന്റെയും കോൺസ്റ്റ് കീവേഡിന്റെയും പ്രത്യേക ആശയം
ഫ്ലോട്ടിംഗ് പോയിന്റ് കൃത്യത	എല്ലാ പ്ലാറ്റ്‌ഫോമുകളിലും ഒരേ ഫ്ലോട്ടിംഗ് പോയിന്റ് ഫലങ്ങൾ ഉറപ്പുനൽകുന്ന ഒരു സ്‌ട്രിക്റ്റ്‌എഫ്‌പി നിർമ്മാണം ജാവയിൽ ഉൾപ്പെടുന്നു.	സി# നടപ്പിലാക്കുന്നതിൽ ആശ്രയിക്കുന്നു; കൃത്യമായ കണക്കുകൂട്ടൽ ഫലങ്ങൾക്ക് ഒരു ഗ്യാരണ്ടിയുമില്ല.
പരിശോധനകൾ പ്രവർത്തനരഹിതമാക്കുന്നു	ജാവയിൽ, എല്ലാ ഡൈനാമിക് പരിശോധനകളും പാക്കേജ് തലത്തിൽ മാത്രമേ പ്രവർത്തനക്ഷമമാക്കൂ/പ്രവർത്തനരഹിതമാക്കൂ	പ്രാദേശികമായി ഡൈനാമിക് അരിത്മെറ്റിക് ഓവർഫ്ലോ ചെക്കിംഗ് പ്രവർത്തനക്ഷമമാക്കാനോ പ്രവർത്തനരഹിതമാക്കാനോ നിങ്ങളെ അനുവദിക്കുന്ന ചെക്ക് ചെയ്തതും അൺചെക്ക് ചെയ്യാത്തതുമായ നിർമ്മാണങ്ങൾ C#-ൽ അടങ്ങിയിരിക്കുന്നു.

പൊതുവേ, C# ന്റെ വാക്യഘടന ജാവയേക്കാൾ കൂടുതൽ വിപുലവും സമ്പന്നവുമാണ്; പ്രത്യേകിച്ചും, ഒരു ക്ലാസിന്റെ വിവരണം നിരവധി മൊഡ്യൂളുകളായി വിഭജിക്കാനുള്ള കഴിവ്, പ്രോപ്പർട്ടികളുടെ വിവരണം, വെർച്വാലിറ്റി നിയന്ത്രിക്കാനുള്ള കഴിവ് തുടങ്ങിയ സവിശേഷതകൾ ഇതിൽ അടങ്ങിയിരിക്കുന്നു. രീതികൾ.

ഡൈനാമിക് ഡാറ്റയും മാലിന്യ ശേഖരണവും ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നതിനുള്ള സംവിധാനം

ഡൈനാമിക് ഡാറ്റയുമായി പ്രവർത്തിക്കുന്നതിന് രണ്ട് ഭാഷകളും ഒരേ മാതൃകയാണ് നടപ്പിലാക്കുന്നത്: പുതിയ നിർമ്മാണം ഉപയോഗിച്ച് ഒബ്ജക്റ്റുകൾ ചലനാത്മകമായി സൃഷ്ടിക്കപ്പെടുന്നു, റൺടൈം അവയിലേക്കുള്ള റഫറൻസുകളുടെ സാന്നിധ്യം നിരീക്ഷിക്കുന്നു, കൂടാതെ റഫറൻസുകളില്ലാത്ത ഒബ്‌ജക്റ്റുകളുടെ മെമ്മറി കാലാകാലങ്ങളിൽ മാലിന്യ ശേഖരണം മായ്‌ക്കുന്നു. മാലിന്യ ശേഖരണം ഒപ്റ്റിമൈസ് ചെയ്യുന്നതിന്, ഭാഷകളുടെയും റൺടൈം പരിതസ്ഥിതികളുടെയും സവിശേഷതകളിൽ ഒരു വസ്തുവിന്റെ അവസാന പരാമർശം ഇല്ലാതാക്കിയതിന് ശേഷം അതിന്റെ ആയുസ്സിൽ നിയന്ത്രണങ്ങൾ അടങ്ങിയിട്ടില്ല - കളക്ടർ പ്രോഗ്രാമിന്റെ നിർവ്വഹണത്തിൽ നിന്ന് സ്വതന്ത്രമായി പ്രവർത്തിക്കുന്നു, അതിനാൽ യഥാർത്ഥ നാശം പ്രോഗ്രാം അവസാനിക്കുന്നതുവരെ അവസാന റഫറൻസ് ഇല്ലാതാക്കിയ ശേഷം ഏത് സമയത്തും ഒബ്ജക്റ്റ് സംഭവിക്കാം. വാസ്തവത്തിൽ, പ്രോഗ്രാം സ്ലോഡൗൺ കുറയ്ക്കുമ്പോൾ സ്വീകാര്യമായ മെമ്മറി ഉപഭോഗം ഉറപ്പാക്കാൻ മാലിന്യ ശേഖരണക്കാർ എക്സിക്യൂഷൻ ഒപ്റ്റിമൈസ് ചെയ്യുന്നു.

C# (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, പൊതുവായ ഭാഷാ റൺടൈം) എന്നതിനായുള്ള ഫൈനലൈസറിന്റെ എക്സിക്യൂഷൻ റദ്ദാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു ഈ വസ്തുവിന്റെരീതി GC.SuppressFinalize(obj) (ഉദാ: ഫയൽ സ്ട്രീമിലെ SQL കണക്ഷൻ). മാലിന്യ ശേഖരണത്തിൽ അന്തിമമാക്കൽ താരതമ്യേന ചെലവേറിയ പ്രവർത്തനമായി കണക്കാക്കപ്പെടുന്നതിനാൽ ഇത് ഉപയോഗപ്രദമാകും, കൂടാതെ ഒരു അന്തിമരൂപമുള്ള ഒരു വസ്തു കൂടുതൽ കാലം ജീവിക്കും.

ഒബ്ജക്റ്റ് ടൂളുകൾ

എനം തരങ്ങൾ

ജാവയിൽ, കർശനമായി പറഞ്ഞാൽ, ഏകമാന ശ്രേണികൾ മാത്രമേ പ്രഖ്യാപിക്കാൻ കഴിയൂ. ജാവയിലെ ഒരു മൾട്ടിഡൈമൻഷണൽ അറേ എന്നത് അറേകളുടെ ഒരു നിരയാണ്. C#-ന് യഥാർത്ഥ മൾട്ടിഡൈമൻഷണൽ അറേകളും അറേകളുടെ അറേകളും ഉണ്ട്, അവയെ C#-ൽ "ജാഗ്ഡ്" എന്ന് സാധാരണയായി വിളിക്കുന്നു. മൾട്ടിഡൈമൻഷണൽ അറേകൾ എല്ലായ്പ്പോഴും "ദീർഘചതുരാകൃതിയാണ്" (ദ്വിമാന പദാവലിയിൽ സംസാരിക്കുന്നു), അതേസമയം അറേകളുടെ അറേകൾക്ക് വ്യത്യസ്ത ദൈർഘ്യമുള്ള സ്ട്രിംഗുകൾ സംഭരിക്കാൻ കഴിയും (വീണ്ടും ദ്വിമാന കേസിൽ, അതുപോലെ തന്നെ മൾട്ടി-ഡൈമൻഷണൽ കേസിൽ). മൾട്ടിഡൈമൻഷണൽ അറേകൾ മെമ്മറി ആക്‌സസ് വേഗത്തിലാക്കുന്നു (ഇതിനായി പോയിന്റർ ഒരു തവണ മാത്രം ഒഴിവാക്കപ്പെടുന്നു), അതേസമയം ജാഗ്ഡ് അറേകൾ മന്ദഗതിയിലാണെങ്കിലും എല്ലാ വരികളും നിറയാത്തപ്പോൾ മെമ്മറി സംരക്ഷിക്കുന്നു. മൾട്ടിഡൈമൻഷണൽ അറേകൾ സൃഷ്ടിക്കാൻ ഒരു കോൾ മാത്രമേ ആവശ്യമുള്ളൂ ഓപ്പറേറ്റർ പുതിയത്, കൂടാതെ സ്തംഭിച്ചവയ്ക്ക് ഓരോ വരിയ്ക്കും ഒരു ലൂപ്പിൽ മെമ്മറി വ്യക്തമായി അനുവദിക്കേണ്ടതുണ്ട്.

പാരാമീറ്ററൈസ്ഡ് (ജനറിക്) തരങ്ങൾ

രണ്ട് ഭാഷകളിലും, തരങ്ങൾ പാരാമീറ്റർ ചെയ്യാവുന്നതാണ്, ഇത് ജനറിക് പ്രോഗ്രാമിംഗ് മാതൃകയെ പിന്തുണയ്ക്കുന്നു. വാക്യഘടനാപരമായി, തരങ്ങളുടെ നിർവചനം വളരെ അടുത്താണ് - രണ്ട് ഭാഷകളിലും ഇത് C++ ടെംപ്ലേറ്റുകളിൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നു, എന്നിരുന്നാലും ചില പരിഷ്കാരങ്ങളോടെയാണ്.

ജാവയിലെ ടൈപ്പ് ജനറിക്‌സ് പൂർണ്ണമായും ഒരു ഭാഷാ നിർമ്മാണമാണ്, അവ കംപൈലറിൽ മാത്രം നടപ്പിലാക്കുന്നു. കംപൈലർ എല്ലാ ജനറിക് തരങ്ങളെയും അവയുടെ മുകളിലെ അതിരുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുകയും ഒരു പരാമീറ്ററൈസ്ഡ് തരം ഉപയോഗിക്കുന്നിടത്തെല്ലാം ഉചിതമായ തരം കാസ്റ്റുകൾ ചേർക്കുകയും ചെയ്യുന്നു. ജനറിക് തരങ്ങളെയും അവയുടെ പാരാമീറ്ററുകളെയും കുറിച്ചുള്ള റഫറൻസുകൾ അടങ്ങിയിട്ടില്ലാത്ത ബൈറ്റ്കോഡാണ് ഫലം. ജനറിക് തരങ്ങൾ നടപ്പിലാക്കുന്നതിനുള്ള ഈ സാങ്കേതികതയെ വിളിക്കുന്നു തരം മായ്ക്കൽ(തരം മായ്ക്കൽ). ഇതിനർത്ഥം യഥാർത്ഥ ജനറിക് തരങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ റൺടൈമിൽ ലഭ്യമല്ല, കൂടാതെ ജനറിക് ടൈപ്പ് ആർഗ്യുമെന്റുകളിൽ നിന്ന് പുതിയ അറേ ഇൻസ്‌റ്റൻസുകൾ സൃഷ്‌ടിക്കാനുള്ള കഴിവില്ലായ്മ പോലുള്ള ചില പരിമിതികൾ ചുമത്തുന്നു. ബുധനാഴ്ച ജാവ എക്സിക്യൂഷൻജനറിക് ടൈപ്പ് സിസ്റ്റം എനിക്ക് പരിചിതമല്ല, അതുകൊണ്ടാണ് പുതിയ JVM നടപ്പിലാക്കലുകൾക്ക് പുതിയ ക്ലാസ് ഫോർമാറ്റിൽ പ്രവർത്തിക്കാൻ ഏറ്റവും കുറഞ്ഞ അപ്‌ഡേറ്റുകൾ ആവശ്യമായി വരുന്നത്.

C# മറ്റൊരു വഴിക്ക് പോയി. സാമാന്യതയ്ക്കുള്ള പിന്തുണ വെർച്വൽ റൺടൈമിലേക്ക് തന്നെ സംയോജിപ്പിച്ചു, ആദ്യം .NET 2.0-ൽ പ്രത്യക്ഷപ്പെട്ടു. പരിസ്ഥിതിയുടെ ഈ കഴിവുകൾ ആക്സസ് ചെയ്യുന്നതിനുള്ള ഒരു ബാഹ്യ ഇന്റർഫേസ് മാത്രമായി ഇവിടെ ഭാഷ മാറിയിരിക്കുന്നു. ജാവയിലെന്നപോലെ, കംപൈലർ സ്റ്റാറ്റിക് ടൈപ്പ് ചെക്കിംഗ് നടത്തുന്നു, എന്നാൽ ഇതിനുപുറമെ, JIT ലോഡ്-ടൈം കൃത്യത പരിശോധിക്കുന്നു. ജനറിക് തരങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങൾ റൺടൈമിൽ പൂർണ്ണമായി നിലവിലുണ്ട്, കൂടാതെ ജനറിക് തരങ്ങളുടെ പ്രതിഫലനത്തിനും അവയുടെ പുതിയ നിർവ്വഹണങ്ങൾ സൃഷ്ടിക്കുന്നതിനും പൂർണ്ണ പിന്തുണ അനുവദിക്കുന്നു.

ജാവ സമീപനം ആവശ്യമാണ് അധിക പരിശോധനകൾറൺടൈമിൽ, കോഡ് ക്ലയന്റ് ടൈപ്പ് കറസ്പോണ്ടൻസ് പിന്തുടരുമെന്ന് ഉറപ്പുനൽകുന്നില്ല, കൂടാതെ ജനറിക് തരങ്ങൾക്ക് പ്രതിഫലനം നൽകുന്നില്ല. ജെനറിക് തരങ്ങളെ പ്രാകൃത തരങ്ങളിലേക്ക് സ്പെഷ്യലൈസ് ചെയ്യാൻ ജാവ അനുവദിക്കുന്നില്ല (ക്ലാസുകളിൽ പ്രാകൃത തരങ്ങൾ പൊതിയുന്നതിലൂടെ മാത്രമേ ഇത് ചെയ്യാൻ കഴിയൂ), അതേസമയം സി# പ്രിമിറ്റീവുകൾ ഉൾപ്പെടെയുള്ള റഫറൻസ്, മൂല്യ തരങ്ങൾ എന്നിവയ്‌ക്ക് ജനറിക്‌സ് നൽകുന്നു. പകരം, പാരാമീറ്ററുകളായി പൊതിഞ്ഞ പ്രാകൃത തരങ്ങൾ ഉപയോഗിക്കാൻ ജാവ നിർദ്ദേശിക്കുന്നു (ഉദാ. ലിസ്റ്റ് ലിസ്റ്റിന് പകരം ), എന്നാൽ ഇത് അധിക വിഹിതത്തിന്റെ ചിലവിൽ വരുന്നു ഡൈനാമിക് മെമ്മറി. Java, C# എന്നിവയിൽ, വ്യത്യസ്ത റഫറൻസ് തരങ്ങളിലെ ജനറിക് തരം സ്പെഷ്യലൈസേഷനുകൾ ഒരേ കോഡ് നിർമ്മിക്കുന്നു, എന്നാൽ C#-ൽ, മൂല്യ തരങ്ങളിൽ സ്പെഷ്യലൈസ് ചെയ്യുമ്പോൾ റൺടൈം ചലനാത്മകമായി ഒപ്റ്റിമൈസ് ചെയ്ത കോഡ് സൃഷ്ടിക്കുന്നു (ഉദാഹരണത്തിന്, ലിസ്റ്റ് ), ലോഡ് ചെയ്യാതെയും അൺറോൾ ചെയ്യാതെയും കണ്ടെയ്‌നറുകളിൽ നിന്ന് അവയെ സംഭരിക്കാനും നീക്കം ചെയ്യാനും അനുവദിക്കുന്നു.

ഇവന്റ് കൈകാര്യം ചെയ്യൽ

ജാവയ്ക്ക് നിരീക്ഷക പാറ്റേൺ സ്വമേധയാ നടപ്പിലാക്കാൻ പ്രോഗ്രാമർ ആവശ്യപ്പെടുന്നു, എന്നിരുന്നാലും ഇത് അജ്ഞാത നെസ്റ്റഡ് ക്ലാസുകളുടെ രൂപത്തിൽ കുറച്ച് വാക്യഘടന പഞ്ചസാര നൽകുന്നു, ഇത് ഒരു ക്ലാസിന്റെ ബോഡി നിർവചിക്കാനും കോഡിലെ ഒരൊറ്റ പോയിന്റിൽ അത് ഉടനടി തൽക്ഷണം ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്നു.

.NET ഡെലിഗേറ്റുകൾ, മൾട്ടികാസ്റ്റിംഗ്, ക്ലാസുകളിൽ ഇവന്റുകൾ സജ്ജീകരിക്കുന്നതിനുള്ള പ്രത്യേക വാക്യഘടന, ഇവന്റ് ഹാൻഡ്‌ലറുകൾ രജിസ്റ്റർ ചെയ്യുന്നതിനും അൺരജിസ്റ്റർ ചെയ്യുന്നതിനുമുള്ള പ്രവർത്തനങ്ങൾ, ഡെലിഗേറ്റ് കോവേരിയൻസ്, കൂടാതെ അജ്ഞാത രീതികൾ എന്നിവയുൾപ്പെടെ ഇവന്റ് പ്രോഗ്രാമിംഗിന് സി# വിപുലമായ ഭാഷാ-തല പിന്തുണ നൽകുന്നു. മുഴുവൻ സെറ്റ്ക്ലോഷർ സെമാന്റിക്സ്.

Java SE 8-ൽ ഉൾപ്പെടുത്തുന്നതിനായി അടച്ചുപൂട്ടലുകൾ നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു. C#-ലെ ഡെലിഗേറ്റുകൾ പോലെയുള്ള ഈ അടച്ചുപൂട്ടലുകൾക്ക്, അന്തിമമായി അടയാളപ്പെടുത്തിയിരിക്കുന്ന വേരിയബിളുകളിലേക്കുള്ള റീഡ് ആക്‌സസ് (അജ്ഞാത നെസ്റ്റഡ് ക്ലാസുകൾ പോലെ) എന്നതിലുപരി, നൽകിയിരിക്കുന്ന സ്കോപ്പിലെ എല്ലാ പ്രാദേശിക വേരിയബിളുകളിലേക്കും പൂർണ്ണ ആക്‌സസ് ഉണ്ടായിരിക്കും.

ഓപ്പറേഷൻ ഓവർലോഡ്

പ്രോപ്പർട്ടികൾ

C# "പ്രോപ്പർട്ടികൾ" എന്ന ആശയത്തെ പിന്തുണയ്ക്കുന്നു - ഫീൽഡിന്റെ മൂല്യം വീണ്ടെടുക്കുന്നതിനും എഴുതുന്നതിനുമുള്ള രീതികൾ സൃഷ്‌ടിച്ച് പൂർണ്ണമായും നിയന്ത്രിത രീതിയിൽ ആക്‌സസ് ചെയ്യപ്പെടുന്ന ഒരു ക്ലാസിന്റെ വ്യാജ ഫീൽഡുകൾ. ഗെറ്റ് ആൻഡ് സെറ്റ് കൺസ്ട്രക്‌റ്റുകൾ ഉപയോഗിച്ചാണ് പ്രോപ്പർട്ടി ഡിക്ലറേഷൻ നടത്തുന്നത്.

C# എന്നതും ഉൾപ്പെടുന്നു സൂചികകൾ, ഓപ്പറേറ്റർ ഓവർലോഡിംഗ് (C++ ലെ ഓപ്പറേറ്റർ ഓവർലോഡിംഗ് പോലെ) അല്ലെങ്കിൽ പാരാമീറ്റർ ചെയ്ത പ്രോപ്പർട്ടികളുടെ ഒരു പ്രത്യേക കേസ് ആയി കണക്കാക്കാം. ഒന്നോ അതിലധികമോ പാരാമീറ്ററുകൾ (ഇൻഡക്‌സുകൾ) ഉണ്ടായിരിക്കാവുന്ന ഒരു പ്രോപ്പർട്ടിയാണ് ഇൻഡക്‌സർ, കൂടാതെ സൂചികകൾ ഏത് തരത്തിലും ആകാം. അറേകൾ പോലെ പെരുമാറുന്ന ക്ലാസുകൾ സൃഷ്ടിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു:

MyList[ 4 ] = 5 ; സ്ട്രിംഗിന്റെ പേര് = xmlNode. ആട്രിബ്യൂട്ടുകൾ ["പേര്"]; ഓർഡറുകൾ = ഉപഭോക്തൃമാപ്പ്[കസ്റ്റമർ] ;

ചില പ്രശസ്ത പ്രോഗ്രാമർമാർ പ്രോപ്പർട്ടികളുടെ ഉപയോഗം നിരസിക്കുന്നു. പ്രത്യേകിച്ചും, ജെഫ്രി റിക്ടർ എഴുതുന്നു:

“വ്യക്തിപരമായി, എനിക്ക് പ്രോപ്പർട്ടികൾ ഇഷ്ടമല്ല, Microsoft .NET ഫ്രെയിംവർക്കിൽ നിന്നും അനുബന്ധ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്നും അവയ്ക്കുള്ള പിന്തുണ നീക്കം ചെയ്യുന്നതിൽ സന്തോഷമുണ്ട്. കാരണം, പ്രോപ്പർട്ടികൾ ഫീൽഡുകൾ പോലെ കാണപ്പെടുന്നു, പക്ഷേ യഥാർത്ഥത്തിൽ രീതികളാണ്."

സാധാരണ C# നാമകരണ ശൈലി പിന്തുടർന്ന്, വസ്‌തുനാമങ്ങൾ ഫീൽഡ് നാമങ്ങളിൽ നിന്ന് ദൃശ്യപരമായി വേർതിരിച്ചിരിക്കുന്നു, അവ ഒരു വലിയ അക്ഷരത്തിൽ ആരംഭിക്കുന്നു.

സോപാധിക സമാഹാരം

C#, ജാവയിൽ നിന്ന് വ്യത്യസ്തമായി, പ്രീപ്രൊസസ്സർ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് സോപാധികമായ സമാഹാരത്തെ പിന്തുണയ്ക്കുന്നു. ഇതിന് ഒരു സോപാധിക ആട്രിബ്യൂട്ടും ഉണ്ട്, അതായത് നൽകിയിരിക്കുന്ന കംപൈലേഷൻ സ്ഥിരാങ്കം നിർവചിക്കുമ്പോൾ മാത്രമേ നിർദ്ദിഷ്ട രീതിയെ വിളിക്കൂ എന്നാണ്. ഈ രീതിയിൽ, നിങ്ങൾക്ക് കോഡിലേക്ക് തിരുകാൻ കഴിയും, ഉദാഹരണത്തിന്, സ്ഥിരീകരണ പരിശോധനകൾ, ഡീബഗ് സ്ഥിരാങ്കം നിർവചിക്കുമ്പോൾ മാത്രം ഡീബഗ് പതിപ്പിൽ പ്രവർത്തിക്കും. .NET സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ, ഇതാണ് Debug.Assert() രീതി.

ജാവ പതിപ്പുകൾ 1.4-ഉം പിന്നീടുള്ള പതിപ്പുകളും ഭാഷയിൽ ഒരു റൺ-ടൈം അനുമാന പരിശോധന സവിശേഷത ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. കൂടാതെ, സ്ഥിരമായ വ്യവസ്ഥകളുള്ള നിർമ്മാണങ്ങൾ കംപൈൽ സമയത്ത് വികസിപ്പിക്കാൻ കഴിയുമെങ്കിൽ. ജാവയ്‌ക്കായി പ്രീപ്രോസസറുകളുടെ മൂന്നാം കക്ഷി നടപ്പിലാക്കലുകൾ ഉണ്ട്, മൊബൈൽ ഉപകരണങ്ങൾക്കായി ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുമ്പോൾ അവ പ്രാഥമികമായി ഉപയോഗിക്കുന്നു.

നെയിംസ്പേസുകൾ, അസംബ്ലികൾ, പാക്കേജുകൾ

C# ഉപയോഗിക്കുന്നു നാമമേഖലകൾ(നെയിംസ്പേസ്), അതേ പേരിലുള്ള C++ മെക്കാനിസത്തെ അനുസ്മരിപ്പിക്കുന്നു. ഓരോ ക്ലാസും ഒരു നെയിംസ്‌പെയ്‌സിന്റേതാണ്; നെയിംസ്‌പെയ്‌സ് വ്യക്തമായി വ്യക്തമാക്കിയിട്ടില്ലാത്ത ക്ലാസുകൾ സ്ഥിരസ്ഥിതിയായി പേരില്ലാത്ത നെയിംസ്‌പെയ്‌സിൽ പെട്ടതാണ്. നെയിംസ്‌പെയ്‌സുകൾ പരസ്പരം കൂടുകൂട്ടാം.

ജാവയ്ക്ക് ഉണ്ട് പാക്കേജുകൾ, C# നെയിംസ്‌പെയ്‌സുകളോട് സാമ്യമുണ്ട്. പാക്കേജുകൾ നെസ്റ്റഡ് ചെയ്യാം, വിവരിച്ചിരിക്കുന്ന ഓരോ ക്ലാസും ഒരു നിശ്ചിത പാക്കേജിലേതാണ്; പാക്കേജിന്റെ വ്യക്തമായ സൂചനയുടെ അഭാവത്തിൽ, ക്ലാസ് ഒരു ആഗോള പേരിടാത്ത പാക്കേജിന്റേതാണ്.

രണ്ട് ഭാഷകളിലും, മറ്റൊരു നെയിംസ്‌പെയ്‌സിലോ പാക്കേജിലോ പ്രഖ്യാപിച്ച ഒരു ഒബ്‌ജക്റ്റ് ആക്‌സസ് ചെയ്യുന്നതിന്, പ്രോഗ്രാമിലെ ആവശ്യമായ പാക്കേജ് (നെയിംസ്‌പെയ്‌സ്) നിങ്ങൾ ഉപയോഗിക്കുന്നതായി പ്രഖ്യാപിക്കണം. യോഗ്യതയുള്ള ഒരു നാമത്തിലൂടെയാണ് ഒരു ഒബ്ജക്റ്റ് ആക്സസ് ചെയ്യുന്നത്; പാക്കേജിന്റെ പേര് (നെയിംസ്പേസ്) ഒരു യോഗ്യതയായി ഉപയോഗിക്കുന്നു. നിങ്ങൾക്ക് യോഗ്യതയില്ലാത്ത ഒരു വസ്തുവിനെ ബന്ധപ്പെടണമെങ്കിൽ, സോഫ്റ്റ്വെയർ മൊഡ്യൂൾഒരു dereference നിർദ്ദേശം ഉണ്ടായിരിക്കണം: C#-ൽ ഉപയോഗിക്കുകയും ജാവയിൽ ഇറക്കുമതി ചെയ്യുകയും ചെയ്യുക.

C#-ൽ, കംപൈൽ ചെയ്‌ത മൊഡ്യൂളുകളുമായി (അസംബ്ലികൾ, അല്ലെങ്കിൽ മൈക്രോസോഫ്റ്റ് ടെർമിനോളജിയിലെ അസംബ്ലി) നെയിംസ്‌പെയ്‌സുകൾ ഒരു തരത്തിലും ബന്ധപ്പെടുത്തിയിട്ടില്ല. ഒന്നിലധികം അസംബ്ലികളിൽ ഒരേ നെയിംസ്‌പെയ്‌സ് അടങ്ങിയിരിക്കാം, കൂടാതെ ഒരു അസംബ്ലിക്ക് ഒന്നിലധികം നെയിംസ്‌പെയ്‌സുകൾ പ്രഖ്യാപിക്കാനാകും, നെസ്റ്റഡ് ആയിരിക്കണമെന്നില്ല. C# സ്കോപ്പ് മോഡിഫയറുകൾക്ക് നെയിംസ്പേസുകളുമായി യാതൊരു ബന്ധവുമില്ല. ജാവയിൽ, ഒരേ പാക്കേജിൽ ഡിഫോൾട്ടായി ഡിക്ലെയർ ചെയ്യുന്ന ക്ലാസുകൾ ഒരു കംപൈൽ ചെയ്ത മൊഡ്യൂളായി മാറുന്നു. ഡിഫോൾട്ട് സ്കോപ്പ് മോഡിഫയർ (വ്യക്തമായ സ്പെസിഫിക്കേഷൻ ഇല്ല) ഒരു ക്ലാസിന്റെ ഫീൽഡുകളുടെയും രീതികളുടെയും വ്യാപ്തി പാക്കേജിന്റെ അതിരുകളിലേക്ക് പരിമിതപ്പെടുത്തുന്നു.

ജാവയിൽ, ഒരു പാക്കേജിന്റെ സോഴ്‌സ് കോഡിന്റെ ഫയലുകളുടെയും ഡയറക്ടറികളുടെയും ഘടന സ്ഥിരസ്ഥിതിയായി പാക്കേജിന്റെ ഘടനയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു - ഒരു പാക്കേജ് ഒരു ഡയറക്ടറിയുമായി യോജിക്കുന്നു, അതിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഉപപാക്കേജുകൾ - ഈ ഡയറക്ടറിയുടെ ഉപഡയറക്‌ടറികൾ, ഉറവിട ഫയലുകൾ ഡയറക്ടറികളിൽ സ്ഥിതിചെയ്യുന്നു. അവ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പാക്കേജ് അല്ലെങ്കിൽ ഉപപാക്കേജുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു. അങ്ങനെ, ഉറവിട വൃക്ഷം പാക്കേജിന്റെ ഘടനയെ പിന്തുടരുന്നു. C#-ൽ, ഒരു സോഴ്സ് ഫയലിന്റെ സ്ഥാനത്തിന് അതിന്റെ നെയിംസ്പേസുമായി യാതൊരു ബന്ധവുമില്ല.

ഫയലുകളിലെ സോഴ്സ് ടെക്സ്റ്റിന്റെ സ്ഥാനം

C#-ൽ, ക്ലാസുകൾ ഏതു വിധത്തിലും ഫയലുകളിൽ സ്ഥിതിചെയ്യാം. സോഴ്സ് കോഡ് ഫയലിന്റെ പേരിന് അതിൽ നിർവചിച്ചിരിക്കുന്ന ക്ലാസുകളുടെ പേരുകളുമായി യാതൊരു ബന്ധവുമില്ല. ഒരു ഫയലിൽ നിരവധി പൊതു ക്ലാസുകൾ സ്ഥാപിക്കാൻ ഇത് അനുവദിച്ചിരിക്കുന്നു. പതിപ്പ് 2.0 മുതൽ, ഒരു ക്ലാസ് രണ്ടോ അതിലധികമോ ഫയലുകളായി (ഭാഗിക കീവേഡ്) വിഭജിക്കാൻ C# നിങ്ങളെ അനുവദിക്കുന്നു. അവസാന ഫീച്ചർ വിഷ്വൽ ഇന്റർഫേസ് ബിൽഡിംഗ് ടൂളുകൾ സജീവമായി ഉപയോഗിക്കുന്നു: ഇന്റർഫേസ് ഡിസൈനർ നിയന്ത്രിക്കുന്ന ഫീൽഡുകളും രീതികളും ഉൾക്കൊള്ളുന്ന ക്ലാസിന്റെ ഭാഗം ഒരു പ്രത്യേക ഫയലായി വേർതിരിക്കപ്പെടുന്നു, അതിനാൽ പ്രോഗ്രാമർ നേരിട്ട് എഡിറ്റ് ചെയ്ത ഫയൽ സ്വയമേവ ജനറേറ്റ് ചെയ്ത കോഡ് ഉപയോഗിച്ച് അലങ്കോലപ്പെടുത്തരുത്. .

ജാവയിൽ, ഓരോ ഫയലിലും ഒരു പൊതു ക്ലാസ് മാത്രമേ ഉൾക്കൊള്ളാൻ കഴിയൂ, ഫയലിന്റെയും ക്ലാസ്സിന്റെയും പേരുകൾ തമ്മിലുള്ള ആശയക്കുഴപ്പം ഇല്ലാതാക്കിക്കൊണ്ട്, ഫയലിന്റെ പേര് ആ ക്ലാസിന്റെ പേരിന് തുല്യമായിരിക്കണമെന്ന് Java ആവശ്യപ്പെടുന്നു. കൂടാതെ, സൺ ശുപാർശ ചെയ്യുന്ന കോഡിംഗ് കൺവെൻഷൻ അനുസരിച്ച്, ഒരു സോഴ്സ് കോഡ് ഫയലിന്റെ വലുപ്പം 2000 ലൈനുകളിൽ കവിയാൻ പാടില്ല, കാരണം ഒരു വലിയ ഫയൽ പാഴ്സ് ചെയ്യാൻ കൂടുതൽ ബുദ്ധിമുട്ടാണ്. വലിയ വലിപ്പംമോശം ഡിസൈൻ തീരുമാനത്തിന്റെ അടയാളമായും ഫയൽ കണക്കാക്കപ്പെടുന്നു.

ഒഴിവാക്കലുകൾ

രണ്ട് ഭാഷകളും ഒരു ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ സംവിധാനത്തെ പിന്തുണയ്ക്കുന്നു, വാക്യഘടനാപരമായി ഒരേ രീതിയിൽ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു: ഭാഷയ്ക്ക് ഒരു അപവാദ ജനറേഷൻ ഓപ്പറേറ്റർ ഉണ്ട് എറിയുകകൂടാതെ ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യൽ ബ്ലോക്കും ശ്രമിക്കുക()പിടിക്കുക()()അവസാനം(), ഒരു ബ്ലോക്കിനുള്ളിൽ സംഭവിക്കുന്ന ഒഴിവാക്കലുകളുടെ തടസ്സം, അവയുടെ പ്രോസസ്സിംഗ്, അന്തിമ പ്രവർത്തനങ്ങളുടെ ഗ്യാരണ്ടീഡ് എക്സിക്യൂഷൻ എന്നിവ ഉറപ്പാക്കുന്നു.

പരിശോധിച്ച ഒഴിവാക്കലുകളെ Java പിന്തുണയ്ക്കുന്നു: ഓരോ രീതിക്കും പ്രോഗ്രാമർ, മെത്തേഡ് എറിയാൻ കഴിയുന്ന ഒഴിവാക്കലുകളുടെ തരങ്ങൾ വ്യക്തമായി വ്യക്തമാക്കണം, ഈ തരങ്ങൾ ത്രോസ് കീവേഡിന് ശേഷമുള്ള രീതി പ്രഖ്യാപനത്തിൽ ലിസ്റ്റ് ചെയ്തിരിക്കുന്നു. പരിശോധിച്ച ഒഴിവാക്കലുകൾ എറിയുന്ന രീതികളാണ് ഒരു രീതി ഉപയോഗിക്കുന്നതെങ്കിൽ, അത് ഒന്നുകിൽ ആ ഒഴിവാക്കലുകൾ എല്ലാം വ്യക്തമായി പിടിക്കണം അല്ലെങ്കിൽ അവയിൽ അടങ്ങിയിരിക്കണം സ്വന്തം വിവരണം. അതിനാൽ, ഓരോ രീതിയിലും എറിയാൻ കഴിയുന്ന ഒഴിവാക്കലുകളുടെ ഒരു ലിസ്റ്റ് കോഡിൽ വ്യക്തമായി അടങ്ങിയിരിക്കുന്നു. ഒഴിവാക്കൽ തരങ്ങളുടെ ശ്രേണിയിൽ രണ്ട് തരങ്ങളും (റൺടൈം എക്‌സെപ്ഷൻ, പിശക്) അടങ്ങിയിരിക്കുന്നു, അവയുടെ പിൻഗാമികൾ പരിശോധിച്ചിട്ടില്ല, വിവരിക്കാൻ പാടില്ല. എവിടെയും സംഭവിക്കാവുന്ന അല്ലെങ്കിൽ പ്രോഗ്രാമർ (റൺടൈം പിശകുകൾ പോലുള്ളവ) സാധാരണയായി കൈകാര്യം ചെയ്യാൻ കഴിയാത്ത റൺടൈം ഒഴിവാക്കലുകൾക്കായി അവ സംവരണം ചെയ്തിരിക്കുന്നു, കൂടാതെ ഒരു ത്രോസ് ഡിക്ലറേഷനിൽ വ്യക്തമാക്കാൻ പാടില്ല.

C# പരിശോധിച്ച ഒഴിവാക്കലുകൾ പിന്തുണയ്ക്കുന്നില്ല. അവരുടെ അഭാവം ഡെവലപ്പർമാരുടെ ബോധപൂർവമായ തിരഞ്ഞെടുപ്പാണ്. C# ന്റെ മുഖ്യ വാസ്തുശില്പിയായ ആൻഡേഴ്‌സ് ഹെജൽസ്ബെർഗ്, ജാവയിൽ ഒരു പരിധിവരെ അവർ ഒരു പരീക്ഷണമായിരുന്നുവെന്നും തങ്ങളെ ന്യായീകരിക്കുന്നില്ലെന്നും വിശ്വസിക്കുന്നു.

സമാന്തര പ്രോഗ്രാമിംഗ്

പൊതുവേ, C#-ലെ സമാന്തര പ്രോഗ്രാമിംഗ് മെക്കാനിസങ്ങൾ ജാവ നൽകിയതിന് സമാനമാണ്, വ്യത്യാസം നടപ്പിലാക്കൽ വിശദാംശങ്ങളിലാണ്. രണ്ട് സാഹചര്യങ്ങളിലും, "ത്രെഡ്" എന്ന ആശയം നടപ്പിലാക്കുന്ന ഒരു ലൈബ്രറി ക്ലാസ് ത്രെഡ് ഉണ്ട്. നിങ്ങളുടെ സ്വന്തം ത്രെഡുകൾ സൃഷ്‌ടിക്കുന്നതിന് ജാവ രണ്ട് വഴികൾ നൽകുന്നു: ഒന്നുകിൽ ത്രെഡ് ക്ലാസ് വിപുലീകരിക്കുക അല്ലെങ്കിൽ റണ്ണബിൾ ഇന്റർഫേസ് നടപ്പിലാക്കുക. രണ്ട് സാഹചര്യങ്ങളിലും, പ്രോഗ്രാമർ ത്രെഡിന്റെ ബോഡി ഉൾക്കൊള്ളുന്ന ഒരു ഇൻഹെറിറ്റഡ് (ഇന്റർഫേസിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന) രീതി റൺ() നിർവ്വചിക്കണം - അതിൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന കോഡ്. പകരം C# ഡെലിഗേറ്റ് മെക്കാനിസം ഉപയോഗിക്കുന്നു: ഒരു ത്രെഡ് സൃഷ്‌ടിക്കുന്നതിന്, സ്റ്റാൻഡേർഡ് ത്രെഡ് ക്ലാസിന്റെ ഒരു ഉദാഹരണം സൃഷ്‌ടിക്കുന്നു, അതിലേക്ക് ഒരു രീതി അടങ്ങുന്ന ഒരു ഡെലിഗേറ്റ് - ത്രെഡിന്റെ ബോഡി - ഒരു കൺസ്ട്രക്റ്റർ പാരാമീറ്ററായി കൈമാറുന്നു.

രണ്ട് ഭാഷകൾക്കും സമകാലികമായി നടപ്പിലാക്കിയ കോഡിന്റെ ഒരു ബ്ലോക്ക് സൃഷ്ടിക്കാനുള്ള കഴിവുണ്ട്; ജാവയിൽ ഇത് സിൻക്രൊണൈസ്ഡ്() ഓപ്പറേറ്റർ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്, സി#-ൽ - ലോക്ക്() ഓപ്പറേറ്റർ ഉപയോഗിച്ച്. രീതി ഡിക്ലറേഷൻ ഹെഡറിലെ സമന്വയിപ്പിച്ച മോഡിഫയർ ഉപയോഗിച്ച് സിൻക്രണസ് രീതികൾ പ്രഖ്യാപിക്കാനും ജാവ നിങ്ങളെ അനുവദിക്കുന്നു. അത്തരം രീതികൾ, എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ, അവരുടെ ഉടമസ്ഥതയിലുള്ള ഒബ്ജക്റ്റ് തടയുക (അങ്ങനെ, ക്ലാസിലെ സമന്വയിപ്പിച്ച രീതികളിൽ, ഒരേ ഉദാഹരണത്തിൽ, ഒരു സമയത്ത് ഒന്ന് മാത്രമേ എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയൂ, ബാക്കിയുള്ളവ കാത്തിരിക്കും). .NET-ൽ സമാനമായ ഒരു ഫീച്ചർ നൽകുന്നത് MethodImplAttribute MethodImplOptions ആണ്. സമന്വയിപ്പിച്ച രീതി നടപ്പിലാക്കൽ ആട്രിബ്യൂട്ട്, എന്നാൽ ജാവയിൽ നിന്ന് വ്യത്യസ്തമായി, ഈ സവിശേഷത ഔദ്യോഗികമായി C# ഭാഷയുടെ ഭാഗമല്ല.

ഒരു ത്രെഡിൽ നിന്ന് മറ്റൊന്നിലേക്ക് ഒരു സിഗ്നൽ അയയ്‌ക്കുന്നതിനും കാത്തിരിക്കുന്നതിനും അടിസ്ഥാനമാക്കി രണ്ട് ഭാഷകളും ഒരേ സമന്വയ സൗകര്യങ്ങൾ നൽകുന്നു. ജാവയിൽ ഇവ notify(), notifyAll(), wait() എന്നീ രീതികളാണ്, C#-ൽ ഇവ Pulse(), PulseAll(), Wait() രീതികളാണ് (മൂന്ന് രീതികളും ജോഡികളായി സമാനമാണ്). ഒരേയൊരു വ്യത്യാസം, ജാവയിൽ ഈ രീതികൾ (അതനുസരിച്ച്, മോണിറ്റർ പ്രവർത്തനക്ഷമത) ഒബ്ജക്റ്റ് ക്ലാസിൽ നടപ്പിലാക്കുന്നു, അതിനാൽ സിൻക്രൊണൈസേഷനായി അധിക ലൈബ്രറികൾ ആവശ്യമില്ല, കൂടാതെ C# ൽ ഈ രീതികൾ ഒരു പ്രത്യേക ലൈബ്രറി ക്ലാസ് മോണിറ്ററിൽ സ്റ്റാറ്റിക് രീതികളായി നടപ്പിലാക്കുന്നു. . C#-ൽ സാധാരണ ലൈബ്രറിത്രെഡുകളുടെ സമാന്തര നിർവ്വഹണത്തിനായി നിരവധി അധിക സിൻക്രൊണൈസേഷൻ പ്രിമിറ്റീവുകളും ഇതിൽ അടങ്ങിയിരിക്കുന്നു: മ്യൂട്ടക്സുകൾ, സെമാഫോറുകൾ, ടൈമറുകൾ സമന്വയിപ്പിക്കൽ. പതിപ്പ് 1.5 മുതൽ, സമാന്തര കമ്പ്യൂട്ടിംഗ് നടപ്പിലാക്കുന്നതിനുള്ള സമഗ്രമായ ഒരു കൂട്ടം ടൂളുകൾ അടങ്ങുന്ന java.util.concurrent, java.util.concurrent.atomic, java.util.concurrent.locks പാക്കേജുകൾ JDK SE ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

താഴ്ന്ന നിലയിലുള്ള കോഡ്

ഇന്നുവരെ, ഒരു ഘടകവുമില്ല ജാവ പരിതസ്ഥിതികൾ Ecma, ISO, ANSI അല്ലെങ്കിൽ മറ്റെന്തെങ്കിലും മാനദണ്ഡമാക്കിയിട്ടില്ല മൂന്നാം പാർട്ടിമാനദണ്ഡങ്ങൾ. സൺ മൈക്രോസിസ്റ്റംസ് അതിന്റെ ജാവ വ്യാപാരമുദ്രകൾ പരിഷ്‌ക്കരിക്കുന്നതിനും ലൈസൻസ് ചെയ്യുന്നതിനുമുള്ള അനിയന്ത്രിതമായ, സവിശേഷമായ നിയമപരമായ അവകാശങ്ങൾ നിലനിർത്തുന്നുണ്ടെങ്കിലും, ജാവ കമ്മ്യൂണിറ്റി പ്രോസസ് (ജെസിപി) എന്ന പ്രക്രിയയിൽ സൺ സ്വമേധയാ പങ്കെടുക്കുന്നു, ഏത് സൺ ജാവ സാങ്കേതികവിദ്യയിലും (ഭാഷ, ടൂൾകിറ്റ്) മാറ്റങ്ങൾ നിർദ്ദേശിക്കാൻ താൽപ്പര്യമുള്ള കക്ഷികളെ ഇത് അനുവദിക്കുന്നു. API) കൺസൾട്ടേഷനുകളിലൂടെയും വിദഗ്ധ ഗ്രൂപ്പുകൾ. JCP നിയമങ്ങൾ അനുസരിച്ച്, JDK, Java റൺടൈം അല്ലെങ്കിൽ സ്പെസിഫിക്കേഷൻ എന്നിവയിലേക്കുള്ള മാറ്റത്തിനുള്ള ഏത് നിർദ്ദേശവും ജാവ ഭാഷസൺ ഏകപക്ഷീയമായി നിരസിച്ചേക്കാം, കാരണം അത് അംഗീകരിക്കപ്പെടുന്നതിന് സൂര്യനിൽ നിന്നുള്ള "അതെ" എന്ന വോട്ട് ആവശ്യമാണ്. JCP ന് വാണിജ്യ അംഗങ്ങളിൽ നിന്ന് അംഗത്വ ഫീസ് ആവശ്യമാണ്, അതേസമയം ലാഭേച്ഛയില്ലാത്ത സ്ഥാപനങ്ങൾക്കും വ്യക്തികൾക്കും സൗജന്യമായി പങ്കെടുക്കാം.

ലൈസൻസ്

"ജാവ" ആയിരിക്കുമ്പോൾ വ്യാപാരമുദ്രസൺ വ്യാപാരമുദ്ര, കൂടാതെ "ജാവ" എന്ന പേരിന് സൺ മാത്രമേ ലൈസൻസ് നൽകൂ, സൺ ജാവയുമായി ഭാഗികമായി പൊരുത്തപ്പെടുന്ന നിരവധി സൗജന്യ പ്രോജക്ടുകൾ ഉണ്ട്. ഉദാഹരണത്തിന്, GNU Classpath, GNU Compiler for Java (GCJ) എന്നിവ സൺ ജാവയുടെ നിലവിലെ പതിപ്പുമായി ഭാഗികമായി പൊരുത്തപ്പെടുന്ന ഒരു സൗജന്യ ക്ലാസ് ലൈബ്രറിയും കമ്പൈലറും നൽകുന്നു. 2006-ന്റെ അവസാനത്തിൽ, എല്ലാ ജാവ സോഴ്‌സ് കോഡുകളും, അവകാശങ്ങൾ നിലനിർത്താത്ത കുത്തക കോഡ് ഒഴികെ, 2007 മാർച്ചോടെ പരിഷ്‌ക്കരിച്ച GPL ലൈസൻസിന് കീഴിൽ സ്വതന്ത്ര സോഫ്റ്റ്‌വെയറായി പുറത്തിറക്കുമെന്ന് സൺ പ്രഖ്യാപിച്ചു. സൺ നിലവിൽ അതിന്റെ ഹോട്ട്‌സ്‌പോട്ട് വെർച്വൽ മെഷീനും ജാവ കമ്പൈലറും വിതരണം ചെയ്യുന്നു GPL ലൈസൻസ്, എന്നാൽ സാധാരണ ജാവ റൺടൈമിന് നിലവിൽ സൗജന്യ ലൈസൻസ് ഇല്ല. സൺ അതിന്റെ ജാവ സോഴ്‌സ് കോഡിന്റെ ഉടമസ്ഥാവകാശം നിലനിർത്തുമെന്നതിനാൽ, GPL-ന് കീഴിൽ അത് പുറത്തിറക്കുന്നത്, ജാവയുടെ ഉടമസ്ഥതയിലുള്ളതോ തുറക്കാത്തതോ ആയ പതിപ്പുകൾ വിതരണം ചെയ്യുന്നതിനോ മറ്റുള്ളവർക്ക് ലൈസൻസ് നൽകുന്നതിനോ സൂര്യനെ തടയില്ല.

C#, CLI റൺടൈം, കൂടാതെ അനുബന്ധ ക്ലാസ് ലൈബ്രറിയുടെ ഭൂരിഭാഗവും സ്റ്റാൻഡേർഡ് ചെയ്തവയാണ്, കൂടാതെ ലൈസൻസില്ലാതെ സ്വതന്ത്രമായി നടപ്പിലാക്കാൻ കഴിയും. പലതും ഇതിനകം നടപ്പാക്കിയിട്ടുണ്ട് സ്വതന്ത്ര സംവിധാനങ്ങൾ C#, മോണോയും DotGNU ഉം ഉൾപ്പെടെ. മോണോ പദ്ധതിയും പലതും നടപ്പാക്കുന്നുണ്ട് നിലവാരമില്ലാത്ത ലൈബ്രറികൾ GNU Classpath, Java എന്നിവയ്ക്ക് സമാനമായ Microsoft മെറ്റീരിയലുകൾ പഠിച്ചുകൊണ്ട് Microsoft. മോണോ പ്രോജക്റ്റ് ഏതെങ്കിലും പേറ്റന്റുകളിലേക്കോ പകർപ്പവകാശങ്ങളിലേക്കോ കടന്നുകയറുന്നത് ഒഴിവാക്കാൻ ലക്ഷ്യമിടുന്നു, കൂടാതെ പ്രോജക്റ്റ് സൗജന്യമായി വിതരണം ചെയ്യാനും GPL ലൈസൻസിന് കീഴിൽ ഉപയോഗിക്കാനും കഴിയും. മൈക്രോസോഫ്റ്റ് നിലവിൽ വാണിജ്യേതര ഉപയോഗത്തിനായി അതിന്റെ .NET റൺടൈമിന്റെ ഒരു പതിപ്പ് വിതരണം ചെയ്യുന്നു.

ഉപയോഗം

സമൂഹം

പ്രവർത്തനത്തിന്റെ വിവിധ മേഖലകളിൽ ഉയർന്ന മത്സരമുള്ള സ്ഥാപനങ്ങളുമായി കൂടുതൽ തുറന്ന സംസ്കാരത്തിലാണ് ജാവ നിർമ്മിച്ചിരിക്കുന്നത്. മിക്ക അധിക ലൈബ്രറികളും സൗജന്യ ഓപ്പൺ സോഴ്‌സ് ലൈസൻസിന് കീഴിൽ ലഭ്യമാണ്. സോഴ്സ് കോഡ്. ചില പ്രവർത്തനങ്ങളെ ഒരു സ്പെസിഫിക്കേഷനായി വിവരിക്കുന്ന രീതിയെയും സൺ പ്രോത്സാഹിപ്പിക്കുന്നു (ജെസിപി പ്രക്രിയ കാണുക), നടപ്പിലാക്കൽ മൂന്നാം കക്ഷി ഡെവലപ്പർമാർക്ക് വിട്ടുകൊടുക്കുന്നു (ഒരുപക്ഷേ ഒരു റഫറൻസ് നടപ്പിലാക്കൽ നൽകുന്നു). അങ്ങനെ, സോഫ്റ്റ്വെയർ നിർമ്മാതാവിൽ നിന്നുള്ള സ്വാതന്ത്ര്യത്തിന്റെ പ്രശ്നം പരിഹരിക്കപ്പെടുന്നു.

മോണോ നിലവിലുണ്ടെങ്കിലും, C# ഡെവലപ്പർമാരെ മൈക്രോസോഫ്റ്റ് പ്ലാറ്റ്‌ഫോമുമായി (OS ഉൾപ്പെടെ) ബന്ധിപ്പിക്കുന്നു. ഓഫീസ് പരിഹാരങ്ങൾ). അതിനാൽ, .NET-ൽ എഴുതപ്പെട്ട സോഫ്റ്റ്‌വെയറിന്റെ ഉപഭോക്താവിന് പലപ്പോഴും വിവിധ സിസ്റ്റം ഘടകങ്ങൾ ഉപയോഗിക്കുന്നതിൽ യാതൊരു തിരഞ്ഞെടുപ്പും ഉണ്ടാകില്ല. ഇത് വെണ്ടർ-ലോക്കിംഗ് എന്ന് വിളിക്കപ്പെടുന്നതിലേക്ക് നയിക്കുന്നു, അതിൽ മൂന്നാം കക്ഷി സോഫ്‌റ്റ്‌വെയറിന്റെ നിർമ്മാതാവിന് നടപ്പിലാക്കിയ പ്രോജക്റ്റിനെ പിന്തുണയ്‌ക്കുന്നതിന് വാങ്ങുന്നയാൾക്ക് ഏതാണ്ട് ഏത് നിബന്ധനകളും നിർദ്ദേശിക്കാനാകും. ഒരു ജാവ ആപ്ലിക്കേഷന്റെ ഉപയോക്താവിന്, ചട്ടം പോലെ, അധിക സോഫ്‌റ്റ്‌വെയറിന്റെ വിതരണക്കാരനെ തിരഞ്ഞെടുക്കാം (ഡാറ്റാബേസ്, ഒഎസ്, ആപ്ലിക്കേഷൻ സെർവർ മുതലായവ).

ജനപ്രീതിയും വികസനവും

ജാവ C# നേക്കാൾ പഴക്കമുള്ളതും വലുതും സജീവവുമായ ഒരു ഉപയോക്തൃ അടിത്തറയിലാണ് നിർമ്മിച്ചിരിക്കുന്നത് ഭാഷാ ഭാഷപലതിലും ആധുനിക പ്രദേശങ്ങൾകമ്പ്യൂട്ടർ സയൻസ്, പ്രത്യേകിച്ച് നെറ്റ്‌വർക്കുകൾ ഉൾപ്പെടുന്നവ. അമേരിക്കൻ സർവ്വകലാശാലകളിലും കോളേജുകളിലും പ്രോഗ്രാമിംഗ് കോഴ്‌സുകളിൽ ജാവ ആധിപത്യം പുലർത്തുന്നു, കൂടാതെ C#-നേക്കാൾ കൂടുതൽ സാഹിത്യം ജാവയിൽ ഇപ്പോൾ ഉണ്ട്. ജാവയുടെ പക്വതയും ജനപ്രീതിയും കാരണമായി കൂടുതൽജാവയിലെ ലൈബ്രറികളും API-കളും (അവയിൽ പലതും ഓപ്പൺ സോഴ്‌സ് ആണ്) C#-ൽ ഉള്ളതിനേക്കാൾ.

ജാവയിൽ നിന്ന് വ്യത്യസ്തമായി, C# താരതമ്യേന പുതിയ ഭാഷയാണ്. മൈക്രോസോഫ്റ്റ് പഠിച്ചു നിലവിലുള്ള ഭാഷകൾ, ജാവ, ഡെൽഫി, വിഷ്വൽ ബേസിക് എന്നിവ പോലെ, ചില തരത്തിലുള്ള ആപ്ലിക്കേഷനുകളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ രീതിയിൽ ഭാഷയുടെ ചില വശങ്ങൾ മാറ്റി.

ജാവയെക്കുറിച്ച് കേൾക്കാവുന്ന ഒരു വിമർശനം, അത് വികസിക്കുന്നത് മന്ദഗതിയിലാണെന്നും ഫാഷനബിൾ പ്രോഗ്രാമിംഗ് പാറ്റേണുകളും രീതിശാസ്ത്രങ്ങളും എളുപ്പമാക്കുന്ന ചില സവിശേഷതകളില്ല എന്നതാണ്. ഭാഷയുടെ ശ്രദ്ധയും ലാളിത്യവും കാരണം നിലവിലെ പ്രോഗ്രാമിംഗ് ട്രെൻഡുകൾ ഉൾക്കൊള്ളാൻ അതിന്റെ ഡെവലപ്പർമാർ വളരെ ഉത്സുകരാണ് എന്നതാണ് C# ഭാഷയെക്കുറിച്ചുള്ള വിമർശനം. ജാവയുടെ ഡിസൈനർമാർ മറ്റ് ആധുനിക ഭാഷകളെ അപേക്ഷിച്ച് ഭാഷയുടെ വാക്യഘടനയിൽ പ്രധാന പുതിയ സവിശേഷതകൾ ചേർക്കുന്നതിന് കൂടുതൽ യാഥാസ്ഥിതികമായ സമീപനമാണ് സ്വീകരിച്ചിരിക്കുന്നത്-ഒരുപക്ഷേ, ദീർഘകാലാടിസ്ഥാനത്തിൽ നാശത്തിലേക്ക് നയിച്ചേക്കാവുന്ന പ്രവണതകളിലേക്ക് ഭാഷയെ പ്രതിഷ്ഠിക്കാൻ തയ്യാറല്ല. ജാവ 5.0 പുറത്തിറങ്ങിയതോടെ, ഈ പ്രവണത വലിയ തോതിൽ തകർന്നു, കാരണം അത് ഭാഷയുടെ നിരവധി പ്രധാന പുതിയ സവിശേഷതകൾ അവതരിപ്പിച്ചു: ഫോർച്ച് ലൂപ്പ്, ഓട്ടോമാറ്റിക് റാപ്പിംഗ്, രീതികൾ വേരിയബിൾ നമ്പർപാരാമീറ്ററുകൾ, എണ്ണപ്പെട്ട തരങ്ങൾ, ജനറിക് തരങ്ങൾ, വ്യാഖ്യാനങ്ങൾ (ഇവയെല്ലാം C#-ൽ ഉണ്ട്).

C#, അതാകട്ടെ, വേഗത്തിൽ വികസിക്കുന്നു, പുതിയ പ്രശ്‌ന-നിർദ്ദിഷ്‌ട സവിശേഷതകൾ ചേർക്കുന്നതിൽ സ്വയം പരിമിതപ്പെടുത്തുന്നു. ഈ പ്രവണത പ്രത്യേകിച്ചും C# 3.0 പതിപ്പിൽ പ്രകടമായിരുന്നു, ഉദാഹരണത്തിന്, SQL പോലുള്ള ചോദ്യങ്ങൾ പ്രത്യക്ഷപ്പെട്ടു. (ഭാഷ ഒരു ഭാഷയായി തുടരുന്ന തരത്തിലാണ് പുതിയ സവിശേഷതകൾ നിർമ്മിച്ചിരിക്കുന്നത് പൊതു ഉപയോഗം. C# 3.0 നെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, C# എന്ന ലേഖനം കാണുക). ജാവയിലേക്കുള്ള പ്രശ്‌ന-അധിഷ്‌ഠിത കൂട്ടിച്ചേർക്കലുകൾ പരിഗണിക്കപ്പെട്ടിട്ടുണ്ട്, പക്ഷേ ഇത്രയെങ്കിലുംഇന്നുവരെ, നിരസിക്കപ്പെട്ടു.

വിപണി

അതിന്റെ തുടക്കം മുതൽ, C# ജാവയുമായി നിരന്തരം താരതമ്യം ചെയ്യപ്പെടുന്നു. C# ഉം അതിന്റെ നിയന്ത്രിത CLR ഉം ജാവയോടും അതിന്റെ JRE (Java Runtime Environment) യോടും വളരെയധികം കടപ്പെട്ടിരിക്കുന്നു എന്നത് നിഷേധിക്കാനാവില്ല.

C# ന്റെ വികസനം ഏതെങ്കിലും വിധത്തിൽ മൈക്രോസോഫ്റ്റ് തിരിച്ചറിഞ്ഞതിന്റെ ഫലമാണോ എന്നത് തർക്കവിഷയമാണ്, ജാവയെ നയിക്കുന്ന ഒരു നിയന്ത്രിത കോഡ് പരിതസ്ഥിതിക്ക്, വർദ്ധിച്ചുവരുന്ന നെറ്റ്‌വർക്കിംഗ് ലോകത്ത്, പ്രത്യേകിച്ച് മറ്റ് ഉപകരണങ്ങളിൽ ഇന്റർനെറ്റിന്റെ ആവിർഭാവത്തോടെ നിരവധി ഗുണങ്ങളുണ്ട്. വ്യക്തിഗത കമ്പ്യൂട്ടറുകൾനെറ്റ്‌വർക്ക് സുരക്ഷയുടെ വർദ്ധിച്ചുവരുന്ന പ്രാധാന്യത്തോടെ. C# സൃഷ്‌ടിക്കുന്നതിന് മുമ്പ്, Windows-ൽ മാത്രം പ്രവർത്തിക്കുന്ന ഫീച്ചറുകൾ ചേർക്കുന്നതിനായി Microsoft Java (J++ സൃഷ്‌ടിക്കുന്നു) പരിഷ്‌ക്കരിച്ചു, അതുവഴി ബ്രേക്കിംഗ് ലൈസൻസ് ഉടമ്പടിസൺ മൈക്രോസിസ്റ്റംസ്. മൈക്രോസോഫ്റ്റ് അതിന്റെ ബിസിനസ്സ് തന്ത്രത്തിന്റെ രണ്ടാം ഘട്ടത്തിലായിരിക്കുമ്പോൾ, "ആലിംഗനം, നീട്ടൽ, കെടുത്തുക" എന്ന് അറിയപ്പെടുന്നു, സൺ ഫയൽ ചെയ്ത ഒരു വ്യവഹാരത്താൽ J++ ന്റെ വികസനം നിർത്തിവച്ചു. ആവശ്യമുള്ള ഫീച്ചറുകളുള്ള ഒരു ജാവ ക്ലോൺ വികസിപ്പിക്കാൻ കഴിയാതെ, മൈക്രോസോഫ്റ്റ് അവരുടെ ആവശ്യങ്ങൾക്കും ഭാവിയിലേക്കുള്ള കാഴ്ചപ്പാടിനും അനുയോജ്യമായ ഒരു ബദൽ സൃഷ്ടിച്ചു.

ഈ പ്രക്ഷുബ്ധമായ തുടക്കം ഉണ്ടായിരുന്നിട്ടും, വിപണിയിൽ രണ്ട് ഭാഷകൾ പരസ്പരം മത്സരിക്കുന്നത് അപൂർവ്വമായിട്ടാണെന്ന് കൂടുതൽ വ്യക്തമാകുകയാണ്. മൊബൈൽ മേഖലയിൽ ആധിപത്യം പുലർത്തുന്ന ജാവയ്ക്ക് വെബ് ആപ്ലിക്കേഷൻ വിപണിയിൽ നിരവധി അനുയായികളുണ്ട്. വിൻഡോസ് ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷൻ മാർക്കറ്റിൽ C# നല്ല സ്വീകാര്യത നേടി, ASP.NET-ന് നന്ദി, C# വെബ് ആപ്ലിക്കേഷൻ മാർക്കറ്റിലും ഒരു കളിക്കാരനാണ്.

ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകൾ

രണ്ട് ഭാഷകളിലും ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകൾക്കായി ഉപയോക്തൃ ഇന്റർഫേസ് കഴിവുകൾ നൽകുന്ന ഒരു കൂട്ടം ലൈബ്രറികളുണ്ട്. ജാവയുടെ കാര്യത്തിൽ, ഇവ സ്വിംഗ്, എസ്‌ഡബ്ല്യുടി എന്നീ മൾട്ടി-പ്ലാറ്റ്‌ഫോം ലൈബ്രറികളും അതുപോലെ സാധാരണമല്ലാത്ത നിരവധി ലൈബ്രറികളുമാണ്. തത്വത്തിൽ, ജാവയിൽ ക്രോസ്-പ്ലാറ്റ്ഫോം ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കാൻ അവയിലേതെങ്കിലും നിങ്ങളെ അനുവദിക്കുന്നു.

നടപ്പിലാക്കുന്ന പ്രധാന ലൈബ്രറിയായ വിൻഡോസ് പ്ലാറ്റ്‌ഫോമിലെ C#-നായി GUIഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകളിലെ ഉപയോക്താവ് Windows.Forms ആണ്, മൈക്രോസോഫ്റ്റിന്റെ ഉടമസ്ഥതയിലുള്ളതും വിൻഡോസിനായി മാത്രം നടപ്പിലാക്കിയതും മറ്റ് പ്ലാറ്റ്ഫോമുകളിൽ - gtk#, മോണോ പ്രോജക്റ്റിന്റെ ഭാഗമായി നടപ്പിലാക്കിയതുമാണ്. സ്വതന്ത്രമായി വിൻഡോസ് നടപ്പിലാക്കാനുള്ള ശ്രമങ്ങൾ.ഫോറങ്ങൾ ഉണ്ടാക്കിയിട്ടുണ്ട് (ഉദാഹരണത്തിന്, DotGNU പ്രോജക്റ്റിൽ), എന്നിരുന്നാലും, ഒറിജിനലിന്റെ അടഞ്ഞ സ്വഭാവം കാരണം, അവ അനിവാര്യമായും ദ്വിതീയവും അപൂർണ്ണവും ആയതിനാൽ അവ നടപ്പിലാക്കുന്നതിനോട് മത്സരിക്കാനാവില്ല. മറ്റ് പ്ലാറ്റ്‌ഫോമുകളിലേക്കുള്ള ആപ്ലിക്കേഷനുകൾ വിൻഡോസിന്റെ കാലതാമസമുള്ള പോർട്ടിംഗിന് മാത്രമേ Microsoft ഉപയോഗിക്കാനാവൂ. വിൻഡോസിനെ അടിസ്ഥാനമാക്കിയുള്ള വികസനങ്ങൾ സാധാരണയായി Windows.Forms-ലാണ് നിർമ്മിച്ചിരിക്കുന്നത്, അവ മറ്റൊരു പ്ലാറ്റ്‌ഫോമിലേക്ക് പോർട്ട് ചെയ്യുന്നത് ബുദ്ധിമുട്ടാണ്. gtk# ഉപയോഗിച്ച് മോണോ എൻവയോൺമെന്റിലെ C# വികസനം പോർട്ടബിൾ ആണ്, എന്നാൽ അവയിൽ കാര്യമായ കുറവ് മാത്രമേ ഉള്ളൂ.

ഭാഷയുടെ സ്വഭാവം കാരണം, ജാവ ഗ്രാഫിക്സ് ലൈബ്രറികളുടെ മാനുവൽ ഉപയോഗം കുറച്ചുകൂടി ബുദ്ധിമുട്ടാണ്. ജാവ ഗ്രാഫിക്സ് ലൈബ്രറികളുടെ ആർക്കിടെക്ചർ ഒരു പുതിയ ഡെവലപ്പർക്ക് മനസ്സിലാക്കാൻ കൂടുതൽ ബുദ്ധിമുട്ടാണ്, എന്നാൽ അതേ സമയം, അത് പ്രൊഫഷണലായി വികസിപ്പിക്കാൻ അവനെ പ്രേരിപ്പിക്കുന്നു. C#, ബിൽറ്റ്-ഇൻ ഇവന്റ് പ്രോഗ്രാമിംഗ് ടൂളുകളുടെ സാന്നിധ്യം കാരണം, ഇവന്റ് പ്രോസസ്സിംഗിന്റെ വിശദാംശങ്ങളും മറ്റ് ചില വശങ്ങളും ഡെവലപ്പറിൽ നിന്ന് മറയ്ക്കുകയും ഇന്റർഫേസ് വികസനം സുഗമമാക്കുകയും ചെയ്യുന്നു. .NET പ്ലാറ്റ്ഫോം തുടക്കത്തിൽ വിഷ്വൽ ഇന്റർഫേസ് ബിൽഡറുകൾ വിപുലമായി ഉപയോഗിച്ചു. കുറഞ്ഞ പ്രോഗ്രാമർ യോഗ്യതകളുള്ള ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകൾക്കായി ഒരു ഇന്റർഫേസ് വേഗത്തിൽ വികസിപ്പിക്കുന്നത് ഇതെല്ലാം സാധ്യമാക്കുന്നു.

കഴിഞ്ഞ കുറച്ച് വർഷങ്ങളായി, ഡെസ്‌ക്‌ടോപ്പ് ആപ്ലിക്കേഷൻ വിപണിയിലേക്ക് ജാവയെ കൂടുതൽ വ്യാപകമായി അവതരിപ്പിക്കുന്നതിൽ സൺ മൈക്രോസിസ്റ്റംസ് ശ്രദ്ധ കേന്ദ്രീകരിച്ചു. JRE 6 പ്ലാറ്റ്‌ഫോമിന്റെ (2006) പതിപ്പിൽ, ഉപയോക്താവിന്റെ ഗ്രാഫിക്കൽ പരിതസ്ഥിതിയുമായുള്ള ആശയവിനിമയം മെച്ചപ്പെടുത്തുന്നതിനാണ് ഊന്നൽ നൽകുന്നത്. Sun's JVM-ന്റെ ഏറ്റവും പുതിയ പതിപ്പ് (JDK 6 അപ്‌ഡേറ്റ് 10) ഉപയോക്തൃ ഇന്റർഫേസിന്റെ നിരവധി മെച്ചപ്പെടുത്തലുകൾ ഉൾക്കൊള്ളുന്നു. പ്രത്യേകിച്ച്, സുതാര്യമായ രൂപങ്ങളും നോൺ-ചതുരാകൃതിയിലുള്ള വിൻഡോകളും. Java IDE-കളുടെ സമീപകാല പതിപ്പുകളിൽ (ഉദാ: NetBeans) ഗണ്യമായി മെച്ചപ്പെടുത്തിയ ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് ബിൽഡറുകളും ഉൾപ്പെടുന്നു.

C#, ജാവയ്‌ക്കൊപ്പം, നിരവധി ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ ക്രമേണ ജനപ്രിയമാവുകയാണ് ലിനക്സ് അടിസ്ഥാനമാക്കിയുള്ളത്കൂടാതെ ബി.എസ്.ഡി. CLR ഉം C# ഭാഷയും Ecma-യും ISO-ഉം മുഖേന സ്റ്റാൻഡേർഡ് ചെയ്‌തിരിക്കുന്നതിനാൽ മോണോ പ്രോജക്റ്റ് നടപ്പിലാക്കുന്നത് നിയമപരമായി വേദനയില്ലാത്ത ഒരു പ്രക്രിയയായിരുന്നു, നിയമപരമായ പ്രശ്‌നങ്ങളെക്കുറിച്ച് ആകുലപ്പെടാതെ ആർക്കും അവ നടപ്പിലാക്കാൻ കഴിയും. അതേ സമയം, അപേക്ഷയുടെ കീഴിലാണ് എഴുതിയിരിക്കുന്നത് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ് വിൻഡോസ് പരിസ്ഥിതിമറ്റൊരു OS-ന് കീഴിൽ പ്രവർത്തിക്കുന്നതിൽ കാര്യമായ പ്രശ്നങ്ങൾ ഉണ്ടായേക്കാം.

സെർവർ ആപ്ലിക്കേഷനുകൾ

ഈ രംഗത്ത്, ഒരുപക്ഷേ രണ്ട് ഭാഷകളും എതിരാളികളായി കണക്കാക്കുന്നതിന് ഏറ്റവും അടുത്താണ്. ജാവ അതിന്റെ J2EE പ്ലാറ്റ്‌ഫോം (Java(2) എന്റർപ്രൈസ് പതിപ്പ്) ഉം ASP.NET ഉള്ള C# ഉം ഡൈനാമിക് വെബ് ഉള്ളടക്കവും ആപ്ലിക്കേഷനുകളും സൃഷ്ടിക്കുന്നതിൽ മത്സരിക്കുന്നു.

JavaEE, .NET എന്നിവയ്‌ക്കായി ലഭ്യമായ ടൂളുകളുടെയും പിന്തുണയ്‌ക്കുന്ന ഉൽപ്പന്നങ്ങളുടെയും സഹിതം ഈ വിപണിയിൽ രണ്ട് ഭാഷകളും വ്യാപകമായി ഉപയോഗിക്കപ്പെടുകയും പിന്തുണയ്‌ക്കുകയും ചെയ്യുന്നു.

മൊബൈൽ ആപ്ലിക്കേഷനുകൾ

J2ME (JavaME, Java(2) Micro Edition) മൊബൈൽ ഫോണിലും PDA വിപണികളിലും വളരെ വിശാലമായ അടിത്തറയുണ്ട്, അവിടെ ഏറ്റവും കൂടുതൽ മാത്രം വിലകുറഞ്ഞ ഉപകരണങ്ങൾകെവിഎം അഭാവം (പരിമിതമായ ഉറവിടങ്ങളുള്ള ഉപകരണങ്ങൾക്കായി ഒരു സ്ട്രിപ്പ്-ഡൗൺ ജാവ വെർച്വൽ മെഷീൻ). നിരവധി ഗെയിമുകൾ ഉൾപ്പെടെയുള്ള ജാവ പ്രോഗ്രാമുകൾ എല്ലായിടത്തും കാണപ്പെടുന്നു.

മിക്കവാറും എല്ലാ ഫോണുകളിലും കെവിഎം ഉൾപ്പെടുന്നുണ്ടെങ്കിലും, മിക്ക ഉപയോക്താക്കളും ഈ കഴിവുകൾ കാര്യമായി ഉപയോഗിക്കുന്നില്ല. ജാവ ആപ്ലിക്കേഷനുകൾമിക്ക ഫോണുകളിലും സാധാരണയായി മെനു സിസ്റ്റങ്ങൾ അടങ്ങിയിരിക്കുന്നു, ചെറിയ കളികൾമൊബെെൽ ഫോണുകൾക്കായുള്ള പൂർണ്ണമായ ആപ്ലിക്കേഷനുകൾ അപൂർവ്വമാണ്.

ഹൈടെക്

സി ഷാർപ്പ്- ഈ പദത്തിന് മറ്റ് അർത്ഥങ്ങളുണ്ട്, C കാണുക. ഈ ലേഖനത്തിന്റെ ശരിയായ തലക്കെട്ട് C# ആണ്. കാരണം തെറ്റായി കാണിച്ചിരിക്കുന്നു സാങ്കേതിക പരിമിതികൾ. സി# സെമാന്റിക്സ്: നിർബന്ധിത ഭാഷാ ക്ലാസ്: മൾട്ടി-പാരഡൈം: ഒബ്ജക്റ്റ് ഓറിയന്റഡ്,... ... വിക്കിപീഡിയ

വിഷ്വൽ ജെ ഷാർപ്പ്- ഈ വിഷ്വൽ ജെ# ലേഖനത്തിന്റെ ശരിയായ തലക്കെട്ട്. സാങ്കേതിക പരിമിതികൾ കാരണം ഇത് തെറ്റായി കാണിച്ചിരിക്കുന്നു. ജാവ പോലുള്ള ഭാഷയിൽ .NET ഫ്രെയിംവർക്കിനായി മൈക്രോസോഫ്റ്റ് സൃഷ്ടിച്ച ഒരു സംയോജിത വികസന അന്തരീക്ഷമാണ് വിഷ്വൽ ജെ#. പ്രത്യേകിച്ച്... ... വിക്കിപീഡിയ

എഫ് ഷാർപ്പ്- ഈ പദത്തിന് മറ്റ് അർത്ഥങ്ങളുണ്ട്, എഫ് (അർത്ഥങ്ങൾ) കാണുക. ഈ F# ലേഖനത്തിന്റെ ശരിയായ തലക്കെട്ട്. സാങ്കേതിക പരിമിതികൾ കാരണം ഇത് തെറ്റായി കാണിച്ചിരിക്കുന്നു. F# ഭാഷാ ക്ലാസ്: മൾട്ടി-പാരഡൈം: ഫങ്ഷണൽ, ഒബ്ജക്റ്റ് ഓറിയന്റഡ്, ... ... വിക്കിപീഡിയ

ഷാർപ്പ് ആയി പാടുക- ഈ ലേഖനത്തിന്റെ ശരിയായ തലക്കെട്ട് Sing# എന്നാണ്. സാങ്കേതിക പരിമിതികൾ കാരണം ഇത് തെറ്റായി കാണിച്ചിരിക്കുന്നു. പാടുക# ഭാഷാ ക്ലാസ്: മൾട്ടി-പാരഡൈം: ഘടനാപരമായ, അനിവാര്യമായ, ഒബ്ജക്റ്റ്-ഓറിയന്റഡ്, ഇവന്റ്-ഓറിയന്റഡ്, ഫങ്ഷണൽ, ... ... വിക്കിപീഡിയ

എം.സി ഷാർപ്പ്- MC# (“MC Sharp”, mcsharp എന്ന് വായിക്കുക), മൾട്ടിപ്രൊസസർ C# പ്രോഗ്രാമിംഗ് ഭാഷ. MC# എന്നത് ... ...

വിഷ്വൽ സി ഷാർപ്പ്

വിഷ്വൽ സി ഷാർപ്പ് .NET- വിഷ്വൽ സ്റ്റുഡിയോ 2008 SP1-ന്റെ മൈക്രോസോഫ്റ്റ് വിഷ്വൽ സ്റ്റുഡിയോ ദൃശ്യപരത, വിൻഡോസ് വിസ്റ്റ ടൈപ്പ് സോഫ്‌റ്റ്‌വെയർ ഡെവലപ്‌മെന്റ് എൻവയോൺമെന്റിൽ C#-ൽ ഒരു പ്രോഗ്രാമിനൊപ്പം ... വിക്കിപീഡിയ

ECMAScript- ഭാഷാ ക്ലാസ്: മൾട്ടി-പാരഡൈം: ഒബ്ജക്റ്റ്-ഓറിയന്റഡ്, ജെനറിക്, ഫങ്ഷണൽ, ഇംപറേറ്റീവ്, വശ-അധിഷ്ഠിത, ഇവന്റ്-ഓറിയന്റഡ്, പ്രോട്ടോടൈപ്പ് പ്രോഗ്രാമിംഗ് പ്രത്യക്ഷപ്പെട്ടത്: 1995 രചയിതാവ്(കൾ) ... വിക്കിപീഡിയ

ജാവ vs. C#... ഒരു ശാശ്വത തർക്കത്തേക്കാൾ മികച്ചത് മറ്റെന്താണ്? ഇല്ല, ഈ ലേഖനം മറ്റൊരു മാനദണ്ഡത്തിനായി നീക്കിവച്ചിട്ടില്ല, ഒരു വിശുദ്ധ യുദ്ധം പോലുമല്ല, ഒരു ചോദ്യം പോലുമില്ല: "ആരാണ് തണുപ്പൻ".

ഓരോ ജോലിക്കും ഒരു ടൂൾ ഉണ്ട്. ഉദാഹരണത്തിന്, സി#, റൂബി എന്നിവ താരതമ്യം ചെയ്യുന്നത് അർത്ഥമാക്കുന്നില്ല, കാരണം അവരുടെ ഉദ്ദേശ്യം തികച്ചും വ്യത്യസ്തമാണ്, അതുപോലെ തന്നെ അവരുടെ സ്വഭാവവും. എന്നിരുന്നാലും, അവരുടെ തത്ത്വചിന്തയിൽ ഏറ്റവും അടുത്തത് C#, Java എന്നിവയാണ്.

മിക്കപ്പോഴും, ജാവയിൽ എഴുതുന്ന സഹപ്രവർത്തകർക്ക് C# നൽകുന്ന (അല്ലെങ്കിൽ, മറിച്ച്, നൽകാത്ത) പല (!!!) കാര്യങ്ങളെക്കുറിച്ച് പോലും അറിയില്ല.

നിങ്ങൾക്ക് C#, Java എന്നിവ നോക്കാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ ആത്മനിഷ്ഠ ഇല്ലാതെ, കൂടാതെ ഈ അല്ലെങ്കിൽ ആ അവസരത്തിന്റെ ആന്തരിക ഘടന കണ്ടെത്തുക, തുടർന്ന് മുന്നോട്ട് പോകുക.

▌ ഒരു ചെറിയ ചരിത്രം

C# ഭാഷ 2001 ൽ പ്രത്യക്ഷപ്പെട്ടു, അതിന്റെ വികസനം 1999 ൽ ആരംഭിച്ചു. അന്ന് അത് ജാവ 1.4 നോട് വളരെ സാമ്യമുള്ളതായിരുന്നു. എന്നിരുന്നാലും, നമുക്കറിയാവുന്ന ആധുനിക C# പതിപ്പ് 2.0-ൽ ആരംഭിക്കണം (ഇത് ജാവ 5-ന്റെ റിലീസുമായി യോജിക്കുന്നു).

C# ജാവയിൽ നിന്ന് ധാരാളം കടം വാങ്ങുന്നുവെന്ന് ഒരു അഭിപ്രായമുണ്ട്. എന്നിരുന്നാലും, ഞാൻ ഇതിനോട് ശക്തമായി വിയോജിക്കുന്നു. എന്റെ അഭിപ്രായത്തിൽ, C# പല തരത്തിൽ C "വസ്‌തുക്കൾക്കൊപ്പം" അല്ലെങ്കിൽ C++ "മനുഷ്യമുഖം" ആണ്.

ലേഖനവും അതിലെ വാദങ്ങളും ഈ പ്രസ്താവന ശരിവയ്ക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.
ഞാൻ വിക്കിപീഡിയ വീണ്ടും പറയില്ല. അതിനാൽ, നമുക്ക് ഉടനടി മുന്നോട്ട് പോകാം പ്രധാന വ്യത്യാസങ്ങൾആനുകൂല്യങ്ങളും.

ആദ്യം, നമ്മൾ JVM, CLR (കോമൺ ലാംഗ്വേജ് റൺടൈം) എന്നിവയുടെ കഴിവുകൾ നോക്കും, പിന്നെ നമ്മൾ C# ന്റെ വാക്യഘടനാ ഷുഗർ നോക്കും.

▌ എപ്പിസോഡ് I: ബൈറ്റ്കോഡ്

.NET, Java എന്നിവ രണ്ടും ബൈറ്റ്കോഡ് ഉപയോഗിക്കുന്നു. തീർച്ചയായും, ഫോർമാറ്റ് കൂടാതെ, വളരെ പ്രധാനപ്പെട്ട ഒരു വ്യത്യാസമുണ്ട് - പോളിമോർഫിസം.

CIL (കോമൺ ഇന്റർമീഡിയറ്റ് ലാംഗ്വേജ്, MSIL എന്നും അറിയപ്പെടുന്നു, IL എന്നും അറിയപ്പെടുന്നു) പോളിമോർഫിക് (സാമാന്യവൽക്കരിക്കപ്പെട്ട) നിർദ്ദേശങ്ങളുള്ള ബൈറ്റ്കോഡാണ്.

അതിനാൽ, ജാവയിലാണെങ്കിൽ അത് ഉപയോഗിക്കുന്നു പ്രത്യേക നിർദ്ദേശങ്ങൾഓരോ തരത്തിലുള്ള പ്രവർത്തനത്തിനും വിവിധ തരം(ഉദാഹരണത്തിന്: ഫാഡ്- 2 ഫ്ലോട്ടുകളുടെ കൂട്ടിച്ചേർക്കൽ, iadd- 2 പൂർണ്ണസംഖ്യകളുടെ കൂട്ടിച്ചേർക്കൽ), തുടർന്ന് ഓരോ തരത്തിലുള്ള പ്രവർത്തനത്തിനും CIL-ൽ പോളിമോർഫിക് പാരാമീറ്ററുകളുള്ള ഒരു നിർദ്ദേശം മാത്രമേയുള്ളൂ (ഉദാഹരണത്തിന്, ഒരു നിർദ്ദേശം മാത്രമേയുള്ളൂ - ചേർക്കുക, ഇത് ഫ്ലോട്ടുകളും പൂർണ്ണസംഖ്യകളും ചേർക്കുന്നു). ഉചിതമായ x86 നിർദ്ദേശങ്ങൾ ജനറേറ്റ് ചെയ്യാനുള്ള തീരുമാനം JIT-ൽ വരുന്നു.

രണ്ട് പ്ലാറ്റ്‌ഫോമുകൾക്കുമുള്ള നിർദ്ദേശങ്ങളുടെ എണ്ണം ഏകദേശം തുല്യമാണ്. ജാവ, സിഐഎൽ ബൈറ്റ്കോഡ് കമാൻഡുകളുടെ ലിസ്റ്റ് താരതമ്യം ചെയ്യുമ്പോൾ, 206 ജാവയ്ക്കാണെന്നും 232 സിഐഎലിനാണെന്നും നിങ്ങൾക്ക് കാണാൻ കഴിയും, എന്നാൽ ജാവയിൽ പല കമാൻഡുകളും പരസ്പരം പ്രവർത്തനക്ഷമത ആവർത്തിക്കുന്നുവെന്ന കാര്യം മറക്കരുത്.

▌ എപ്പിസോഡ് III: ജനറിക്‌സ് (പാരാമീറ്ററൈസ്ഡ് തരങ്ങൾ || പാരാമെട്രിക് പോളിമോർഫിസം)

നിങ്ങൾക്കറിയാവുന്നതുപോലെ, ജാവ തരം മായ്ക്കൽ സംവിധാനം ഉപയോഗിക്കുന്നു, അതായത്. ജനറിക്‌സിനുള്ള പിന്തുണ കംപൈലർ മാത്രമാണ് നൽകുന്നത്, എന്നാൽ റൺടൈം വഴിയല്ല, സമാഹരിച്ചതിന് ശേഷം, തരത്തെക്കുറിച്ചുള്ള വിവരങ്ങൾ ലഭ്യമാകില്ല.

ഉദാഹരണത്തിന്, കോഡ്:

ലിസ്റ്റ് strList = പുതിയ ArrayList (); ലിസ്റ്റ് intList = പുതിയ ArrayList (); bool areSame = strList.getClass() == intList.getClass(); System.out.println(areSame);
പ്രദർശിപ്പിക്കും സത്യം.

മാത്രമല്ല, സാമാന്യവൽക്കരിച്ച തരത്തിന് പകരം ടിതരത്തിലുള്ള ഒരു വസ്തുവിന്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കപ്പെടുന്നു java.lang.Object.

ലിസ്റ്റ് strList = പുതിയ ArrayList (); strList.add("stringValue"); സ്ട്രിംഗ് str = strList.get(0);
ഇതിലേക്ക് പരിവർത്തനം ചെയ്യും:

ലിസ്റ്റ് ലിസ്റ്റ് = പുതിയ അറേ ലിസ്റ്റ്(); list.add("stringValue"); സ്ട്രിംഗ് x = (സ്ട്രിംഗ്) list.get(0);
അതിനാൽ മുഴുവൻ തരത്തിലുള്ള സുരക്ഷാ നയം നശിപ്പിക്കപ്പെടുന്നുതൽക്ഷണം.

നെറ്റ്, മറിച്ച്, ഉണ്ട് പൂർണ്ണ പിന്തുണകംപൈൽ-ടൈം, റൺ-ടൈം എന്നിവ രണ്ടും ജനറിക്‌സ്.

ജാവയിലെ ജനറിക്‌സിനെ പൂർണ്ണമായി പിന്തുണയ്ക്കാൻ എന്താണ് നടപ്പിലാക്കേണ്ടത്? പകരം, .NET ഡെവലപ്മെന്റ് ടീം എന്താണ് ചെയ്തതെന്ന് നമുക്ക് നോക്കാം:

• ക്രോസ്-ലാംഗ്വേജ് ഇന്റർഓപ്പറബിളിറ്റിക്ക് കോമൺ ടൈപ്പ് സിസ്റ്റം തലത്തിലുള്ള ജനറിക്‌സ് പിന്തുണ
• റിഫ്ലക്ഷൻ API-ൽ നിന്നുള്ള പൂർണ്ണ പിന്തുണ
• അടിസ്ഥാന ക്ലാസുകളിലേക്ക് പുതിയ ക്ലാസുകൾ/രീതികൾ ചേർക്കുന്നു (ബേസ് ക്ലാസ് ലൈബ്രറി)
• ഫോർമാറ്റിലെയും മെറ്റാഡാറ്റ പട്ടികകളിലെയും മാറ്റങ്ങൾ
• റൺടൈം മെമ്മറി അലോക്കേഷൻ അൽഗോരിതം മാറ്റങ്ങൾ
• പുതിയ ഡാറ്റ ഘടനകൾ ചേർക്കുന്നു
• JIT-ൽ നിന്നുള്ള ജനറിക്‌സ് പിന്തുണ (കോഡ് പങ്കിടൽ)
• CIL ഫോർമാറ്റിലെ മാറ്റങ്ങൾ (പുതിയ ബൈറ്റ്കോഡ് നിർദ്ദേശങ്ങൾ)
• CIL കോഡ് വെരിഫയർ പിന്തുണ

ആ. കംപൈൽ സമയത്ത് മാത്രമല്ല, റൺടൈമിലും തരം വിവരങ്ങൾ നഷ്‌ടപ്പെടാതെയും മാറ്റാതെയും ജനറിക്‌സ് ലഭ്യമാണ്. ബോക്സിംഗ്/അൺബോക്സിംഗ് എന്നിവയുടെ ആവശ്യകതയും അപ്രത്യക്ഷമാകുന്നു.

▌ എപ്പിസോഡ് IV: തരങ്ങൾ

ജാവ പൂർണ്ണമായും OO ഭാഷയാണ്. ഇത് ചർച്ചാവിഷയമാണ്. എന്തുകൊണ്ടാണിത്: പ്രാകൃത തരങ്ങൾ (പൂർണ്ണസംഖ്യ, ഫ്ലോട്ട് മുതലായവ) java.lang.Object-ൽ നിന്ന് പാരമ്പര്യമായി ലഭിക്കുന്നില്ല. അതിനാൽ, ജാവയിലെ ജനറിക്‌സ് പ്രാകൃത തരങ്ങളെ പിന്തുണയ്ക്കുന്നില്ല.

എന്നാൽ ശരിക്കും OO ഭാഷയിൽ എല്ലാം വസ്തുവാണ്.

ഇത് മാത്രമല്ല പരിമിതി. നിങ്ങളുടെ സ്വന്തം പ്രാകൃത തരങ്ങൾ സൃഷ്ടിക്കാനും സാധ്യമല്ല.

ഇത് ചെയ്യാൻ C# നിങ്ങളെ അനുവദിക്കുന്നു. ഈ ഘടനകളുടെ പേര് നിർമ്മിക്കുക.

ഉദാഹരണത്തിന്:

പൊതു ഘടന ക്വാഡ് (int X1; int X2; int Y1; int Y2;)
കൂടാതെ, C#-ലെ ജനറിക്‌സ് മൂല്യ തരങ്ങൾ (int, float, മുതലായവ) ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ജാവയിലാണെങ്കിൽ നിങ്ങൾ ഇതുപോലെ എഴുതേണ്ടതുണ്ട്:

ലിസ്റ്റ് intList = പുതിയ ArrayList ();
എന്നാൽ നിങ്ങൾക്ക് ഇത് ചെയ്യാൻ കഴിയില്ല:

ലിസ്റ്റ് intList = പുതിയ ArrayList ();
C# പ്രാകൃത തരങ്ങളുടെ ഉപയോഗം അനുവദിക്കുന്നു.

ഇനി നമ്മൾ .NET-ലെ ടൈപ്പ് ഹൈറർക്കി എന്ന വിഷയത്തിലേക്ക് വരാം.

.NET-ൽ 3 തരം തരങ്ങളുണ്ട്: മൂല്യം, റഫറൻസ്, പോയിന്റർ തരങ്ങൾ.

അതിനാൽ, മൂല്യ തരം- ജാവയിൽ നിന്നുള്ള പ്രാകൃത തരത്തിലുള്ള അനലോഗ്. എന്നിരുന്നാലും, ഇത് പാരമ്പര്യമായി ലഭിക്കുന്നു സിസ്റ്റം.ഒബ്ജക്റ്റ്, കൂമ്പാരത്തിലല്ല, സ്റ്റാക്കിലാണ് ജീവിക്കുന്നത് (ഇപ്പോൾ ഒരു നിരാകരണം: മൂല്യ തരത്തിന്റെ സ്ഥാനം അതിന്റെ ജീവിത ചക്രത്തെ ആശ്രയിച്ചിരിക്കുന്നു, ഉദാഹരണത്തിന്, ഒരു അടച്ചുപൂട്ടലിൽ പങ്കെടുക്കുമ്പോൾ, ബോക്സിംഗ് സ്വയമേവ സംഭവിക്കുന്നു).

റഫറൻസ് തരം- ജാവയിലെ റഫറൻസ് തരങ്ങൾക്ക് സമാനമാണ്.

പോയിന്റർ തരം– .NET ന്റെ ഏറ്റവും അസാധാരണമായ സ്വത്താണ്. പോയിന്ററുകളുമായി നേരിട്ട് പ്രവർത്തിക്കാൻ CLR നിങ്ങളെ അനുവദിക്കുന്നു എന്നതാണ് വസ്തുത!

ഉദാഹരണത്തിന്:

സ്ട്രക്റ്റ് പോയിന്റ് (പബ്ലിക് ഇൻറ്റ് x; പബ്ലിക് ഇൻറ്റ് വൈ; ) സുരക്ഷിതമല്ലാത്ത സ്റ്റാറ്റിക് ശൂന്യമായ പോയിന്റർമെത്തോഡ്() (പോയിന്റ് പോയിന്റ്; പോയിന്റ്* p = p->x = 100; p->y = 200; പോയിന്റ് പോയിന്റ്2; പോയിന്റ്* p2 = (*p2 ).x = 100; (*p2).y = 200; )
C++ കോഡ് പോലെ തോന്നുന്നു, അല്ലേ?

▌ എപ്പിസോഡ് V: C# ഫീച്ചറുകൾ

ആദ്യം, C#-ന് എന്ത് ചെയ്യാനാകുമെന്ന് നമുക്ക് നിർവചിക്കാം:

• പ്രോപ്പർട്ടികൾ (ഓട്ടോമാറ്റിക് ഉൾപ്പെടെ)
• പ്രതിനിധികൾ
• ഇവന്റുകൾ
• അജ്ഞാത രീതികൾ
• ലാംഡ പദപ്രയോഗങ്ങൾ
• എക്സ്പ്രഷൻ മരങ്ങൾ
• അജ്ഞാത ക്ലാസുകൾ
• ശക്തമായ തരം അനുമാനം
• ഓപ്പറേറ്റർ ഓവർലോഡിംഗ്
• സൂചികകൾ
• ...കൂടുതൽ

പ്രോപ്പർട്ടികൾ C#-ൽ അവ വാക്യഘടന പഞ്ചസാരയെ പ്രതിനിധീകരിക്കുന്നു, കാരണം കംപൈൽ ചെയ്യുമ്പോൾ, അവ തരം രീതികളായി മാറുന്നു XXX നേടുക, സെറ്റ്XXX. എന്നിരുന്നാലും, കൺസെപ്റ്റ് പ്രോപ്പർട്ടിയെക്കുറിച്ചുള്ള വിവരങ്ങൾ മെറ്റാഡാറ്റയിൽ സംഭരിച്ചിരിക്കുന്നു, അതിനാൽ മറ്റേതെങ്കിലും പിന്തുണയ്ക്കുന്ന ഭാഷാ പ്രോപ്പർട്ടിയിൽ നിന്നും നമുക്ക് അത് ആക്സസ് ചെയ്യാൻ കഴിയും object.PropertyX, പക്ഷേ അല്ല object.GetPropertyX.

ഉദാഹരണത്തിന്:

പബ്ലിക് ക്ലാസ് ടെസ്റ്റ്ക്ലാസ് (പബ്ലിക് ഇൻറ്റ് ടോട്ടൽസം (റിട്ടേൺ കൗണ്ട് * പ്രൈസ്;)) //ഓട്ടോമാറ്റിക് പ്രോപ്പർട്ടി - കംപൈലർ ഫീൽഡുകൾ തന്നെ ജനറേറ്റ് ചെയ്യും പബ്ലിക് ഇൻറ്റ് കൗണ്ട് (ഗെറ്റ്; സെറ്റ്;) പബ്ലിക് ഇൻറ്റ് പ്രൈസ് (നേടുക (റിട്ടേൺ 50;))
ഇത് ഇതിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടും:

പബ്ലിക് ക്ലാസ് ടെസ്റ്റ്ക്ലാസ് ( /* *മറ്റെല്ലാ കോഡുകളും */ സ്വകാര്യ ഇൻറ്റ് k__BackingField; //ഓട്ടോമാറ്റിക് പ്രോപ്പർട്ടി - കംപൈലർ ഫീൽഡുകൾ തന്നെ ജനറേറ്റ് ചെയ്യും പബ്ലിക് ഇൻറ്റ് കൗണ്ട് ( നേടുക ( മടങ്ങുക k__BackingField; ) സെറ്റ് ( k__BackingField = മൂല്യം; )))
പ്രതിനിധികൾ C/C++ ലെ രീതികളിലേക്കുള്ള പോയിന്ററുകളുടെ അനലോഗ് ആണ്. എന്നിരുന്നാലും, അവ സുരക്ഷിതമാണ്. അവരുടെ പ്രധാന ലക്ഷ്യം കോൾബാക്ക് ഫംഗ്ഷനുകൾ, അതുപോലെ ഇവന്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു.

അതേ സമയം, .NET-ലെ പ്രതിനിധികൾ സമ്പൂർണ സൗകര്യങ്ങൾ.

ഈ സമീപനം ജാവയ്ക്കുള്ള ഡാവിഞ്ചി പദ്ധതിയിൽ നിന്ന് അടിസ്ഥാനപരമായി വ്യത്യസ്തമാണ്, കാരണം രണ്ടാമത്തേതിൽ അവർ VM തന്നെ വികസിപ്പിക്കാൻ ശ്രമിക്കുന്നു.

C#-ലെ ഒരു ഉദാഹരണം നോക്കാം:

പബ്ലിക് ക്ലാസ് ടെസ്റ്റ്ക്ലാസ് (പബ്ലിക് ഡെലിഗേറ്റ് int BinaryOp(int arg1, int arg2); public int Add(int a, int b) ( return a + b; ) public int Multiply(int first, int second) (ആദ്യം * സെക്കന്റ് മടങ്ങുക; ) പൊതു ശൂന്യമായ TestDelegates() (BinaryOp op = new BinaryOp(Add); int result = op(1, 2); Console.WriteLine(ഫലം); //ഔട്ട്‌പുട്ട് ചെയ്യും: 3 op = new BinaryOp(Multiply); result = op( 2 , 5); Console.WriteLine(ഫലം); //ഔട്ട്പുട്ട് ചെയ്യും: 10 ) )
കൂടാതെ സിയിലും:

Int Add(int arg1, int arg2) (റിട്ടേൺ arg1 + arg2; ) അസാധുവായ TestFP() (int (*fpAdd)(int, int); fpAdd = //ഫംഗ്ഷൻ പോയിന്റർ int മൂന്ന് = fpAdd(1, 2); / / ഒരു പോയിന്റർ വഴി ഫംഗ്‌ഷനെ വിളിക്കുക)
അപ്പോൾ നമ്മൾ എന്താണ് കാണുന്നത്? C യിൽ നമുക്ക് മറ്റ് തരത്തിലുള്ള പരാമീറ്ററുകളുള്ള ഒരു ഫംഗ്‌ഷനിലേക്ക് ഒരു പോയിന്റർ കൈമാറാൻ കഴിയുമെങ്കിൽ (float arg1, float arg2 എന്ന് പറയുക), C#-ൽ ഇത് അസാധ്യമാണ്. C#-ൽ, കംപൈലേഷൻ ഘട്ടത്തിൽ, മാത്രമല്ല റൺടൈമിലും ഡെലിഗേറ്റുകൾ ഒപ്പും ടൈപ്പ് പരിശോധനയും നടത്തുന്നു.

ഇവന്റുകൾഇവന്റ്-ഡ്രൈവ് പ്രോഗ്രാമിംഗ് നടപ്പിലാക്കാൻ അത്യാവശ്യമാണ്. തീർച്ചയായും, നിങ്ങൾക്ക് EventDispatcher അല്ലെങ്കിൽ പ്രസാധക/സബ്‌സ്‌ക്രൈബർ പാറ്റേൺ ഉപയോഗിച്ച് നേടാനാകും. എന്നിരുന്നാലും, പ്രാദേശിക ഭാഷാ പിന്തുണ കാര്യമായ നേട്ടങ്ങൾ നൽകുന്നു. അതിലൊന്നാണ് തരം സുരക്ഷ.

ഉദാഹരണത്തിന്:

പബ്ലിക് ക്ലാസ് MyClass (പ്രൈവറ്റ് സ്ട്രിംഗ് _വാല്യൂ; പബ്ലിക് ഡെലിഗേറ്റ് അസാധുവാണ് ChangingEventhandler (string oldValue); പൊതു ഇവന്റ് ChangingEventhandler Changing; പൊതു ശൂന്യമായ OnChanging (string oldvalue) (ChangingEventhandler handler = മാറ്റുന്നു; എങ്കിൽ (ഹാൻഡ്ലർ !) = null) ഹാൻഡിൽ); പബ്ലിക് സ്ട്രിംഗ് മൂല്യം (റിട്ടേൺ _മൂല്യം; ) സെറ്റ് (ഓൺചേഞ്ചിംഗ്(_മൂല്യം); _മൂല്യം = മൂല്യം; ) ) പൊതു അസാധുവായ TestEvent() ( MyClass instance = new MyClass(); instance.Changing += new ChangingEventhandler(instance_Changing); ഉദാഹരണം. മൂല്യം = "പുതിയ സ്ട്രിംഗ് മൂല്യം"; //будет вызван метод instance_Changing } void instance_Changing(string oldValue) { Console.WriteLine(oldValue); } } !}
അജ്ഞാത രീതികൾജീവിതത്തെ ഗണ്യമായി ലളിതമാക്കുക - ക്ലാസ് ഘടന വൃത്തിയായി തുടരുന്നു, അതായത്. ക്ലാസിൽ തന്നെ പ്രത്യേക അധിക രീതികൾ സൃഷ്ടിക്കേണ്ട ആവശ്യമില്ല.

അജ്ഞാത രീതികൾ ഉപയോഗിച്ച് ബൈനറി പ്രവർത്തനങ്ങൾ ഉപയോഗിച്ച് മുകളിലുള്ള ഉദാഹരണം പരിഷ്കരിക്കാം:

പബ്ലിക് ക്ലാസ് ടെസ്റ്റ്ക്ലാസ് (പബ്ലിക് ഡെലിഗേറ്റ് int BinaryOp(int arg1, int arg2); പൊതു അസാധുവായ TestDelegates() (BinaryOp op = new BinaryOp(desegate(int a, int b) ( return a + b; )); int result = op( 1, 2); Console.WriteLine(ഫലം); //ഔട്ട്പുട്ട് ചെയ്യും: 3 ) )
നീളം കുറഞ്ഞതും വൃത്തിയുള്ളതുമല്ലേ?

ഇനി നമുക്ക് പരിഗണിക്കാം ലാംഡ പദപ്രയോഗങ്ങൾ.

ഒരു ലാംഡ എക്‌സ്‌പ്രഷൻ എന്നത് എക്‌സ്‌പ്രഷനുകളും ഓപ്പറേറ്റർമാരും അടങ്ങുന്ന ഒരു അജ്ഞാത ഫംഗ്‌ഷനാണ്, കൂടാതെ ഡെലിഗേറ്റുകളോ എക്‌സ്‌പ്രഷൻ ട്രീയോ സൃഷ്‌ടിക്കാനും ഉപയോഗിക്കാം.

പബ്ലിക് ക്ലാസ് ടെസ്റ്റ്ക്ലാസ് (പബ്ലിക് ഡെലിഗേറ്റ് int BinaryOp(int arg1, int arg2); പൊതു ശൂന്യമായ TestDelegates() (BinaryOp op = new BinaryOp((a, b) => a + b); int result = op(1, 2); Console.WriteLine(ഫലം); //ഔട്ട്പുട്ട് ചെയ്യും: 3 ) )
സംഭവങ്ങളുള്ള ഒരു ഉദാഹരണം എങ്ങനെയിരിക്കും? വളരെ ലളിതം:

പൊതു ക്ലാസ് MyClass ( /* * മറ്റെല്ലാ കോഡ് */ പൊതു ശൂന്യമായ TestEvent() ( MyClass instance = new MyClass(); instance.Changing += (o) => Console.WriteLine(o); instance.Value = "(! LANG:പുതിയ സ്ട്രിംഗ് മൂല്യം"; //будет вызван Console.WriteLine } } !}
ശരി, ഞങ്ങൾ കോഡ് കൂടുതൽ കുറച്ചു, അത് ഒരു ഫങ്ഷണൽ ശൈലി പോലെ കാണാൻ തുടങ്ങുന്നു (!!!). അതെ, C# ആണ് പ്രവർത്തന ഭാഷ, കാരണം ഫംഗ്‌ഷനുകൾ ഫസ്റ്റ് ക്ലാസ് ഒബ്‌ജക്‌റ്റുകളാണ്.

ലാംഡ എക്സ്പ്രഷനുകളും അവയ്‌ക്കൊപ്പം എക്സ്പ്രഷൻ ട്രീകളും സൃഷ്ടിച്ചു ലിങ്ക്(ഭാഷാ സംയോജിത ചോദ്യം).

ഇപ്പോഴും LINQ പരിചിതമല്ലേ? LINQ-ലെ പ്രശസ്തമായ MapReduce എങ്ങനെയായിരിക്കുമെന്ന് കാണണോ?

പൊതു സ്റ്റാറ്റിക് ക്ലാസ് MyClass (പബ്ലിക് അസാധുവായ MapReduceTest() (var വാക്കുകൾ = പുതിയത് ("...ചില വാചകം ഇവിടെ പോകുന്നു..."); var wordOccurrences = വാക്കുകൾ .GroupBy(w => w). തിരഞ്ഞെടുക്കുക(ഇന്റർമീഡിയറ്റ് => പുതിയത് ( വാക്ക് = ഇന്റർമീഡിയറ്റ്.കീ, ആവൃത്തി = ഇന്റർമീഡിയറ്റ്. സം(w => 1) .എവിടെ(w => w. ഫ്രീക്വൻസി > 10) .OrderBy(w => w.Frequency); ) )
അല്ലെങ്കിൽ SQL പോലുള്ള വാക്യഘടന ഉപയോഗിക്കുക:

പൊതുവായ അസാധുവായ MapReduceTest() ( സ്ട്രിംഗ് പദങ്ങൾ = പുതിയ സ്ട്രിംഗ് ( "...ചില വാചകങ്ങൾ ഇവിടെ പോകുന്നു..." ); var wordOccurrences = w എന്ന വാക്ക് ഗ്രൂപ്പിലെ w യിൽ നിന്ന് w മുതൽ ഇന്റർമീഡിയറ്റിലേക്ക് പുതിയത് തിരഞ്ഞെടുക്കുക ( Word = intermediate.Key, Frequency = intermediate.Sum((string w) => 1) ) എന്നതിലേക്ക് w. ആവൃത്തി > 10 ക്രമപ്രകാരം w. ഫ്രീക്വൻസി തിരഞ്ഞെടുക്കുക w; )
ഈ ഉദാഹരണത്തിൽ നമ്മൾ LINQ (GroupBy().Select().Where(), etc.) എന്നിവയും അജ്ഞാത ക്ലാസുകളും കാണുന്നു -

പുതിയത് (Word = intermediate.Key, Frequency = intermediate.Sum(w => 1) )
ഹും...ഇവിടെ മറ്റെന്താണ് ഉപയോഗിക്കുന്നത്? ഉത്തരം ലളിതമാണ് - ഒരു ശക്തമായ തരം അനുമാന സംവിധാനം.

ഇവിടെ പ്രധാന വാക്ക് ഒരു പ്രധാന പങ്ക് വഹിക്കുന്നു var. C++11 ന് സമാനമായ രൂപകൽപ്പനയുണ്ട് ഓട്ടോ.

അതിനാൽ ടൈപ്പ് അനുമാനം ഇല്ലാതെ നമ്മൾ ഇങ്ങനെ എഴുതേണ്ടി വരും:

പൊതുവായ അസാധുവായ MapReduceTest() ( സ്ട്രിംഗ് വാക്കുകൾ = പുതിയ സ്ട്രിംഗ് ( "...ചില വാചകങ്ങൾ ഇവിടെ പോകുന്നു..." ); var wordOccurrences = Enumerable.OrderBy(Enumerable.Where(Enumerable.Select(Enumerable.GroupBy (പദങ്ങൾ, ഡെലിഗേറ്റ് (സ്ട്രിംഗ് w) ( മടങ്ങ് w; )), ഡെലിഗേറ്റ് (ഐജിഗ്രൂപ്പിംഗ് ഇന്റർമീഡിയറ്റ്) ( പുതിയത് തിരികെ നൽകുക ( വാക്ക് = ഇന്റർമീഡിയറ്റ്. കീ, ആവൃത്തി = എണ്ണാവുന്ന തുക. (ഇന്റർമീഡിയറ്റ്, (ഫങ് ) (w => 1)) ); )), പ്രതിനിധി (<>f__AnonymousType0 w) ( മടങ്ങുക w. ഫ്രീക്വൻസി > 10; )), പ്രതിനിധി (<>f__AnonymousType0 w) (റിട്ടേൺ w.ഫ്രീക്വൻസി;)); )
[ഈ രീതിഞങ്ങൾക്കായി സൃഷ്ടിച്ച കമ്പൈലർ]

C#-ന്റെ മറ്റെല്ലാ സവിശേഷതകളും അതിന്റെ കംപൈലർ ക്രമീകരണങ്ങളും മറ്റും വിവരിക്കാൻ. ഒന്നിലധികം ലേഖനങ്ങൾ നീക്കിവയ്ക്കേണ്ടത് ആവശ്യമാണ്.

അതേസമയം, C# 5 - ഇത് ഇതിനകം ലഭ്യമാണ്, ഉടൻ തന്നെ ഔദ്യോഗികമായി പുറത്തിറങ്ങും, കൂട്ടിച്ചേർക്കുന്നു അസിൻക്രണസ് പ്രോഗ്രാമിംഗ് , അത് C++11-ലും പ്രത്യക്ഷപ്പെട്ടു!

▌ ഉപസംഹാരം

C# ഉം Java ഉം ശക്തമായ ഭാഷകളാണ്, അതുപോലെ തന്നെ ശക്തമായ പ്ലാറ്റ്‌ഫോമുകളും (.NET, Java). ലേഖനത്തിന്റെ തുടക്കത്തിൽ ഞാൻ ഇതിനകം എഴുതിയതുപോലെ, ഓരോ ജോലിക്കും ഒരു ഉപകരണം ഉണ്ട്.

C# എന്നത് ജാവയുടെ തുടർച്ചയോ പകർപ്പോ അല്ല. മൈക്രോസോഫ്റ്റിൽ ഇത് വികസിപ്പിച്ചെടുക്കുമ്പോൾ പോലും, അതിന്റെ കോഡ് നാമം COOL (C-like Object Oriented Language) എന്നായിരുന്നു. ഈ ലേഖനത്തിൽ C/C++ അനലോഗി എത്ര തവണ ഉദ്ധരിച്ചിട്ടുണ്ട്? മതിയായ അളവ്.

ഭാഷകളും പ്ലാറ്റ്‌ഫോമുകളും തമ്മിലുള്ള വ്യത്യാസങ്ങളുടെ പ്രശ്നം പരിഹരിക്കാൻ (കുറഞ്ഞത് അൽപ്പമെങ്കിലും) എന്റെ ലേഖനം സഹായിച്ചിട്ടുണ്ടെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി!

കൂടാതെ മെമ്മറി റിലീസ് വ്യക്തമായി വ്യക്തമാക്കിയിട്ടില്ല. രണ്ടും അവയുടെ വാക്യഘടനയിൽ സിൻക്രൊണൈസേഷൻ മെക്കാനിസങ്ങൾ ഉൾക്കൊള്ളുന്നു.

Java, C# എന്നിവയ്ക്ക് ശക്തവും ദുർബലവുമായ ഒബ്ജക്റ്റ് റഫറൻസുകൾ ഉണ്ട്. ഒരു ലിങ്ക് മാലിന്യം ശേഖരിക്കുമ്പോൾ സന്ദേശങ്ങൾ സ്വീകരിക്കുന്ന ഒരു ശ്രോതാവിനെ രജിസ്റ്റർ ചെയ്യാൻ Java നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് പ്രകടനം മെച്ചപ്പെടുത്തുന്നു ദുർബലമായ ഹാഷ്മാപ്പ്, അത് C#-ൽ നിലവിലില്ല. ഒരു വസ്തു മാലിന്യം ശേഖരിക്കുമ്പോൾ ഉപയോക്തൃ കോഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ രണ്ട് ഭാഷകളും അനുവദിക്കുന്നു. C#-ൽ, പരിചിതമായ C++ ഡിസ്ട്രക്റ്റർ സിന്റാക്സിലൂടെ പ്രകടിപ്പിക്കുന്ന ഒരു പ്രത്യേക ഫൈനൽ രീതിയാണ് ഇതിനുള്ള സംവിധാനം. ജാവയിൽ, ഒബ്‌ജക്റ്റ് ക്ലാസിൽ പ്രഖ്യാപിച്ചിരിക്കുന്ന അന്തിമ രീതിയെ മറികടക്കുന്നതിലൂടെ ഇത് നേടാനാകും.

ഡാറ്റ തരങ്ങൾ

രണ്ട് ഭാഷകളും ആശയത്തെ പിന്തുണയ്ക്കുന്നു (C# ൽ അറിയപ്പെടുന്നത് മൂല്യ തരങ്ങൾ - മൂല്യ തരങ്ങൾ), കൂടാതെ ആദിമ തരങ്ങളെ ഒബ്‌ജക്‌റ്റ് തരങ്ങളിലേക്ക് വിവർത്തനം ചെയ്യുന്നതിനായി അവയുടെ സ്വയമേവയുള്ള “റാപ്പിംഗ്” ഒബ്‌ജക്റ്റുകളിലേക്കും (ബോക്‌സിംഗ്) “അൺഫോൾഡിംഗ്” (അൺബോക്‌സിംഗ്) നൽകുന്നു. C#-ന് ജാവയെക്കാൾ കൂടുതൽ പ്രാകൃത തരങ്ങളുണ്ട്, ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ തരങ്ങൾ എല്ലാ ഒപ്പിട്ടവയ്‌ക്കൊപ്പം ജോഡികളായി ലഭ്യമാണ്, കൂടാതെ ഉയർന്ന കൃത്യതയുള്ള ഫ്ലോട്ടിംഗ് പോയിന്റ് കണക്കുകൂട്ടലുകൾക്കായി ഒരു പ്രത്യേക ദശാംശ തരവും. ലാളിത്യത്തിനുവേണ്ടി ജാവ ഒപ്പിടാത്ത മിക്ക തരങ്ങളും ഉപേക്ഷിച്ചു. പ്രത്യേകിച്ചും, ജാവയ്ക്ക് ഒരു പ്രാകൃത ഒപ്പിടാത്ത ബൈറ്റ് തരം ഇല്ല.

ചിഹ്നങ്ങളും പ്രത്യേക സവിശേഷതകളും

ജാവയ്ക്ക് ഒരു പ്രത്യേക ഇമ്പോർട്ട് സ്റ്റാറ്റിക് സിന്റാക്സ് ഉണ്ട്, അത് ഒരു ക്ലാസിലെ ചില അല്ലെങ്കിൽ എല്ലാ സ്റ്റാറ്റിക് രീതികൾക്കും വേരിയബിളുകൾക്കും ചുരുക്കിയ പേരുകൾ ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. C#-ന് ഒരു സ്റ്റാറ്റിക് ക്ലാസ് വാക്യഘടനയുണ്ട്, അത് ക്ലാസ്സിനെ മാത്രമായി പരിമിതപ്പെടുത്തുന്നു സ്റ്റാറ്റിക് രീതികൾ ഉപയോഗിച്ച്, എന്നാൽ ഓരോ തവണയും ക്ലാസ് വ്യക്തമായി വ്യക്തമാക്കാതെ ഈ രീതികൾ മാത്രം വ്യക്തമാക്കാൻ മാർഗമില്ല.

പ്രത്യേക കീവേഡുകൾ

കീവേഡ്	അവസരം, ഉപയോഗത്തിന്റെ ഉദാഹരണം
തയ്യാറാകൂ	C# വാക്യഘടന പിന്തുണയ്ക്കുന്നു .
പുറത്ത്, റഫ	ഒന്നിലധികം മൂല്യങ്ങൾ തിരികെ നൽകാൻ നിങ്ങളെ അനുവദിക്കുന്ന രീതി ഔട്ട്പുട്ട് പാരാമീറ്ററുകളെ C# പിന്തുണയ്ക്കുന്നു.
സ്വിച്ച്	C#-ൽ, സ്വിച്ച് സ്റ്റേറ്റ്മെന്റ് സ്ട്രിംഗുകളിലും പ്രവർത്തിക്കുന്നു.
കർശനമായ fp	ഫ്ലോട്ടിംഗ് പോയിന്റ് പ്രവർത്തനങ്ങളുടെ ഫലങ്ങൾ എല്ലാ പ്ലാറ്റ്ഫോമുകളിലും മാറ്റമില്ലാത്തതാണെന്ന് ഉറപ്പാക്കാൻ Java strictfp ഉപയോഗിക്കുന്നു.
പരിശോധിച്ചു, പരിശോധിക്കാത്തത്	C#-ൽ, പരിശോധിച്ച എക്‌സ്‌പ്രഷനുകളിലോ ബ്ലോക്കുകളിലോ റൺ ടൈമിൽ ഗണിത ഓവർഫ്ലോ പരിശോധന ഉൾപ്പെടുത്താം.
ഉപയോഗിക്കുന്നത്	C#"s-ൽ ഉപയോഗിക്കുന്ന കീവേഡ്, സൃഷ്‌ടിച്ച ഒബ്‌ജക്റ്റ് നീക്കം ചെയ്യപ്പെടുകയോ അല്ലെങ്കിൽ പുറത്തുകടക്കുമ്പോൾ അടയ്‌ക്കപ്പെടുകയോ ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നു: ഉപയോഗിച്ച് (സ്‌ട്രീം റൈറ്റർ ഫയൽ = പുതിയ സ്‌ട്രീം റൈറ്റർ("ടെസ്റ്റ്.ടിഎക്‌സ്‌റ്റ്")) (ഫയൽ.റൈറ്റ്("ടെസ്റ്റ്"); )
പോയി	C# ജമ്പ് ഓപ്പറേറ്ററെ പിന്തുണയ്ക്കുന്നു. നിയന്ത്രണം കൈമാറ്റം ചെയ്യുന്നതിനുള്ള കൂടുതൽ ഘടനാപരമായ രീതികൾ സാധാരണയായി ശുപാർശ ചെയ്യപ്പെടുമെങ്കിലും (അതുകൊണ്ടാണ് ഇത് ജാവയിൽ ഉപേക്ഷിച്ചത്) ചിലപ്പോൾ ഇത് ഉപയോഗപ്രദമാകും. ഒരു സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിലെ വ്യത്യസ്ത കേസ് ലേബലുകളിലേക്ക് നിയന്ത്രണം കൈമാറുക എന്നതാണ് C#-ലെ ഗോട്ടോ കീവേഡിന്റെ പൊതുവായ ഉപയോഗം. സ്വിച്ച്(നിറം) (കേസ് കളർ.നീല: കൺസോൾ.റൈറ്റ് ലൈൻ("നിറം നീലയാണ്"); ബ്രേക്ക്; കേസ് കളർ.ഡാർക്ക്ബ്ലൂ: കൺസോൾ.റൈറ്റ് ലൈൻ("നിറം ഇരുണ്ടതാണ്"); ഗോട്ടോ കേസ് കളർ.ബ്ലൂ; // ... )

ഇവന്റ് കൈകാര്യം ചെയ്യൽ

ജാവയ്ക്ക് നിരീക്ഷക പാറ്റേൺ സ്വമേധയാ നടപ്പിലാക്കാൻ പ്രോഗ്രാമർ ആവശ്യപ്പെടുന്നു, എന്നിരുന്നാലും ചിലത് അജ്ഞാത രൂപത്തിൽ നൽകുന്നു, ഇത് ക്ലാസ് ബോഡി നിർവചിക്കാനും കോഡിന്റെ ഒരു ഘട്ടത്തിൽ ഉടൻ തന്നെ അതിന്റെ ഒരു ഉദാഹരണം സൃഷ്ടിക്കാനും നിങ്ങളെ അനുവദിക്കുന്നു. ഈ സവിശേഷത സാധാരണയായി നിരീക്ഷകരെ സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്നു.

.NET ഡെലിഗേറ്റുകൾ, മൾട്ടികാസ്റ്റിംഗ്, ക്ലാസുകളിൽ ഇവന്റുകൾ സജ്ജീകരിക്കുന്നതിനുള്ള പ്രത്യേക വാക്യഘടന, ഇവന്റ് ഹാൻഡ്‌ലറുകൾ രജിസ്റ്റർ ചെയ്യുന്നതിനും അൺരജിസ്റ്റർ ചെയ്യുന്നതിനുമുള്ള പ്രവർത്തനങ്ങൾ, ഡെലിഗേറ്റ് കോവേരിയൻസ്, പൂർണ്ണമായ സെമാന്റിക്‌സുള്ള അജ്ഞാത രീതികൾ എന്നിവയുൾപ്പെടെ ഇവന്റ് പ്രോഗ്രാമിംഗിന് സി# വിപുലമായ ഭാഷാ-തല പിന്തുണ നൽകുന്നു.

Java SE 7-ൽ ഉൾപ്പെടുത്തുന്നതിനായി അടച്ചുപൂട്ടലുകൾ നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു. C#-ലെ ഡെലിഗേറ്റുകൾ പോലെയുള്ള ഈ അടച്ചുപൂട്ടലുകൾക്ക്, അന്തിമമായി അടയാളപ്പെടുത്തിയിരിക്കുന്ന വേരിയബിളുകളിലേക്കുള്ള റീഡ് ആക്‌സസ് (അജ്ഞാത നെസ്റ്റഡ് ക്ലാസുകൾ പോലെ) എന്നതിലുപരി, നൽകിയിരിക്കുന്ന സ്കോപ്പിലെ എല്ലാ പ്രാദേശിക വേരിയബിളുകളിലേക്കും പൂർണ്ണ ആക്‌സസ് ഉണ്ടായിരിക്കും.

ഓപ്പറേഷൻ ഓവർലോഡ്

C#-ൽ ഒരു വലിയ കൂട്ടം നൊട്ടേഷണൽ സൗകര്യങ്ങൾ ഉൾപ്പെടുന്നു, അവയിൽ പലതും, ഓപ്പറേറ്റർ ഓവർലോഡിംഗ്, ഉപയോക്തൃ-നിർവചിക്കപ്പെട്ടത് എന്നിവ പോലെ, C++ പ്രോഗ്രാമർമാർക്ക് പരിചിതമാണ്. ഇതിന് ഇന്റർഫേസ് രീതികളുടെ വ്യക്തമായ നിർവ്വഹണവുമുണ്ട്, ഇത് ഒരു ക്ലാസിനെ അതിന്റെ സ്വന്തം രീതികളിൽ നിന്ന് വേറിട്ട് ഇന്റർഫേസ് രീതികൾ നടപ്പിലാക്കാൻ അനുവദിക്കുന്നു. വ്യത്യസ്ത നടപ്പാക്കലുകൾരണ്ട് വ്യത്യസ്ത ഇന്റർഫേസുകളിൽ പെടുന്ന ഒരേ പേരിലുള്ള രീതികൾ.

ജാവയിൽ ഓപ്പറേറ്റർ ഓവർലോഡിംഗ് ഉൾപ്പെടുന്നില്ല, കാരണം അതിന്റെ ദുരുപയോഗം വായിക്കാൻ ബുദ്ധിമുട്ടുള്ളതും ഡീബഗ് ചെയ്യാൻ ബുദ്ധിമുട്ടുള്ളതുമായ കോഡിലേക്ക് നയിച്ചേക്കാം. അതേസമയം, ജാവയിലെ ഓവർലോഡിന്റെ അഭാവം ചില ഗണിത പ്രോഗ്രാമുകൾക്ക് അനുയോജ്യമല്ല.

രീതികൾ

C#-ൽ, രീതികൾ ഡിഫോൾട്ടല്ല, അങ്ങനെ ചെയ്യുന്നതിന് വെർച്വൽ കീവേഡ് ഉപയോഗിച്ച് വ്യക്തമായി പ്രഖ്യാപിക്കണം. ജാവയിൽ, നേരെമറിച്ച്, സ്റ്റാറ്റിക് ഒഴികെയുള്ള എല്ലാ പൊതു രീതികളും വെർച്വൽ ആണ്. ജാവ ഫൈനൽ കീവേഡ് C#-ൽ സീൽ ചെയ്തതിന്റെ ഒരു അനലോഗ് ആണ് കൂടാതെ ഡിറൈവ്ഡ് ക്ലാസുകളിൽ ഒരേ ഒപ്പുള്ള ഒരു രീതി സൃഷ്ടിക്കുന്നത് നിരോധിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. വിളിക്കുന്ന രീതിക്ക് ആവശ്യമുള്ള ഓവർലാപ്പ് വെർച്വാലിറ്റി ഉറപ്പുനൽകുന്നു, എന്നാൽ കോളുകളിൽ ചില എക്സിക്യൂഷൻ ഓവർഹെഡ് ചുമത്തുന്നു, കാരണം ഈ കോളുകൾ സാധാരണയായി ഇൻലൈൻ സബ്സ്റ്റിറ്റ്യൂഷന് വിധേയമാകാത്തതിനാൽ ലേക്ക് ഒരു അധിക കോൾ ആവശ്യമാണ്. എന്നിരുന്നാലും, സൺ ഉൾപ്പെടെയുള്ള ചില ജെവിഎം നടപ്പിലാക്കലുകൾ, ഏറ്റവും കൂടുതൽ വിളിക്കപ്പെടുന്ന വെർച്വൽ രീതികളുടെ ഇൻലൈൻ സബ്സ്റ്റിറ്റ്യൂഷൻ നടപ്പിലാക്കുന്നു.

ഒരു ഡിറൈവ്ഡ് ക്ലാസിലെ ഒരു വെർച്വൽ രീതി അസാധുവാക്കാനുള്ള ഉദ്ദേശ്യത്തിന്റെ വ്യക്തമായ പ്രഖ്യാപനം C#-ന് ആവശ്യമാണ്. ഈ ഉദ്ദേശം അസാധുവാക്കൽ കീവേഡ് വിവരിച്ചിരിക്കുന്നു. അസാധുവാക്കൽ പ്രോഗ്രാമറുടെ ഉദ്ദേശ്യമല്ലെങ്കിൽ, പഴയതിനെ നിഴൽ നിറയ്ക്കാൻ, അതേ പേരും ഒപ്പും ഉള്ള ഒരു പുതിയ വെർച്വൽ രീതി അവതരിപ്പിക്കാൻ ഒരാൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, മറ്റൊരു കീവേഡ്, പുതിയത് ആവശ്യമാണ്. ഈ വാക്കുകളൊന്നും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, ഇത് ഒരു സമാഹാര പിശകിന് കാരണമാകുന്നു. ജാവയിൽ, ഏത് രീതിയും എല്ലായ്പ്പോഴും അതേ പേരും ഒപ്പും ഉള്ള അടിസ്ഥാന ക്ലാസ് രീതിയെ ഫലത്തിൽ അസാധുവാക്കുന്നു. ബേസ് ക്ലാസ് മറ്റൊരു ഡെവലപ്പർ സൃഷ്ടിച്ചതാണെങ്കിൽ ഈ സ്വഭാവം അപകടകരമാണ്, കൂടാതെ പുതിയ പതിപ്പ് ഡിറൈവ്ഡ് ക്ലാസിൽ നിലവിലുള്ള അതേ രീതിയാണ് അവതരിപ്പിക്കുന്നത്; ഈ സാഹചര്യത്തിൽ, ഡിറൈവ്ഡ് ക്ലാസിൽ നിന്ന് നിലവിലുള്ള രീതി അടിസ്ഥാന ക്ലാസിൽ പുതുതായി അവതരിപ്പിച്ച രീതിയെ മറികടക്കും, ഇത് രണ്ട് ഡെവലപ്പർമാരുടെയും ഉദ്ദേശ്യമല്ല.

സോപാധിക സമാഹാരം

C#, ജാവയിൽ നിന്ന് വ്യത്യസ്തമായി, ഉപയോഗിച്ചുള്ള സോപാധിക സമാഹാരത്തെ പിന്തുണയ്ക്കുന്നു. ഇതിന് ഒരു സോപാധിക ആട്രിബ്യൂട്ടും ഉണ്ട്, അതായത് നൽകിയിരിക്കുന്ന കംപൈലേഷൻ സ്ഥിരാങ്കം നിർവചിക്കുമ്പോൾ മാത്രമേ നിർദ്ദിഷ്ട രീതിയെ വിളിക്കൂ എന്നാണ്. ഈ രീതിയിൽ, നിങ്ങൾക്ക് കോഡിലേക്ക് തിരുകാൻ കഴിയും, ഉദാഹരണത്തിന്, സ്ഥിരീകരണ പരിശോധനകൾ, ഡീബഗ് സ്ഥിരാങ്കം നിർവചിക്കുമ്പോൾ മാത്രം ഡീബഗ് പതിപ്പിൽ പ്രവർത്തിക്കും. .NET സ്റ്റാൻഡേർഡ് ലൈബ്രറിയിൽ, ഇതാണ് Debug.Assert() രീതി. ജാവ പതിപ്പുകൾ 1.4-ഉം പിന്നീടുള്ള പതിപ്പുകളും ഭാഷയിൽ ഒരു റൺ-ടൈം അനുമാന പരിശോധന സവിശേഷത ഉൾപ്പെടുത്തിയിട്ടുണ്ട്.

നെയിംസ്‌പെയ്‌സുകളും ഉറവിട ഫയലുകളും

C# നെയിംസ്‌പേസുകൾ C++ നെ കൂടുതൽ അനുസ്മരിപ്പിക്കുന്നു. ജാവയിൽ നിന്ന് വ്യത്യസ്തമായി, സോഴ്‌സ് ഫയലിന്റെ സ്ഥാനത്തിന് അതിന്റെ നെയിംസ്‌പെയ്‌സുമായി യാതൊരു ബന്ധവുമില്ല. കർശനമായി പറഞ്ഞാൽ, ജാവയിലെ സോഴ്സ് ഫയലുകളുടെ സ്ഥാനം പാക്കേജിന്റെ ഡയറക്ടറി ഘടനയെ പ്രതിഫലിപ്പിക്കണമെന്നില്ല, അത് സ്ഥിരസ്ഥിതി സ്വഭാവമാണ്.

സോഴ്‌സ് ഫയലിന്റെ പേര് അതിൽ നിർവചിച്ചിരിക്കുന്ന ഒരേയൊരു പബ്ലിക് ക്ലാസിന്റെ പേരുമായി കൃത്യമായി പൊരുത്തപ്പെടണമെന്ന് ജാവ ആവശ്യപ്പെടുന്നു, അതേസമയം ഒരു ഫയലിൽ നിരവധി പൊതു ക്ലാസുകൾ നിർവചിക്കാൻ C# നിങ്ങളെ അനുവദിക്കുന്നു കൂടാതെ ഫയലിന്റെ പേരിൽ യാതൊരു നിയന്ത്രണങ്ങളും ഏർപ്പെടുത്തുന്നില്ല, കൂടാതെ (ഇൻ 2.0-ഉം അതിനുമുകളിലും ഉള്ള പതിപ്പുകൾ) ഒരു ക്ലാസ്സിനെ രണ്ടോ അതിലധികമോ ഫയലുകളായി വിഭജിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു (കീവേഡ് ഭാഗികം).

ഒഴിവാക്കലുകൾ

ജാവ പിന്തുണകൾ പരിശോധിച്ചു, എല്ലാം പൂർണ്ണമായി പിടിക്കാനും പ്രോസസ്സ് ചെയ്യാനും നിർബന്ധിതമാക്കുന്നു അസാധാരണമായ സാഹചര്യങ്ങൾ. ഒരു രീതിക്ക് എറിയാൻ കഴിയുന്ന എല്ലാ ഒഴിവാക്കലുകളും അതിന്റെ പ്രഖ്യാപനത്തിൽ ത്രോസ് കീവേഡ് ഉപയോഗിച്ച് ലിസ്റ്റ് ചെയ്യണം. C# പരിശോധിച്ച ഒഴിവാക്കലുകൾ പിന്തുണയ്ക്കുന്നില്ല. ചില ഡെവലപ്പർമാർ പരിശോധിച്ച ഒഴിവാക്കലുകൾ ഉറപ്പാക്കുന്നതിന് വളരെ ഉപയോഗപ്രദമാണെന്ന് കണ്ടെത്തുന്നു നല്ല ശൈലിപ്രോഗ്രാമിംഗ്. C# ന്റെ മുഖ്യ വാസ്തുശില്പിയുൾപ്പെടെ മറ്റുള്ളവർ, ജാവയിൽ അവർ ഒരു പരിധിവരെ ഒരു പരീക്ഷണമായിരുന്നുവെന്നും തങ്ങളെ ന്യായീകരിക്കുന്നില്ലെന്നും വാദിക്കുന്നു.

പരിശോധിച്ച ഒഴിവാക്കലുകൾക്കെതിരായ ഒരു വാദമാണ്, അവ ഉപയോഗിക്കുമ്പോൾ, ഒരു ഫംഗ്ഷന്റെ ആന്തരിക കോഡ് മാറ്റുന്നത് പുതിയ ഒഴിവാക്കലുകൾ എറിയുന്നതിലേക്ക് നയിച്ചേക്കാം, ഇതിന് ഈ ഫംഗ്ഷന്റെ പ്രഖ്യാപനത്തിലും അതിനെ വിളിക്കുന്ന മറ്റെല്ലാവർക്കും മാറ്റം ആവശ്യമാണ്. ഒടുവിൽ, ഇന്റർഫേസ് അനുയോജ്യത നിലനിർത്താൻ, ഫംഗ്‌ഷനുകൾ ത്രോസ് എക്‌സെപ്‌ഷൻ ആയി പ്രഖ്യാപിക്കുന്നത് സാധാരണമായിരുന്നു, അങ്ങനെ പരിശോധിച്ച ഒഴിവാക്കലുകളുടെ മുഴുവൻ ആശയവും നിരാകരിക്കുന്നു. ജാവയിൽ ഇന്റർഫേസ് അനുയോജ്യത നിലനിർത്താനുള്ള മറ്റൊരു മാർഗ്ഗം, പുതുതായി അവതരിപ്പിച്ച ഒഴിവാക്കൽ പിടിക്കുക, പഴയ ഡിക്ലെക്റ്റഡ് ഒന്നിൽ പൊതിഞ്ഞ് വീണ്ടും എറിയുക എന്നതാണ്. ഉദാഹരണത്തിന്, ഒരു രീതി മാറ്റിയാൽ അത് ഡാറ്റാബേസ് ആക്സസ് ചെയ്യാൻ തുടങ്ങും ഫയൽ സിസ്റ്റം, അപ്പോൾ അതിന് SQLException തന്നെ പിടിക്കാനും പകരം പുതുതായി എറിയുന്ന IOException എറിയാനും കഴിയും, കാരണം ഈ രീതിയുടെ ഉപയോക്താവിന് അതിന്റെ ആന്തരിക നിർവ്വഹണത്തിന്റെ വിശദാംശങ്ങളെക്കുറിച്ച് അറിയാൻ പാടില്ല.

താഴ്ന്ന നിലയിലുള്ള കോഡ്

നടപ്പാക്കലുകൾ

ജെവിഎം, സിഎൽആർ

എല്ലാത്തരം ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും പരിതസ്ഥിതികളിലും ജാവ സർവ്വവ്യാപിയാണ്. നിരവധി നടപ്പിലാക്കലുകൾ നിലവിലുണ്ട്, ചിലപ്പോൾ ഓപ്പൺ സോഴ്സ്.

ClickOnce സാങ്കേതികവിദ്യ Java Webstart-ന് സമാനമായ പ്രവർത്തനം വാഗ്ദാനം ചെയ്യുന്നു, എന്നാൽ Windows ക്ലയന്റുകൾക്ക് മാത്രമേ ഇത് ലഭ്യമാകൂ. Windows-ലെ Internet Explorer-നും .NET വിൻഡോസ് ഫോമുകൾ പ്രദർശിപ്പിക്കാൻ കഴിയും, അത് ആപ്‌ലെറ്റ് പോലെയുള്ള പ്രവർത്തനക്ഷമത നൽകുന്നു, എന്നാൽ ഒരു പ്രത്യേക ബ്രൗസറിൽ മാത്രമായി പരിമിതപ്പെടുത്തിയിരിക്കുന്നു.

സ്റ്റാൻഡേർഡൈസേഷൻ

C# ഭാഷ മൈക്രോസോഫ്റ്റ് നിർവ്വചിച്ചിട്ടില്ല, മറിച്ച് സ്റ്റാൻഡേർഡ് കമ്മിറ്റികളും . ജാവ പ്ലാറ്റ്‌ഫോമിൽ പകർപ്പവകാശവും വീറ്റോ അധികാരവും സൺ നിലനിർത്തുമ്പോൾ, രണ്ടാമത്തേത് പ്രധാനമായും നിയന്ത്രിക്കുന്നത് ജാവ കമ്മ്യൂണിറ്റി പ്രോസസ് (ജെസിപി) വഴിയാണ്, ഇത് ജാവ ടെക്‌നോളജി സ്‌പെസിഫിക്കേഷന്റെ പുതിയ പതിപ്പുകളും സവിശേഷതകളും നിർവചിക്കുന്നതിൽ താൽപ്പര്യമുള്ള കക്ഷികളെ ഉൾപ്പെടുത്താൻ അനുവദിക്കുന്നു.

C#, .NET എന്നിവയ്‌ക്കായുള്ള ECMA, ISO മാനദണ്ഡങ്ങൾ ഭാഷ, CLI ചട്ടക്കൂട്, അടിസ്ഥാന ക്ലാസുകൾ (ബേസ് ക്ലാസ് ലൈബ്രറി അല്ലെങ്കിൽ BCL) എന്നിവ നിർവ്വചിക്കുന്നു. ഡാറ്റാബേസുകൾക്കായുള്ള ലൈബ്രറികൾ, GUI-കൾ, വെബ് ആപ്ലിക്കേഷനുകൾ ( , ഒപ്പം ) എന്നിങ്ങനെയുള്ള സ്റ്റാൻഡേർഡ് ചട്ടക്കൂടിന് മുകളിൽ Microsoft നടപ്പിലാക്കിയ പുതിയ ലൈബ്രറികളിൽ പലതും മാനദണ്ഡങ്ങളിൽ ഉൾപ്പെടുന്നില്ല. എന്നിരുന്നാലും, ഈ ലൈബ്രറികൾ നടപ്പിലാക്കുന്നതിനുള്ള കമ്മ്യൂണിറ്റി പ്രോജക്ടുകൾ പ്രോസിക്യൂട്ട് ചെയ്യേണ്ടതില്ലെന്ന് മൈക്രോസോഫ്റ്റ് ഔദ്യോഗികമായി സമ്മതിച്ചിട്ടുണ്ട്.

ഉപയോഗം

സമൂഹം

പ്രവർത്തനത്തിന്റെ വിവിധ മേഖലകളിൽ ഉയർന്ന മത്സരമുള്ള സ്ഥാപനങ്ങളുമായി കൂടുതൽ തുറന്ന സംസ്കാരത്തിലാണ് ജാവ നിർമ്മിച്ചിരിക്കുന്നത്. ഇത് സോഫ്‌റ്റ്‌വെയർ വെണ്ടർ സ്വാതന്ത്ര്യത്തിന്റെ പ്രശ്നം പൂർണ്ണമായും പരിഹരിക്കുന്നുവെങ്കിലും, ഇത് ഭാഷയ്ക്ക് കൂടുതൽ സങ്കീർണ്ണത നൽകുന്നു. ലൈബ്രറികളും ഘടകങ്ങളും വിജയകരമായി ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ ജാവ മാത്രമല്ല, എല്ലാ മത്സരിക്കുന്ന ഷെല്ലുകളും ചട്ടക്കൂടുകളും നടപ്പാക്കലുകളുടെ വിവിധ "തന്ത്രങ്ങളും" അറിയേണ്ടതുണ്ട്.

ജനപ്രീതിയും വികസനവും

ജാവ C# നേക്കാൾ പഴക്കമുള്ളതും വലുതും സജീവവുമായ ഒരു ഉപയോക്തൃ അടിത്തറയിലാണ് നിർമ്മിച്ചിരിക്കുന്നത് കമ്പ്യൂട്ടർ സയൻസിന്റെ പല ആധുനിക മേഖലകളിലും, പ്രത്യേകിച്ച് അവിടെ . അമേരിക്കൻ സർവ്വകലാശാലകളിലെയും കോളേജുകളിലെയും പ്രോഗ്രാമിംഗ് കോഴ്‌സുകളിൽ ജാവ ആധിപത്യം പുലർത്തുന്നു, കൂടാതെ C#-നേക്കാൾ ഇന്ന് ജാവയിൽ കൂടുതൽ സാഹിത്യമുണ്ട്. ജാവയുടെ പക്വതയും ജനപ്രീതിയും C#-ൽ ഉള്ളതിനേക്കാൾ കൂടുതൽ ലൈബ്രറികളും API-കളും ജാവയിൽ (അവയിൽ പലതും ഓപ്പൺ സോഴ്‌സ് ആണ്) ഉണ്ടാകാൻ കാരണമായി.

ജാവയിൽ നിന്ന് വ്യത്യസ്തമായി, C# താരതമ്യേന പുതിയ ഭാഷയാണ്. മൈക്രോസോഫ്റ്റ് നിലവിലുള്ള ജാവ പോലുള്ള ഭാഷകൾ പഠിച്ചു, കൂടാതെ ചില തരത്തിലുള്ള ആപ്ലിക്കേഷനുകളുടെ ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ രീതിയിൽ ഭാഷയുടെ ചില വശങ്ങൾ മാറ്റി. കാലക്രമേണ, ജാവയുടെ താത്കാലിക നേട്ടത്തിന് പ്രാധാന്യം കുറയുന്നു.

ജാവയെക്കുറിച്ച് കേൾക്കാവുന്ന ഒരു വിമർശനം, അത് വികസിക്കുന്നത് മന്ദഗതിയിലാണെന്നും ഫാഷനബിൾ പ്രോഗ്രാമിംഗ് പാറ്റേണുകളും രീതിശാസ്ത്രങ്ങളും വഴി സുഗമമാക്കുന്ന ചില സവിശേഷതകളില്ല എന്നതാണ്. ഭാഷയുടെ ശ്രദ്ധയും ലാളിത്യവും കാരണം പ്രോഗ്രാമിംഗിലെ നിലവിലെ ട്രെൻഡുകൾ ഉൾക്കൊള്ളാൻ അതിന്റെ ഡെവലപ്പർമാർ വളരെ ഉത്സുകരാണ് എന്നതാണ് C# ഭാഷയെക്കുറിച്ചുള്ള വിമർശനം. ജാവയുടെ ഡിസൈനർമാർ മറ്റ് ആധുനിക ഭാഷകളെ അപേക്ഷിച്ച് ഭാഷയുടെ വാക്യഘടനയിൽ പ്രധാന പുതിയ സവിശേഷതകൾ ചേർക്കുന്നതിന് കൂടുതൽ യാഥാസ്ഥിതികമായ സമീപനമാണ് സ്വീകരിച്ചത്-ഒരുപക്ഷേ, ദീർഘകാലാടിസ്ഥാനത്തിൽ നിർജീവാവസ്ഥയിലേക്ക് നയിച്ചേക്കാവുന്ന പ്രവണതകളിലേക്ക് ഭാഷയെ പ്രതിഷ്ഠിക്കാൻ തയ്യാറായില്ല. Java 5.0 ഈ പ്രവണതയെ പല തരത്തിൽ പ്രോത്സാഹിപ്പിച്ചു, കാരണം അത് ഭാഷയുടെ നിരവധി പ്രധാന പുതിയ സവിശേഷതകൾ അവതരിപ്പിച്ചു: foreach loop, automatic wrapping, variadic methods, enumerated types, generics, and annotations (ഇവയെല്ലാം C#-ൽ ഉണ്ട്) .

C#, അതാകട്ടെ, വേഗത്തിൽ വികസിക്കുന്നു, പുതിയ പ്രശ്‌ന-നിർദ്ദിഷ്‌ട സവിശേഷതകൾ ചേർക്കുന്നതിൽ സ്വയം പരിമിതപ്പെടുത്തുന്നു. C# 3.0-ന്റെ വരാനിരിക്കുന്ന പതിപ്പിൽ ഈ പ്രവണത പ്രത്യേകിച്ചും പ്രകടമായിരുന്നു, ഉദാഹരണത്തിന്, -പോലുള്ള ചോദ്യങ്ങൾ പ്രത്യക്ഷപ്പെട്ടു. (ഭാഷയെ ഒരു പൊതു-ഉദ്ദേശ്യ ഭാഷയായി നിലനിർത്തുന്നതിനാണ് പുതിയ സവിശേഷതകൾ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. C# 3.0-നെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക്, കാണുക.

വർദ്ധിച്ചുവരുന്ന നെറ്റ്‌വർക്ക് ലോകത്ത്, പ്രത്യേകിച്ച് പേഴ്‌സണൽ കമ്പ്യൂട്ടറുകൾ ഒഴികെയുള്ള ഉപകരണങ്ങളിൽ ഇൻറർനെറ്റിന്റെ വരവോടെ ജാവയുടെ നേതൃത്വത്തിലുള്ള കോഡ് പരിതസ്ഥിതിക്ക് ധാരാളം ഗുണങ്ങളുണ്ടെന്ന മൈക്രോസോഫ്റ്റിന്റെ അംഗീകാരത്തിന്റെ ഫലമാണോ C#-ന്റെ വികസനം എന്നത് തർക്കവിഷയമാണ്. നെറ്റ്‌വർക്ക് സുരക്ഷയുടെ പ്രാധാന്യം. C# സൃഷ്‌ടിക്കുന്നതിന് മുമ്പ്, OS-ൽ മാത്രം പ്രവർത്തിക്കുന്ന ഫീച്ചറുകൾ ചേർക്കുന്നതിനായി Microsoft ജാവയെ പരിഷ്‌ക്കരിച്ചു, അങ്ങനെ ലൈസൻസ് കരാർ ലംഘിച്ചു. എന്നറിയപ്പെടുന്ന മൈക്രോസോഫ്റ്റ് അതിന്റെ ബിസിനസ്സ് തന്ത്രത്തിന്റെ രണ്ടാം ഘട്ടത്തിലായിരുന്നു , J++ ന്റെ വികസനം സൺ ഫയൽ ചെയ്ത ഒരു വ്യവഹാരത്താൽ തടഞ്ഞു.തങ്ങൾക്ക് ആവശ്യമുള്ള ഫീച്ചറുകളുള്ള ഒരു ജാവ ക്ലോൺ വികസിപ്പിക്കാനുള്ള അവസരം നഷ്ടപ്പെട്ടതിനാൽ, മൈക്രോസോഫ്റ്റ് അവരുടെ ആവശ്യങ്ങൾക്കും ഭാവിയെക്കുറിച്ചുള്ള കാഴ്ചപ്പാടിനും അനുയോജ്യമായ ഒരു ബദൽ സൃഷ്ടിച്ചു.

ഈ പ്രക്ഷുബ്ധമായ തുടക്കം ഉണ്ടായിരുന്നിട്ടും, വിപണിയിൽ രണ്ട് ഭാഷകൾ പരസ്പരം മത്സരിക്കുന്നത് അപൂർവ്വമായിട്ടാണെന്ന് കൂടുതൽ വ്യക്തമാകുകയാണ്. മൊബൈൽ മേഖലയിൽ ആധിപത്യം പുലർത്തുന്ന ജാവയ്ക്ക് വെബ് ആപ്ലിക്കേഷൻ വിപണിയിൽ നിരവധി അനുയായികളുണ്ട്. വിൻഡോസ് ഡെസ്‌ക്‌ടോപ്പ് ആപ്ലിക്കേഷൻ മാർക്കറ്റിൽ സി#ക്ക് നല്ല സ്വീകാര്യത ലഭിച്ചു, കൂടാതെ വിൻഡോസ് ആപ്ലിക്കേഷനുകളുടെ പ്രാഥമിക ഭാഷയായി മൈക്രോസോഫ്റ്റ് മുന്നോട്ട് കൊണ്ടുപോകുന്നു. നന്ദി, C# വെബ് ആപ്ലിക്കേഷൻ വിപണിയിലെ ഒരു കളിക്കാരൻ കൂടിയാണ്.

ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകൾ

ഡെസ്‌ക്‌ടോപ്പ് ആപ്ലിക്കേഷനുകളുടെ കാര്യത്തിൽ ജാവ ചിലപ്പോഴൊക്കെ അമിത വാഗ്ദാനവും ഡെലിവറി ചെയ്യുന്നില്ലെന്നും ആരോപിക്കപ്പെടുന്നു. അതിന്റെ AWT (അബ്‌സ്‌ട്രാക്റ്റ് വിൻഡോവിംഗ് ടൂൾകിറ്റ്) ജാലക ലൈബ്രറികൾ കഴിവുകളുടെ സമ്പത്ത് അഭിമാനിക്കുന്നുണ്ടെങ്കിലും, ഡെസ്‌ക്‌ടോപ്പ് ആപ്ലിക്കേഷൻ വിപണിയിൽ സ്വയം സ്ഥാപിക്കാൻ ജാവയ്ക്ക് പാടുപെടേണ്ടിവന്നു. അവളുടെ തത്ത്വങ്ങൾ കർശനമായി പാലിക്കൽ<пишем один раз, используем везде>ഓരോ നിർദ്ദിഷ്‌ട ഡെസ്‌ക്‌ടോപ്പ് സിസ്റ്റത്തിലെയും പ്രത്യേക കഴിവുകളും പ്രവർത്തന രീതികളും പരമാവധി പ്രയോജനപ്പെടുത്തുന്നത് ബുദ്ധിമുട്ടാക്കുന്നു. തൽഫലമായി, ജാവയിൽ എഴുതിയ ഡെസ്ക്ടോപ്പ് ആപ്ലിക്കേഷനുകൾ പലപ്പോഴും ഇങ്ങനെയാണ് കാണപ്പെടുന്നത്<чужие>അവർ വധിക്കപ്പെട്ട പ്ലാറ്റ്ഫോമിൽ.

ഡെസ്‌ക്‌ടോപ്പ് ആപ്ലിക്കേഷനുകളെ ആകർഷകമാക്കുന്ന തരത്തിൽ ഡെവലപ്പർമാർക്കും ഉപയോക്താക്കൾക്കും ജാവയെ പ്രൊമോട്ട് ചെയ്യുന്നതിൽ സൺ മൈക്രോസിസ്റ്റംസ് മന്ദഗതിയിലാണെന്ന് ചിലർ പറയുന്നു. ഭാഷകൾക്കും പ്ലാറ്റ്‌ഫോമുകൾക്കുമിടയിൽ കുറച്ച് എതിരാളികളുള്ള ജാവ വെബ് സ്റ്റാർട്ട് പോലുള്ള സാങ്കേതികവിദ്യകൾ പോലും മോശമായി പ്രോത്സാഹിപ്പിക്കപ്പെട്ടു.

2006-ൽ പ്രതീക്ഷിച്ച ജാവ പതിപ്പ് 6.0-ന്റെ റിലീസ് ഡെസ്‌ക്‌ടോപ്പ് വിപണിയിൽ വീണ്ടും ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു - ഡെസ്‌ക്‌ടോപ്പ് പരിതസ്ഥിതിയുമായി മികച്ചതും കർശനവുമായ സംയോജനത്തിനായി വിപുലമായ പുതിയതും രസകരവുമായ ടൂളുകൾ.

ഹൈടെക്

ബിഡി-ജെ ഇന്ററാക്ടീവ് പ്ലാറ്റ്‌ഫോം വഴി ഡിവിഡി നിലവാരത്തിന്റെ അടുത്ത തലമുറയിൽ ഉപയോഗിക്കുന്നതിനുള്ള ഔദ്യോഗിക സോഫ്‌റ്റ്‌വെയറായി ജാവ സ്വീകരിച്ചു. ഇതിനർത്ഥം മെനുകൾ, ഗെയിമുകൾ, ഡൗൺലോഡുകൾ മുതലായവ പോലെയുള്ള സംവേദനാത്മക ഉള്ളടക്കം എല്ലാ ഡ്രൈവുകളിലും ഉണ്ടെന്നാണ് ഡിവിഡി ബ്ലൂ-റേജാവ പ്ലാറ്റ്ഫോമിൽ സൃഷ്ടിക്കപ്പെടും.