Namespaces da kuma using directives suna aiki ta yaya?

Question

Accepted Answer

**Namespaces** suna shirya code a cikin rukunonin logi da kuma suna hana turuwar suna (kamar foda don nau'i). **`using` directives** suna shigo da namespaces don ka iya ziyartar nau'insu ta hanyar gajere. A juna gida suna shirya C# code da kuma shiga karfi .NET gida. ## Sanarwa 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 yana haduwa da nau'i masu alaaka a karkashin suna (`MyApp.Services.UserService`), hana turuwar tsakanin azuzuwan da suna daidai a namespaces daban-daban. File-scoped namespaces (C# 10) suna rage nesting. ## using directives — shigo da namespaces ```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` a saman fili yana shigowa da namespace don nau'insa su kasance akwai ta hanyar gajere (maimakon gabatacciyar suna). Kana shigowa da .NET libraries da kake bukata ta wannan hanyar. ## using aliases da 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) suna sanarwa shigowa sau daya don dukkan aiki — zamani .NET auto-kasama bayyanar gida (`ImplicitUsings`), saboda haka ba ku saba rubuta `using System;` ba. ## Sanarwa: using directive da kuma using statement ```csharp using var file = File.OpenText("x.txt"); // using STATEMENT — auto-disposes (different feature!) ``` ## Me ya sa ya mahalaci Namespaces da kuma using directives sune tushe ga shirya C# code da kuma shiga .NET ecosystem, don haka fahimta su shine mahimmancin ilmi na yau-yau. **Namespaces** suna shirya nau'i a cikin rukunonin logi (wakilin tsarin foda) da hana **turuwar suna** — ba tare da su ba, azuzuwan ku zai kasada da juna da kuma da karfin .NET gida da fashi na wahaje. **`using` directives** sune ta yadda kake shigowa da wannan karfi: shigowa da namespaces don ki yi amfani da nau'insu (`Console`, `List`, LINQ hanyoyi) ta hanyar gajere maimakon gabatacciyar suna — kowane fili na C# yana dogara ga usings don shiga aiki na tsarin. Sanin ta yaya za ku sanarwa namespaces (gaba da zamani file-scoped syntax), shigo tare da usings, yi amfani da aliases don warware rikice-rikice, da kuma samfuri **global usings** (C# 10, sanarwa bayyanar shigowa sau daya don dukkan aiki — yanzu sau-sau auto-samarwa ta hanyar ImplicitUsings, don haka ba ku saba rubuta boilerplate usings ba) shine dole don shirya aiki da kuma yi amfani da tsarin. Fahimta namespaces da usings — shirya code, hana turuwar rikice-rikice, shiga .NET gida, da zamani global/implicit usings waɗanda suka rage boilerplate — shine tushe ga kowane C# development, tunda kowane program yana shirya code a cikin namespaces da kuma shiga aiki ta hanyar usings. (Karewa fasifewa daga `using` *statement*, siffe daban ta amfani don automatic resource disposal.)