Namespaces மற்றும் using directives எவ்வாறு செயல்படுகின்றன?

Question

Accepted Answer

**Namespaces** கோடை தருக்க குழுக்களாக ஏற்பாடு செய்கின்றன மற்றும் பெயர் மோதல்களைத் தடுக்கின்றன (வகைகளுக்கான கோப்புறைகள் போன்றவை). **`using` directives** namespaces ஐ import செய்கின்றன, இதனால் நீங்கள் அவற்றின் வகைகளை குறுகிய பெயரில் குறிப்பிடலாம். ஒன்றாக இவை C# கோடை கட்டமைக்கின்றன மற்றும் பரந்த .NET நூலகத்தை அணுக இயலுகின்றன. ## Namespaces ஐ அறிவிப்பது ```csharp // declare a namespace (conventionally matching the folder structure) namespace MyApp.Services; // file-scoped namespace (C# 10) — applies to the whole file public class UserService { } // fully-qualified name: MyApp.Services.UserService // or block-scoped (traditional) namespace MyApp.Models { public class User { } } ``` ஒரு namespace தொடர்புடைய வகைகளை ஒரு பெயரின் கீழ் குழுப்படுத்துகிறது (`MyApp.Services.UserService`), வெவ்வேறு namespaces இல் உள்ள ஒரே பெயரிலான வகுப்புகளுக்கு இடையே மோதல்களைத் தடுக்கிறது. File-scoped namespaces (C# 10) nesting ஐ குறைக்கிறது. ## using directives — namespaces ஐ import செய்யுங்கள் ```csharp using System; // import → use Console instead of System.Console using System.Collections.Generic; // → List, Dictionary using System.Linq; // → LINQ extension methods using MyApp.Services; // your own namespaces Console.WriteLine("hi"); // short name works thanks to `using System;` var list = new List(); // thanks to the Generic using ``` ஒரு கோப்பின் உச்சியில் `using` ஒரு namespace ஐ import செய்கின்றன, இதனால் அதன் வகைகள் குறுகிய பெயரால் கிடைக்கின்றன (முழு-qualified பெயரைக் காட்டிலும்). நீங்கள் இந்த வழியில் தேவையான .NET நூலகங்களை import செய்கிறீர்கள். ## using aliases மற்றும் global usings ```csharp using Project = MyApp.Models.Project; // ALIAS — resolve a name conflict or shorten // GLOBAL using (C# 10) — apply to the ENTIRE project, declared once global using System; global using System.Collections.Generic; // → no need to repeat common usings in every file (often auto-generated) ``` **Global usings** (C# 10) முழு திட்டத்திற்கும் imports ஐ ஒரு முறை அறிவிக்கிறது — நவீன .NET சாதாரணமான உள்ளனவை தானாக-include செய்கிறது (`ImplicitUsings`), எனவே நீங்கள் இப்போது `using System;` ஐ அரிதாகவே எழுதுவீர்கள். ## குறிப்பு: using directive vs using statement ```csharp using var file = File.OpenText("x.txt"); // using STATEMENT — auto-disposes (different feature!) ``` ## இது ஏன் முக்கியமானது Namespaces மற்றும் using directives கள் C# கோடை ஏற்பாடு செய்ய மற்றும் .NET சுற்றுச்சூழலை அணுக அடிப்படை ஆகும், எனவே அவற்றைப் புரிந்துகொள்வது அத்தியாவசிய দৈনந்தின ஞ்ஞானம். **Namespaces** வகைகளை தருக்க குழுக்களாக ஏற்பாடு செய்கின்றன (கோப்புறை கட்டமைப்பை பிரதிபலிக்கிறது) மற்றும் **பெயர் மோதல்களைத்** தடுக்கிறது — அவையில்லாமல், உங்கள் வகுப்புக்கள் ஒன்றுக்கொன்று மற்றும் பரந்த .NET நூலகம் மற்றும் மூன்றாம் পক்ష தொகுப்புகளுடன் மோதி இருக்கும். **`using` directives** நூலகத்தை அணுகுவது எப்படி என்பதாகும்: namespaces ஐ import செய்து அவற்றின் வகைகளை (`Console`, `List`, LINQ முறைகள்) குறுகிய பெயரில் பயன்படுத்த முடியும் — முழு-qualified பெயரின் பதிலாக — ஒவ்வொரு C# கோப்பும் framework இயல்பாக அணுக usings ஐ நம்பியுள்ளது. Namespaces ஐ அறிவிப்பது எப்படி (நவீன file-scoped syntax உள்பட), using கள்ஐ import செய்வது, மோதல்களைத் தீர்க்க aliases ஐ பயன்படுத்துவது, மற்றும் **global usings** ஐ (C# 10, முழு திட்டத்திற்கும் சாதாரணமான imports ஐ ஒரு முறை அறிவிப்பது — இப்போது பெரும்பாலும் ImplicitUsings வழியாக தானாக-உৎপன்னம், எனவே நீங்கள் boilerplate usings ஐ அரிதாகவே எழுதுவீர்கள்) செயல்படுத்துவது திட்டங்களை கட்டமைக்கவும் framework ஐ பயன்படுத்தவும் தேவை. Namespaces மற்றும் usings ஐ புரிந்துகொள்வது — கோடு organization, collision prevention, .NET நூலகத்தை அணுகல், மற்றும் நவீன global/implicit usings இவை boilerplate ஐ குறைக்கின்றன — எந்த C# development க்கும் அடிப்படை, ஏனெனில் ஒவ்வொரு நிரல் namespaces ஐ கோட்டை ஏற்பாடு செய்கிறது மற்றும் usings மூலம் usefulness ஐ அணுகுகிறது. (பொறுமையை இருந்து வேறுபடுத்துவது மதிப்பு, `using` *statement*, automatic resource disposal க்கான வெவ்வேறு বৈশிষ்ட்யம்.)