सी # वैकल्पिक पैरामीटर कक्षा पैरामीटर के लिए शून्य के अलावा?

Question

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

public void DoSomething(Class1 optional1, Class2 optional2, Class3 optional3) 
    { 
     if (! WasSpecified(optional1)) { optional1 = defaultForOptional1; } 
     if (! WasSpecified(optional2)) { optional2 = defaultForOptional2; } 
     if (! WasSpecified(optional3)) { optional3 = defaultForOptional3; } 

     // ... do the actual work ... 
    } 

मैं Class1 optional1 = null उपयोग नहीं कर सकते क्योंकि अशक्त सार्थक है।

1. हर संभव संयोजन है, जिसके लिए 8 भार के का मतलब है के साथ भार के प्रदान करें: मैं क्योंकि इन वैकल्पिक पैरामीटर मैं इन विकल्पों के साथ आए हैं के लिए संकलन समय निरंतर आवश्यकता के कुछ प्लेसहोल्डर वर्ग उदाहरण Class1 optional1 = defaultForOptional1 उपयोग नहीं कर सकते यह विधि।
2. प्रत्येक वैकल्पिक पैरामीटर के लिए एक बूलियन पैरामीटर शामिल करें जो दर्शाता है कि डिफ़ॉल्ट का उपयोग करना है या नहीं, जिसे मैं हस्ताक्षर को अपनाना चाहता हूं।

क्या कोई इस के लिए कुछ चालाक समाधान के साथ आया है?

धन्यवाद!

संपादित करें: मैंने एक रैपर वर्ग लिखना समाप्त कर दिया, इसलिए मुझे Boolean HasFoo दोहराना नहीं पड़ा।

/// <summary> 
    /// A wrapper for variables indicating whether or not the variable has 
    /// been set. 
    /// </summary> 
    /// <typeparam name="T"></typeparam> 
    public struct Setable<T> 
    { 
     // According to http://msdn.microsoft.com/en-us/library/aa288208%28v=vs.71%29.aspx, 
     // "[s]tructs cannot contain explicit parameterless constructors" and "[s]truct 
     // members are automatically initialized to their default values." That's fine, 
     // since Boolean defaults to false and usually T will be nullable. 

     /// <summary> 
     /// Whether or not the variable was set. 
     /// </summary> 
     public Boolean IsSet { get; private set; } 

     /// <summary> 
     /// The variable value. 
     /// </summary> 
     public T Value { get; private set; } 

     /// <summary> 
     /// Converts from Setable to T. 
     /// </summary> 
     /// <param name="p_setable"></param> 
     /// <returns></returns> 
     public static implicit operator T(Setable<T> p_setable) 
     { 
      return p_setable.Value; 
     } 

     /// <summary> 
     /// Converts from T to Setable. 
     /// </summary> 
     /// <param name="p_tee"></param> 
     /// <returns></returns> 
     public static implicit operator Setable<T>(T p_tee) 
     { 
      return new Setable<T> 
      { 
       IsSet = true 
       , Value = p_tee 
      }; 
     } 
    } 

Answer 1

मैं कम से कम पैरामीटर के लिए एक नए प्रकार बनाने पर विचार करेंगे:

public void DoSomething(DoSomethingOptions options) 

... जहां DoSomethingOptions ऐसा दिखाई दे सकता:

public class DoSomethingOptions 
{ 
    private Class1 class1; 
    public bool HasClass1 { get; private set; } 

    public Class1 Class1 
    { 
     get { return class1; } 
     set 
     { 
      class1 = value; 
      HasClass1 = true; 
     } 
    } 

    ... for other properties ... 
} 

फिर आप इसे कॉल कर सकते हैं:

DoSomething(new DoSomethingOptions { Class1 = null, Class2 = new Class2() }); 

आप अधिभार के घातीय सेट के साथ समाप्त नहीं होते हैं, और आप इसे अभी भी उचित रूप से कॉम्पैक्ट कर सकते हैं।

यह दृष्टिकोण के समान है कि ProcessProcessStartInfo के साथ आता है।

Answer 2

हर संभव संयोजन है, जो इस विधि के लिए 8 भार के का मतलब है के साथ भार के प्रदान करें।

यह मेरी प्राथमिकता है। यह स्थिति को बहुत स्पष्ट और रखरखाव बनाता है। आंतरिक रूप से, आप डुप्लिकेट कोड को कम करने के लिए एक प्रारंभिक दिनचर्या पर मानचित्र कर सकते हैं।

Answer 3

हाँ, किसी ऑब्जेक्ट का उपयोग करने का प्रयास करें। एक वर्ग को परिभाषित करें जो संभावित विकल्पों को समाहित करता है। जब ऑब्जेक्ट में कोई विकल्प सेट किया जाता है तो आप उसी ऑब्जेक्ट में स्टोर कर सकते हैं यदि यह मूल प्रॉपर्टी के सेटटर के उपयोग के माध्यम से सेट किया गया हो।

एक उदाहरण:

internal class SettingsHolder 
{ 
    public SettingsHolder() 
    { 
     IsOriginalPropADefault = true; 
    } 

    private Class1 originalProp; 
    public Class1 OriginalProp 
    { 
     get 
     { 
      return originalProp; 
     } 
     set 
     { 
      originalProp = value; 
      IsOriginalPropADefault = false; 
     } 
    } 

    public bool IsOriginalPropADefault { get; private set; } 

} 

Answer 4

मैं null मतलब है "कुछ भी नहीं है," और बनाने पसंद करते हैं Class1 पर प्रकार Class1, Class2, आदि की एक static readonly सदस्य है, Class2 आदि None नाम दिया है।फिर null सार्थक बनाने के बजाय आप मूल रूप से इरादे से "कुछ नहीं" के रूप में शून्य का उपयोग कर सकते हैं।

मामले कि भ्रामक है में:

public class Class1 
{ 
    public static readonly Class1 None = new Class1(); 
} 
public static Class2 
{ 
    public static readonly Class2 None = new Class2(); 
} 

ध्यान दें, कि यदि आपके मामले में null "कोई नहीं" के अलावा कुछ का मतलब है ("MissingData" या कुछ और की तरह) आप सदस्य thusly नाम रखना चाहिए। यह भी ध्यान दें: इससे भविष्य में आपके कोड को पढ़ने और उपयोग करने के लिए अन्य लोगों को बहुत अधिक समझदारी होगी।

Answer 5

आप Flags गणना बना सकते हैं कि आप किन वर्गों का उपयोग करने के लिए यह पारित कर सकते हैं।

[Flags] 
public enum DoSomethingOptions 
{ 
    None = 0, 
    UseClass1 = 1, 
    UseClass2 = 2, 
    UseClass3 = 4, 
    etc.. 
} 

DoSomething(Class1 class1, ..., DoSomethingOptions options = DoSomethingOptions.None) { ... } 

फिर कक्षाओं का उपयोग करने के लिए यह गणना करने के लिए उस गणना को पास करें। मुझे आश्चर्य है कि आपने null का उपयोग शून्य के अलावा कुछ और करने के लिए क्यों किया? हालांकि यह एक समाधान हो सकता है, मैं वास्तव में "अपने डिजाइन पर पुनर्विचार" कहना चाहूंगा।