Extension methods ఆपстані types (వీటిని మీరు యాజ్ఞాపకం చేయని string లేదా int వంటి types సహా) వాటిని సవరించకుండా లేదా వారసత్వం చేయకుండా "జోడించడానికి" అనుమతిస్తుంది. అవి మొదటి పారామితిపై this సవరణలతో static methods గా నిర్వచించబడతాయి మరియు 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 సవరణ method ను ఆ type యొక్క extension గా గుర్తిస్తుంది. ఇది 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 operators (Where, Select, మొదలైనవి) అన్నీ IEnumerable<T> పై extension methods — అందుకే అవి చాలా fluently chain చేస్తాయి. ఇది extension methods యొక్క అత్యంత ప్రముఖ ఉపయోగం.
Extension methods ఒక ముఖ్యమైన మరియు విలక్షణమైన C# feature, మరియు వాటిని అర్థం చేసుకోవడం వాటిని ఉపయోగించడానికి మరియు C# యొక్క ముఖ్య భాగాలు ఎలా కొరకు గ్రహించడానికి విలువైనది — చాలా ముఖ్యంగా LINQ, ఇది పూర్తిగా extension methods పై నిర్మితమైనది (LINQ అనువాద operators Where/Select/OrderBy extensions IEnumerable<T> పై ఉన్నాయి, అందుకే అవి చాలా fluently chain చేస్తాయి).
ఈ feature ఆపస్తానె types కు functionality జోడించడానికి అనుమతిస్తుంది — వీటిని మీరు యాజ్ఞాపకం చేయనివి (string, int, framework types) లేదా సవరించలేనివి (sealed classes, interfaces) — వారసత్వం లేదా original సవరించకుండా, clean, fluent calling syntax (str.IsValidEmail() ఒక instance method లాగా చదువుతుంది) ని ఉంచుతూ.
ఇది helper methods రాయడానికి ఉపయోగకరమైనది, fluent APIs నిర్మించుటకు, మరియు interfaces కు behavior జోడించడానికి.
Extension methods అర్థం చేసుకోవడం — వాటిని నిర్వచించడం (this మొదటి పారామితిపై, static class లో), అవి static calls కు syntactic sugar, మరియు ముఖ్యంగా LINQ నవటిపై నిర్మితమైనది — C# యొక్క clean, fluent helpers రాయటానికి మరియు LINQ మరియు many fluent .NET APIs వారి syntax ని ఎలా సాధించటానికి అర్థం చేసుకోవటానికి ముఖ్యమైన జ్ఞానం.
Extension methods C# యొక్క అత్యంత ముఖ్యమైన feature (LINQ) కు మూలమైనవి మరియు types నిష్ణాత్తుగా విస్తరించటకు సాధారణ మార్గం కనుక, వాటిని తెలుసుకోవడం తరచుగా-అన్వయిత జ్ఞానం, ఇది C# యొక్క fluent, extensible APIs ఎలా పనిచేస్తాయో అర్థం యొక్క ప్రతిబింబం — మరియు మీరు సారూప్యంగా clean, discoverable code రాయటకు అనుమతిస్తుంది.