એક્સટેંશન મેથોડ્સ તમને અસ્તિત્વમાં રહેલ પ્રકારો (જેમાં તમારી માલિકીના પ્રકારો નથી, જેમ કે string અથવા int) માટે મેથોડ્સ "ઉમેરવા" દે છે તેમને સંશોધિત કર્યા વિના અથવા વારસામાં લીધા વિના। તેઓ static મેથોડ્સ તરીકે વ્યાખ્યાયિત કરવામાં આવે છે જેમાં પ્રથમ પેરામીટર પર this મોડિફાયર હોય, અને તેમને ઇન્સ્ટન્સ મેથોડ્સ તરીકે કહેવામાં આવે છે। 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 મોડિફાયર મેથોડને તે પ્રકારનું એક્સટેંશન તરીકે ચિહ્નિત કરે છે. તે એક static મેથોડ છે, પરંતુ તમે તેને ઇન્સ્ટન્સ મેથોડ જેમ કહો છો (str.IsValidEmail()), જે કુદરતી રીતે વાંચે છે.
// these are equivalent — the extension call is sugar for a static call
"[email protected]".IsValidEmail();
StringExtensions.IsValidEmail("[email protected]");
એક્સટેંશન મેથોડ્સ કમ્પાયલર મેજિક છે — તેઓ ખરેખર static મેથોડ કોલ્સ છે, પરંતુ this-પેરામીટર સિન્ટેક્સ તમને તેમને fluently કહેવા દે છે જાણે તેઓ પ્રકારની માલિકી હોય. (તેઓ static class માં હોવા જોઈએ અને નેમસ્પેસ 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 ઓપરેટર્સ (Where, Select, વગેરે) IEnumerable<T> પર એક્સટેંશન મેથોડ્સ છે — તેથી જ તેઓ એટલા fluently chain કરે છે. આ એક્સટેંશન મેથોડ્સનો સૌથી પ્રખ્યાત ઉપયોગ છે.
એક્સટેંશન મેથોડ્સ એક મહત્વપૂર્ણ અને વિશિષ્ટ C# ફીચર છે, અને તેમને સમજવું તેમનો ઉપયોગ કરવા અને C# ના મુખ્ય ભાગો કેવી રીતે કાર્ય કરે છે તે સમજવા માટે મૂલ્યવાન છે — સૌથી નોંધણીય રીતે LINQ, જે સંપૂર્ણપણે એક્સટેંશન મેથોડ્સ પર બનાવવામાં આવ્યું છે (જ Where/Select/OrderBy ઓપરેટર્સ IEnumerable<T> પર એક્સટેંશન્સ છે, તેથી જ તેઓ એટલા fluently chain કરે છે).
ફીચર તમને અસ્તિત્વમાં રહેલ પ્રકારો — તમારી માલિકીનાં (string, int, ફ્રેમવર્ક પ્રકારો) અથવા જેમાંને તમે સંશોધિત કરી શકતા નથી (sealed classes, interfaces) — માટે કાર્યક્ષમતા ઉમેરવા દે છે વારસા અથવા મૂળ સંશોધિત કર્યા વિના, જ્યારે સ્વચ્છ, fluent કોલિંગ સિન્ટેક્સ રાખે છે (str.IsValidEmail() ઇન્સ્ટન્સ મેથોડ જેમ વાંચે છે).
તે helper મેથોડ્સ લખવા માટે ઉપયોગી છે જે પ્રકારો કુદરતી રીતે વિસ્તૃત કરે છે, fluent APIs બનાવે છે, અને interfaces માટે વર્તન ઉમેરે છે.
એક્સટેંશન મેથોડ્સને સમજવું — તેમને કેવી રીતે વ્યાખ્યાયિત કરવું (this પ્રથમ પેરામીટર પર, static class માં), કે તેઓ static કોલ્સ માટે સિન્ટેક્ટિક શુગર છે, અને ખાસ કરીને કે LINQ તેમ પર બનાવવામાં આવ્યું છે — સ્વચ્છ, fluent C# helpers લખવા અને LINQ અને ઘણી fluent .NET APIs કેવી રીતે તેમનું સિન્ટેક્સ પ્રાપ્ત કરે છે તે સમજવા બંને માટે મહત્વપૂર્ણ જ્ઞાન છે.
એક્સટેંશન મેથોડ્સ એક્સટેંશન મેથોડ્સ C# ના સૌથી મહત્વપૂર્ણ ફીચર્સમાંથી એક (LINQ) ને અંતર્ગત બનાવે છે અને પ્રકારો elegantly વિસ્તૃત કરવાનો સામાન્ય રીત છે, તેમને જાણવું વારંવાર વાપરવામાં આવતું જ્ઞાન છે જે C# ના fluent, extensible APIs કેવી રીતે કાર્ય કરે છે તેની સમજણ પ્રતિબિંબિત કરે છે — અને તમને તેવી જ સ્વચ્છ, discoverable કોડ લખવા દે છે.