உங்கள் .NET திறன்களை சோதிக்க 7 முக்கிய கருத்துக்கள்

தங்கள் .NET நிபுணத்துவத்தை நிரூபிக்க விரும்பும் எவருக்கும் இந்தக் கட்டுரை சரியானது!

வணக்கம் .NET டெவலப்பர்கள்,

இந்தக் கட்டுரையில், ஒவ்வொரு டெவலப்பரும் தெரிந்துகொள்ள வேண்டிய வெவ்வேறு C# கருத்துகளை நான் ஆராய்வேன். உங்கள் அறிவைச் சோதிப்பது எப்போதுமே ஒரு சிறந்த யோசனையாகும், மேலும் இந்த கட்டுரையில் விளக்கங்கள் மற்றும் குறியீடு எடுத்துக்காட்டுகளுடன் சில எடுத்துக்காட்டுகளை ஒன்றாக இணைத்துள்ளேன்.

குறியீட்டு எடுத்துக்காட்டுகளை நீங்கள் அறிந்திருந்தால் மற்றும் புரிந்து கொண்டால், நீங்கள் .NET இல் சிறப்பாக செயல்படுவீர்கள்.

1. IEnumerable<T> vs. Icollection<T> இடையே உள்ள வேறுபாடு

C# இல் தர்க்கத்தை எழுதும் போது, டெவலப்பர்கள் IEnumerable<T> மற்றும் ICollection<T> ஐ அடிக்கடி சந்திக்கின்றனர். அவை மிகவும் ஒத்ததாக இருக்கலாம், ஆனால் அவை மென்பொருள் உருவாக்கத்தில் வெவ்வேறு நோக்கங்களுக்காக சேவை செய்கின்றன.

• IEnumerable<T> பொதுவான அல்லாத சேகரிப்புகளுக்கான அடிப்படை இடைமுகமாக செயல்படுகிறது. இது வரையறுக்கப்பட்ட வகையின் தொகுப்பை மீண்டும் செய்ய உதவுகிறது.

