ეს სამი განსხვავებული ტიპის კატეგორია C#-ში არის: enum (დასახელებული ნიშვნიერი მნიშვნელობების ნაკრები), struct (მნიშვნელობის ტიპი მცირე მონაცემებისთვის) და class (მითითების ტიპი ობიექტებისთვის). სწორი არჩევანი დამოკიდებულია მონაცემებისა და ქცევის რა ასპექტებზე მუშაობთ.
Status { Active, Inactive, Pending }
Status s = Status.Active;
(s == Status.Active) { }
Permissions { Read = , Write = , Execute = }
enum განსაზღვრავს ფიქსირებული კომპლექტის დასახელებულ მნიშვნელობებს — ტიპის უსაფრთხო მუდმივებს იმგვარი რამეებისთვის, როგორებიცაა მდგომარეობები, როლები ან ვარიანტები (ჯადოსნური რიცხვების/სტრიქონების ჩანაცვლება). ეს არის მნიშვნელობის ტიპი, რომელიც მხარდაჭერილია მთელი რიცხვით.
public struct Point // VALUE type — copied by value, no heap allocation
{
public int X { get; }
public int Y { get; }
public Point(int x, int y) { X = x; Y = y; }
}
Point p1 = new(1, 2);
Point p2 = p1; // COPIES the whole struct (independent)
struct არის მნიშვნელობის ტიპი — ინხერენტულად შენახული (ხშირად stack-ზე), მნიშვნელობით დაკოპირებული, heap გამოყოფის გარეშე. საუკეთესო მცირე, უმუტაბელი, მონაცემების ხასიათის მნიშვნელობებისთვის (კოორდინატები, ფული, თარიღი), სადაც მნიშვნელობის სემანტიკა და heap გამოყოფის თავიდან აცილება ხელმისაწვდომელი სამუშაოს გაუმჯობესებას.
public class User // REFERENCE type — on the heap, copied by reference
{
public string Name { get; set; }
public void DoWork() { } // rich behavior
}
User u1 = new() { Name = "Ann" };
User u2 = u1; // both reference the SAME object
class არის მითითების ტიპი — heap-ზე, მითითებით დაკოპირებული (გაზიარებული), მხარდაჭერს მემკვიდრეობას და მდიდარ ქცევას. დაშვებული არჩევანი უმეტესი ობიექტებისთვის იდენტობის, ქცევის და შეცვლად მდგომარეობის მიხედვით.
enum → a fixed set of named constants (states, roles, options)
struct → small, immutable data values; value semantics; avoid heap allocation
(keep small — large structs are costly to copy)
class → most objects: identity, behavior, inheritance, mutable/larger state (the default)
სწორი ტიპის კატეგორიის არჩევანი — enum, struct ან class — არის ფундამენტური C# დიზაინის გადაწყვეტილება, რომელიც გავლენას ახდენს სისწორეზე, სემანტიკასა და ამუშავების სიჩქარეზე, ამიტომ განსხვავებების გაგება მნიშვნელოვანია. enum-ები უზრუნველყოფენ ტიპის უსაფრთხო დასახელებულ მუდმივებს (მდგომარეობებისთვის, როლებისთვის, ვარიანტებისთვის), ბევრად უკეთესი ვიდრე შეცდომებისკენ მიმავალი ჯადოსნური რიცხვები ან სტრიქონები — ხშირი, მნიშვნელოვანი მოდელირების ინსტრუმენტი.
struct vs class განსხვავება განსაკუთრებით მნიშვნელოვანია, რადგან ის განსაზღვრავს მნიშვნელობის წინააღმდეგ მითითების სემანტიკას: struct-ები არის მნიშვნელობის ტიპები (დაკოპირებული მნიშვნელობით, ინხერენტულად შენახული, heap გამოყოფის გარეშე) მცირე უმუტაბელი მონაცემების მნიშვნელობებისთვის, სადაც მნიშვნელობის სემანტიკა და შემცირებული გამოყოფა ხელმისაწვდომელი სამუშაოს ეხმარება, ხოლო class-ები არის მითითების ტიპები (გაზიარებული მითითებით, heap-ზე გამოყოფილი, მემკვიდრეობის მხარდაჭერა და მდიდარი ქცევა) — დაშვებული ოჯახი უმეტესი ობიექტებისთვის იდენტობის და ქცევის მიხედვით.
სწორი არჩევის გაკეთება რეალურ შედეგებთან დაკავშირებულია: დიდი struct ძვირი ღირს დასაკოპირებლად, და struct-ის გამოყენება იქ სადაც მითითების სემანტიკა მოსალოდნელია (ან პირიქით) ხელმისაწვდომელი შეცდომებს იწვევს.
გაგება როდის რა გამოიყენოთ — enum ფიქსირებული მუდმივი კომპლექტებისთვის, struct მცირე მონაცემის ხასიათის მნიშვნელობებისთვის (მცირე ზომაში შენახული), class უმეტესი ობიექტებისთვის (დაშვებული) — და მნიშვნელობის წინააღმდეგ მითითების გამოწვევები მნიშვნელოვანი ცოდნაა მონაცემების სწორად და ამუშავების ეფექტიანად მოდელირებისთვის C#-ში.
მას შემდეგ რაც ეს არჩევანი ჩნდება როდესაც თქვენ განსაზღვრავთ ტიპს, და მას შემდეგ რაც მნიშვნელობის/მითითების განსხვავება საფუძველს ქმნის C# ქცევის დიდ ნაწილს, გაგება განსხვავებების და enum-ების, struct-ების და class-ების განტოლებული გამოყენების — არის ბირთვული, ხშირი-სამოქმედო ცოდნა და ხშირი ინტერვიუს ხდის C#-ის ტიპების სისტემის გაგების ასახვის.