Extension methods საშუალებას გაძლევთ "დაამატოთ" methods არსებულ types-ებს (მათ ჩათვლით types-ებს, რომელიც თქვენ არ ფლობთ, როგორიცაა string ან int) მათი შეცვლის ან მემკვიდრეობის გარეშე. ისინი განისაზღვრება static methods-ის სახით this modifier-ით პირველ პარამეტრზე და იძახიან, თითქოს ისინი instance methods იყვნენ. LINQ აგებულია მათზე.
public static class StringExtensions
{
// `this string str` makes this an extension method ON string
public static bool IsValidEmail(this string str)
{
return str.Contains("@") && str.Contains(".");
}
public static string Truncate(this string str, int max)
{
return str.Length <= max ? str : str[..max] + "...";
}
}
// call them as if they were instance methods on string
"[email protected]".IsValidEmail(); // true
"long text here".Truncate(5); // "long ..."
this modifier პირველ პარამეტრზე აღნიშნავს method-ს, როგორც აღნიშნული type-ის გაფართოებას. ეს static method-ია, მაგრამ თქვენ აძახებთ მას, როგორც instance method-ს (str.IsValidEmail()), რაც ბუნებრივად იკითხება.
// these are equivalent — the extension call is sugar for a static call
"[email protected]".IsValidEmail();
StringExtensions.IsValidEmail("[email protected]");
Extension methods არის compiler magic — ისინი რეალურად static method calls არიან, მაგრამ this-parameter syntax საშუალებას გაძლევთ აძახოთ მათ fluently, თითქოს ისინი type-ს ეკუთვნოდნენ. (ისინი უნდა იყოს static class-ში და namespace იყოს შემოტანილი using-თან.)
// Where, Select, OrderBy, etc. are extension methods on IEnumerable<T>
list.Where(x => x > 0).Select(x => x * 2);
// → IEnumerable<T> has no Where method; LINQ ADDS them via extension methods
LINQ-ის ყველა query operator (Where, Select და ა.შ.) არის extension methods IEnumerable<T>-ზე — ამიტომ ისინი იკვრებენ ისე fluently. ეს არის extension methods-ის ყველაზე პროტაგონისტი გამოყენება.
Extension methods არის მნიშვნელოვანი და განსხვავებული C# feature და მათი გაგება ღირებული როგორც მათი გამოყენების, ისე C#-ის ძირითადი ნაწილების გაგების თვალსაზრისით — ყველაზე აღსანიშნავად LINQ, რომელიც მთლიანად აგებულია extension methods-ზე (The Where/Select/OrderBy operators არის extensions IEnumerable<T>-ზე, ამიტომ ისინი იკვრებენ ისე fluently).
ეს feature საშუალებას გაძლევთ დაამატოთ ფუნქციონალობა არსებულ types-ებს — მათ ჩათვლით ones, რომელიც თქვენ არ ფლობთ (string, int, framework types) ან არ შეგიძლიათ შეცვალოთ (sealed classes, interfaces) — მემკვიდრეობის გარეშე ან originali-ს შეცვლის გარეშე, სიგელი clean, fluent calling syntax-ის (str.IsValidEmail() იკითხება instance method-ის მსგავსად).
ეს სასარგებლოა helper methods-ის დაწერისთვის, რომელიც extend type-ებს ბუნებრივად, fluent APIs აგებისთვის და behavior დამატებისთვის interfaces-ზე.
Extension methods-ის გაგება — როგორ განისაზღვროს ისინი (this პირველ პარამეტრზე, static class-ში), რომ ისინი არიან syntactic sugar static calls-ისთვის და განსაკუთრებით რომ LINQ აგებულია მათზე — მნიშვნელოვანი ცოდნაა როგორც clean, fluent C# helpers-ის დაწერისთვის, ისე იმის გაგების თვალსაზრისით, თუ როგორ აღწევენ LINQ და მრავალი fluent .NET APIs მათი syntax — და საშუალებას გაძლევთ დაწეროთ მსგავსი clean, discoverable code.
ვინაიდან extension methods underpin ერთ C#-ის ყველაზე მნიშვნელოვან feature-ს (LINQ) და არის გავრცელებული გზა types-ის გაფართოებისთვის elegantly, მათი ცოდნა არის frequently-applied knowledge, რომელიც ასახავს გაგებას იმის შესახებ, თუ როგორ მუშაობენ C#-ის fluent, extensible APIs — და საშუალებას გაძლევთ დაწეროთ მსგავსი clean, discoverable code.