वैकल्पिक प्रतिनिधियों

Question

यह दो विस्तार के तरीकों का एक सरल उदाहरण overloads है

public static class Extended 
{ 
    public static IEnumerable<int> Even(this List<int> numbers) 
    { 
     return numbers.Where(num=> num % 2 == 0); 
    } 

    public static IEnumerable<int> Even(this List<int> numbers, Predicate<int> predicate) 
    { 
     return numbers.Where(num=> num % 2 == 0 && predicate(num)); 
    } 
} 

मैं उन्हें एक में विलय करने के लिए, एक प्रतिनिधि की स्थापना वैकल्पिक होने के लिए द्वारा सक्षम होने के लिए करना चाहते हैं:

public static class Extended 
{ 
    public static IEnumerable<int> Even(this List<int> numbers, Predicate<in> predicate = alwaysTrue) 
    { 
     return numbers.Where(num=> num % 2 == 0 && predicate(num)); 
    } 

    public static bool alwaysTrue(int a) { return true; } 
} 

हालांकि, संकलक एक त्रुटि फेंकता है:

Default parameter value for 'predicate' must be a compile-time constant

मैं नहीं दिख रहा है कि मेरे alwaysTrue समारोह स्थिर नहीं है, लेकिन हे, संकलक kno ws बेहतर :)

क्या प्रतिनिधि पैरामीटर वैकल्पिक बनाने का कोई तरीका है?

Answer 1

यह स्थिर नहीं है क्योंकि आपने एक विधि समूह से एक प्रतिनिधि बनाया है ... यह संकलन-समय स्थिर नहीं है जब तक सी # भाषा का संबंध नहीं है।

आप null का अर्थ कोस कोई आपत्ति नहीं है थोड़ा आप इस्तेमाल कर सकते हैं:

private static readonly Predicate<int> AlwaysTrue = ignored => true; 

public static List<int> Even(this List<int> numbers, 
          Predicate<int> predicate = null) 
{ 
    predicate = predicate ?? AlwaysTrue; 
    return numbers.Where(num=> num % 2 == 0 && predicate(num)); 
} 

(आप अभी भी AlwaysTrue एक विधि बना सकता है और एक विधि समूह रूपांतरण का उपयोग, लेकिन इसके बाद के संस्करण दृष्टिकोण है बहुत थोड़ा अधिक कुशल सिर्फ एक बार प्रतिनिधि उदाहरण बनाकर।)

Answer 2

public static List<int> Even(this List<int> numbers, Predicate<in> predicate = null) 
{ 
    return numbers.Where(num=> num % 2 == 0 && (predicate == null || predicate(num))); 
} 

Answer 3

आप क्या करना है यह +०१२३०५६४७८ होने की अनुमति है, और फिर के रूप में हमेशा सही के रूप में व्यवहार करें।

आपके पास इसके लिए दो विकल्प हैं, प्रतिनिधि कॉल को छोड़ने के लिए कोड को दोगुना करें, यह उन मामलों में तेज़ी से प्रदर्शन करेगा जहां आप प्रतिनिधि को पास नहीं करते हैं। के रूप में आप चाहते थे

public static List<int> Even(this List<int> numbers, Predicate<int> predicate = null) 
{ 
    if (predicate == null) 
     return numbers.Where(num=> num % 2 == 0).ToList(); 
    else 
     return numbers.Where(num=> num % 2 == 0 && predicate(num)).ToList(); 
} 

या, एक डमी कार्यान्वयन प्रदान करते हैं:

public static List<int> Even(this List<int> numbers, Predicate<int> predicate = null) 
{ 
    predicate = predicate ?? new Predicate<int>(alwaysTrue); 
    return numbers.Where(num=> num % 2 == 0 && predicate(num)).ToList(); 
} 

इसके अलावा, विचार करें कि क्या तुम सच में ऐसा करना चाहते हैं। प्रभाव वैकल्पिक पैरामीटर संकलित कोड पर है कि कॉलिंग कोड अब डिफ़ॉल्ट मान प्रदान करता है, जिसका अर्थ है कि यह हमेशा ओवरलोड को कॉल करेगा जो एक सूची और प्रतिनिधि लेता है।

यदि आप बाद में वापस जाना चाहते हैं, तो आपको यह सुनिश्चित करने की आवश्यकता है कि विधि को कॉल करने वाले सभी कोड को फिर से सम्मिलित किया जाए, क्योंकि यह जादुई रूप से उस विधि का उपयोग शुरू नहीं करेगा जो प्रतिनिधि प्रदान नहीं करता है।

दूसरे शब्दों में, इस कॉल:

var even = list.Even(); 

है जैसे कि यह इस तरह लिखा गया था दिखेगा:

var even = list.Even(null); 

आप अब विधि बदलते हैं, एक बार फिर अतिभारित किया जा सकता है अगर ऊपर कॉल पुन: संकलित नहीं किया गया है, तो यह हमेशा उस प्रतिनिधि के लिए एक प्रतिनिधि को कॉल करेगा, केवल उस पैरामीटर के लिए null प्रदान करेगा।

Answer 4

आप एक null -default मूल्य इस्तेमाल कर सकते हैं:

public static class Extended 
{ 
    public static IEnumerable<int> Even(this IEnumerable<int> numbers, 
             Predicate<int> predicate = null) 
    { 
     if (predicate==null) 
     { 
      predicate = i=>true; 
     } 

     return numbers.Where(num => num % 2 == 0 && predicate(num)); 
    } 
}