தரவு கையாளுதல் அனுமதிக்கப்படாததால், மிகவும் பாதுகாப்பான ஒரு இலகுரக சேகரிப்பை வைத்திருப்பது நல்லது. எந்தவொரு சேகரிப்பும் தரவு கையாளுதலைத் தடுக்க விரும்பினால், IEnumerable<T> ஐப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது

 IEnumerable<int> numbers = new List<int> { 1, 2, 3 }; foreach (var number in numbers) { Console.WriteLine(number); // Outputs: 1 2 3 }

• Icollection<T> விரிவாக்கம் IEnumerable<T> மாற்றும் முறைகளின் உதவியுடன் மாற்றங்களை அனுமதிக்கிறது. இந்த இடைமுகம் சேகரிப்பில் எண்ணிக்கையைச் சேர்க்க, நீக்க மற்றும் சரிபார்க்கும் முறைகளைக் கொண்டுள்ளது.

  
  

 ICollection<int> data = new List<int> { 12,43,556}; numbers.Add(4); Console.WriteLine(data.Count); // Outputs: 4

சேகரிப்புக்கு மாற்று முறைகள் தேவைப்படும்போது Icollection<T> மற்றும் எளிமையான வாசிப்பு செயல்களுக்கு IEnumerable<T> பரிந்துரைக்கப்படுகிறது.

2. நெட் கோரில் சார்பு ஊசியின் பங்கு

நீங்கள் தளர்வாக இணைக்கப்பட்ட & சோதிக்கக்கூடிய குறியீட்டை எழுத விரும்பினால், DI வடிவமைப்பு வடிவத்தைப் பயன்படுத்த பரிந்துரைக்கப்படுகிறது, i. DI உடன், டெவலப்பர்கள் வகுப்புகளுக்கு இடையே உள்ள சார்புகளை எளிதாக நிர்வகிக்க முடியும்.

.NET கோர் DIக்கான உள்ளமைக்கப்பட்ட ஆதரவைக் கொண்டுள்ளது, இது செயல்படுத்துவதை எளிதாக்குகிறது.

ஒரு டெவலப்பர் எப்படி C# இல் DI ஐ செயல்படுத்த முடியும்

• உங்கள் Startup.cs கோப்பின் ConfigureServices முறையில் சேவைகளைப் பதிவுசெய்யவும் . ஊசி போடுவதற்கு எந்தச் சேவைகள் கிடைக்கும் என்பதை இங்குதான் நீங்கள் வரையறுக்கிறீர்கள்.

 public void ConfigureServices(IServiceCollection services) { // Register a transient service services.AddTransient<IMyService, MyService>(); }

• கன்ஸ்ட்ரக்டர் ஊசி மூலம் உங்கள் வகுப்புகளில் சேவைகளைப் புகுத்தவும் . உங்கள் வகுப்புகள் நேரடியாக உருவாக்க வேண்டிய அவசியமின்றி அவற்றின் சார்புகளைப் பெறுவதை இது உறுதி செய்கிறது.

 public class MyController : Controller { private readonly IMyService _myService; public MyController(IMyService myService) { _myService = myService; } public IActionResult Index() { var data = _myService.GetData(); return View(data); } }

ஒரு டெவலப்பர் சேவைகளின் உருவாக்கத்தை துண்டிக்கும்போது ஒரு குறியீடு மிகவும் பராமரிக்கக்கூடியது மற்றும் சோதிக்கக்கூடியது.

3. ref மற்றும் out அளவுருக்களுக்கு இடையே உள்ள வேறுபாடு

C# இல், குறிப்பு மூலம் அளவுருக்களை அனுப்ப, ref மற்றும் out ஆகியவை பயன்படுத்தப்படுகின்றன, ஆனால் அவை தனித்துவமான பண்புகளைக் கொண்டுள்ளன.

• ref அளவுருக்கள் ஒரு முறைக்கு அனுப்பும் முன் மாறி துவக்கப்பட வேண்டும். முறையானது மாறியின் மதிப்பை மாற்றியமைக்க முடியும்.

 public void UpdateValue(ref int number) { number += 10; } int myNumber = 5; UpdateValue(ref myNumber); Console.WriteLine(myNumber); // Outputs: 15

• அவுட் அளவுருக்கள் கடந்து செல்லும் முன் துவக்கம் தேவையில்லை. முறை திரும்பும் முன் அவுட் அளவுருவிற்கு மதிப்பை ஒதுக்க வேண்டும்.

 public void GetValues(out int value1, out int value2) { value1 = 10; value2 = 20; } GetValues(out int a, out int b); Console.WriteLine(a); // Outputs: 10 Console.WriteLine(b); // Outputs: 20

ஒரு முறை ஏற்கனவே உள்ள மாறியை மாற்றியமைக்க வேண்டியிருக்கும் போது ref பொதுவாகப் பயன்படுத்தப்படுகிறது, அதே சமயம் ஒரு முறை பல மதிப்புகளைத் திரும்பப் பெற அல்லது அழைப்பாளரால் வழங்கப்படாத மதிப்புகளைத் தொடங்கும் போது அவுட் பயன்படுத்தப்படுகிறது.

4. ஒத்திசைவு மற்றும் காத்திருப்பு: பயன்பாட்டு செயல்திறனை மேம்படுத்துதல்

.NET இல், சுமையின் கீழ் சிறப்பாக செயல்படும் திறமையான பயன்பாடுகளை எழுதுவதற்கு ஒத்திசைவற்ற நிரலாக்கம் அவசியம். ஒத்திசைவு மற்றும் காத்திருக்கும் முக்கிய வார்த்தைகள் ஒத்திசைவற்ற செயல்பாடுகளுடன் வேலை செய்வதை எளிதாக்குகின்றன.

• ஒத்திசைவு முறைகள் ஒத்திசைவற்ற முறையில் பணிகளைச் செய்ய உங்களை அனுமதிக்கின்றன. அதன் உள்ளே காத்திருப்பு பயன்பாட்டை இயக்க, ஒத்திசைவு முக்கிய சொல்லைக் கொண்டு ஒரு முறையைக் குறிக்கவும்.

 public async Task<string> FetchDataAsync() { await Task.Delay(1000); // Simulates an asynchronous operation return "Data fetched"; }

• முக்கிய தொடரிழையைத் தடுக்காமல், பயன்பாட்டு UIக்கு காத்திருக்கிறது .

 public async Task ShowDataAsync() { string data = await FetchDataAsync(); Console.WriteLine(data); }

உங்கள் பயன்பாட்டின் செயல்திறனை மேம்படுத்த விரும்பினால், ஒத்திசைவைப் பயன்படுத்தவும் மற்றும் திறம்பட காத்திருக்கவும், அதே நேரத்தில் பயன்பாட்டு UI ஐப் பதிலளிக்கவும்.

5. நெட் கோர் பயன்பாடுகளில் விதிவிலக்கு கையாளுதல்

வலுவான மற்றும் பயனர் நட்பு பயன்பாடுகளைப் பராமரிக்க விதிவிலக்குகளை அழகாகக் கையாள்வது மிகவும் முக்கியமானது. .NET கோர் விதிவிலக்கு கையாளுதலுக்கான பல்வேறு வழிமுறைகளை வழங்குகிறது.

• உள்ளூர் விதிவிலக்கு கையாளுதல்: விதிவிலக்குகளைப் பிடிக்கவும் கையாளவும் முயற்சி-பிடிப்புத் தொகுதிகளைப் பயன்படுத்தவும்.

 try { int result = 10 / 0; // This will throw a DivideByZeroException } catch (DivideByZeroException ex) { Console.WriteLine("An error occurred: " + ex.Message); }

• ASP.NET Core இல் உலகளாவிய விதிவிலக்கு கையாளுதலை மிடில்வேரைப் பயன்படுத்தி நிர்வகிக்கலாம். எல்லா வகையான விதிவிலக்குகளையும் பொதுவான இடத்தில் பார்க்கலாம், இது டெவலப்பர்களுக்கு பயனர் நட்பு/பொதுவான பிழைச் செய்திகளை நிர்வகிக்க உதவுகிறது.

 public void Configure(IApplicationBuilder app) { app.UseExceptionHandler("/Home/Error"); }

உலகளாவிய விதிவிலக்கு கையாளுதல் மிடில்வேர் அனைத்து பயன்பாட்டு பிழைகள் மற்றும் விதிவிலக்குகளைக் கையாள ஒரு பொதுவான இடத்தை வழங்குகிறது. பயன்பாடு தொடர்ந்து பதில்களைக் கையாளுவதை இது உறுதி செய்கிறது.

6. appsettings.json ASP.NET கோரின் பங்கு

appsettings.json கோப்பு, உள்ளமைவு சரங்கள் மற்றும் பிற பயன்பாடு சார்ந்த விசைகள் போன்ற பயன்பாட்டுச் சான்றுகளை நிர்வகிக்கப் பயன்படுகிறது. கட்டமைப்பு அமைப்புகளை சூழலுக்கு ஏற்ப பிரிக்கலாம்

• எடுத்துக்காட்டு appsettings.json கோப்பு:

 { "ConnectionStrings": { "DefaultConnection": "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;" }, "Logging": { "LogLevel": { "Default": "Warning" } } }

• உள்ளமைக்கப்பட்ட உள்ளமைவு அமைப்பைப் பயன்படுத்தி உங்கள் பயன்பாட்டில் உள்ளமைவு மதிப்புகளை அணுகுவது நேரடியானது.

 public class MyService { private readonly string _connectionString; public MyService(IConfiguration configuration) { _connectionString = configuration.GetConnectionString("DefaultConnection"); } }

appsettings.json கோப்பு, உள்ளமைவு அமைப்புகளை எளிதாகப் பெற அனுமதிக்கிறது, திறமையாக கையாள வேண்டும்.

7. C# இல் த்ரெட் எதிராக பணி புரிந்து

டாஸ்க் மற்றும் த்ரெட் இரண்டும் C# இல் ஒரே நேரத்தில் நிரலாக்கத்திற்குப் பயன்படுத்தப்படுகின்றன, ஆனால் அவை வெவ்வேறு நோக்கங்களுக்குச் சேவை செய்கின்றன.

• த்ரெட் என்பது ஒரு ஒற்றைப் பாதையைக் குறிக்கிறது மற்றும் இது ஒரு கீழ்-நிலை கட்டமைப்பாகும். இது செயல்படுத்துவதில் கூடுதல் கட்டுப்பாட்டை வழங்குகிறது ஆனால் கைமுறை மேலாண்மை தேவைப்படுகிறது.

 Thread thread = new Thread(() => { Console.WriteLine("Running on a new thread"); }); thread.Start();

• பணியானது ஒத்திசைவு செயல்பாடுகளைச் செயல்படுத்த ஒரு சுருக்கமான செயல்பாட்டை வழங்குகிறது மற்றும் இது ஒத்திசைவு/காத்திருப்புடன் பயன்படுத்தப்படுகிறது.

 Task.Run(() => { Console.WriteLine("Running asynchronously"); });

பணிகள் ஒத்திசைவற்ற செயல்பாடுகளின் நிர்வாகத்தை எளிதாக்குகின்றன மற்றும் நவீன C# மேம்பாட்டிற்கு பெரும்பாலும் விருப்பமான தேர்வாகும்.

எனவே, நீங்கள் எப்படி செய்தீர்கள்?

நீங்கள் நம்பிக்கையுடன் கருத்தை அறிந்திருந்தால் மற்றும் குறியீட்டு எடுத்துக்காட்டுகளைப் புரிந்து கொண்டால், நீங்கள் .NET இல் நன்கு அறிந்தவராக இருக்கலாம்.

உரையாடலைத் தொடர்வோம், ஒருவருக்கொருவர் .NET நிபுணர்களாக வளர உதவுவோம்.

மகிழ்ச்சியான குறியீட்டு!