Generics საშუალებას გაძლევთ დაწეროთ კლასები და მეთოდები, რომლებიც პარამეტრიზებულია ტიპით, რაც უზრუნველყოფს ტიპის უსაფრთხოებას და ხელმისაწვდომობას კოდის დუბლირების ან cast-ის გარეშე. Constraints შეზღუდავს რა ტიპებს შეიძლება ჰქონდეს generic პარამეტრი, რაც ხელმისაწვდებელი გახდის მათი წევრების უსაფრთხო გამოყენებას. Generics ფართოდ გამოიყენება C#-ში (მთელი collections ბიბლიოთეკა იყენებს მათ).
=> arr[i];
=> arr[i];
x = Get([] { , , }, );
Generics გადააქვს ტიპის შეცდომები runtime-დან (cast-ი object-ზე) compile time-ზე და აღმოფხვრის cast-ებს — უსაფრთხო, ხელმისაწვდებელი კოდი.
public class Box<T> // a generic class
{
private T _value;
public void Set(T value) => _value = value;
public T Get() => _value;
}
var box = new Box<string>(); // T = string, type-safe
// generic method
public T Max<T>(T a, T b) where T : IComparable<T> // constraint (see below)
=> a.CompareTo(b) > 0 ? a : b;
where T : class // T must be a reference type
where T : struct // T must be a value type
where T : new() // T must have a parameterless constructor
where T : IComparable<T> // T must implement an interface (so you can call its members)
where T : BaseClass // T must derive from BaseClass
// example: constraint lets you call CompareTo safely
public T Max<T>(T a, T b) where T : IComparable<T>
=> a.CompareTo(b) > 0 ? a : b; // CompareTo is available because of the constraint
Constraints (where T : ...) შეზღუდავს რა შეიძლება იყოს T, რაც საშუალებას გაძლევთ უსაფრთხოდ გამოიყენოთ იმ ტიპის წევრები (მაგალითად, კონსტრეინტი IComparable<T>-ზე საშუალებას გაძლევთ გამოიძახოთ CompareTo). კონსტრეინტის გარეშე, T შეიძლება იყოს რაიმე, ამიტომ არ შეგიძლიათ ივარაუდოთ რომელი წევრი აქვს.
List<T>, Dictionary<K,V>, IEnumerable<T>, Task<T>, Nullable<T> ...
→ the entire collections library and much of .NET is generic.
Generics ფუნდამენტურია C#-ში — ისინი ფართოდ გამოიყენება (მთელი collections ბიბლიოთეკა, Task<T>, IEnumerable<T> და უამრავი API არის generic), ამიტომ მათი გაგება აუცილებელია C# დეველოპმენტის ნებისმიერი საქმიანობისთვის.
Generics იხსნის რეალურ პრობლემას: დაწეროთ ხელმისაწვდებელი კოდი, რომელიც მუშაობს მრავალი ტიპისთვის ხოლო შენიჭს ტიპის უსაფრთხოება — ალტერნატივა (object და cast) დანაკარგებს compile-time უსაფრთხოებას და მოითხოვს შეცდომებით სავსე cast-ებს, ხოლო კოდის დუბლირება თითო ტიპზე არის განუჭვრეტელი.
Generics გაძლევთ ხელმისაწვდებელ, ტიპის უსაფრთხო კოდს cast-ის გარეშე და compile-time შეცდომის შემოწმებით. Constraints (where T : ...) არის მნიშვნელოვანი დამატება: ისინი შეზღუდავს რა შეიძლება იყოს ტიპის პარამეტრი, რაც ორივე ხელმისაწვდებელი გახდის იმ ტიპის წევრების უსაფრთხო გამოყენება (კონსტრეინტი ინტერფეისზე საშუალებას გაძლევთ გამოიძახოთ მისი მეთოდები) და უზრუნველყოფს სწორ გამოყენებას.
გენერიკული კლასების და მეთოდების, ტიპის მოკრების მუშაობის, და constraints-ის (class, struct, new(), interface/base-class constraints) გაგება აუცილებელია როგორც generic-მძიმე .NET ბიბლიოთეკების ეფექტიანად გამოყენებისთვის, ასევე საკუთარი ხელმისაწვდებელი, ტიპის უსაფრთხო აბსტრაქციის დაწერისთვის.
ac generics ემყარება C#-ის collections-ს და framework-ის დიდ ნაწილს, და რადგან ისინი ხელმისაწვდებელი ტიპის უსაფრთხო კოდის გასაღებია, generics-ის და constraints-ის დაუფლება ძირითადი, ხშირად გამოყენებული ცოდნა ეფექტიანი C# დეველოპმენტისთვის და ტიპის უსაფრთხო, ხელმისაწვდებელი დიზაინის გაგების ზოგადი ინდიკატორია.