C# optional parameter besides null for class parameter?

Question

What is the best solution to this problem? I'm trying to create a function that has several optional parameters of class types for which null is a meaningful value and cannot be used as a default. As in,

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 ...
    }

I can't use Class1 optional1 = null because null is meaningful. I can't use some placeholder class instance Class1 optional1 = defaultForOptional1 because of the compile-time constant requirement for these optional parameters I've come up with the following options:

Provide overloads with every possible combination, which means 8 overloads for this method.
Include a Boolean parameter for each optional parameter indicating whether or not to use the default, which I clutters up the signature.

Has anyone out there come up with some clever solution for this?

Thanks!

edit: I ended up writing a wrapper class for so I didn't have to keep repeating 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
            };
        }
    }

Overloads won't let you pass the literal null constant. (Just a style issue.) — Neil
– Neil, Commented May 23, 2012 at 20:35

Jon Skeet · Accepted Answer · 2012-05-23 20:36:57Z

12

I would at least consider creating a new type for the parameter:

public void DoSomething(DoSomethingOptions options)

... where DoSomethingOptions could look like this:

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 ...
}

Then you can call it with:

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

You don't end up with an exponential set of overloads, and you can still call it reasonably compactly.

This is similar to the approach that Process takes with ProcessStartInfo.

answered May 23, 2012 at 20:36

Jon Skeet

1.5m893 gold badges9.3k silver badges9.3k bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Becca Over a year ago

Thanks for the idea, Jon. I'll go with this unless I hear about some way to get around that compile-time constant issue.

Reed Copsey · Accepted Answer · 2012-05-23 20:33:59Z

6

Provide overloads with every possible combination, which means 8 overloads for this method.

This is my preference. It makes the situation very clear and maintainable. Internally, you can map to a single initialization routine to reduce duplicated code.

answered May 23, 2012 at 20:33

Reed Copsey

567k80 gold badges1.2k silver badges1.4k bronze badges

4 Comments

myermian Over a year ago

In this scenario (8 overloads) it can be considered somewhat maintainable. But, this clearly would not be maintainable as more parameters are required. Just imagine if he had 5 parameters... that's 32 variations! yes, it is more clear in its own way, but maintainability takes a huge hit. Then again, CA1026 msdn.microsoft.com/en-us/library/ms182135.aspx does state to not use optional parameters for public access... it's just a lot of craziness.

Reed Copsey Over a year ago

@m-y Realistically, it's rare that EVERY parameter is or should be optional, though - so it's only the meaningful ones. If every parameter is optional, I'd refactor into a more meaningful data structure.

Becca Over a year ago

@ReedCopsey, that's consistent with Jon Skeet's answer below. I will mostly likely use a transfer object as you and Jon suggest, since I might have more than three optional parameters. m-y is right that the variations will get excessive.

Becca Over a year ago

@ReedCopsey Your second comment, that is, is consistent with Jon Skeet's answer.

Chris Pfohl · Accepted Answer · 2012-05-23 20:55:04Z

6

I'd prefer making null mean "nothing," and have a static readonly member of type Class1, Class2, etc. on Class1, Class2 etc. named None. Then instead of making null meaningful you can use null as "nothing" as it was originally intended.

In case that's confusing:

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

Note, that if null in your case means something other than "None" (like "MissingData" or something else) you should name the member thusly. Also note: this will make a lot more sense to other people reading and using your code in the future.

edited May 23, 2012 at 20:55

answered May 23, 2012 at 20:37

Chris Pfohl

19.2k9 gold badges75 silver badges115 bronze badges

7 Comments

BrokenGlass Over a year ago

Also see Null Object pattern for related info: en.wikipedia.org/wiki/Null_Object_pattern (and +1)

myermian Over a year ago

+1 - Yes, I agree whole heartily. Instead of taking away the true meaning of null, have a static field that represents a "Nothing" value. It's kind of like String.Empty vs null.

Becca Over a year ago

Like I said, I'm trying to avoid using null to mean "Nothing" or "Unspecified". In this case, null is meaningful. In your example, how would I use Class1.None as a default parameter without getting "Default parameter value for 'optional1' must be a compile-time constant"? public void DoSomething(Class1 optional1 = Class1.None) gets me that error. Thank you all for your replies.

Chris Pfohl Over a year ago

@Don, would you mind explaining how null is meaningful? You're fighting against C#'s semantics...Also, you wouldn't use Class.None as a default parameter, you'd use null, and then inside the method you'd start out by saying, class1Parameter = class1Parameter ?? Class1.None

myermian Over a year ago

@Don01001100: You'd flip the usage... Class1.None would represent whatever you're using null to represent now, and null would represent itself. So you'd default all your optional parameters to null and use Class1.None to replace whatever null was representing. Don't use null to give additional meaning to something other than it being null. Again, look at String.Empty. It literally is a string that represents "Nothing" instead of using null to represent "Nothing".

|

myermian · Accepted Answer · 2012-05-23 20:49:08Z

2

You can create a Flags enumeration that you can pass along to mark which classes to use.

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

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

Then simply pass that enumeration in to mark which classes to use. I do wonder why you used null to mean something other than null? Although this might be a solution, I'd really like to say "rethink your design".

answered May 23, 2012 at 20:49

myermian

32.6k26 gold badges135 silver badges222 bronze badges

Comments

Remco · Accepted Answer · 2012-05-25 10:32:22Z

1

Yeah, try using an object. Define a class which encapsulates the possible choices. When a choice is set in the object you can store in that same object if it was set through the use of the setter of the original property.

An example:

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; }

}

edited May 25, 2012 at 10:32

answered May 23, 2012 at 20:36

Remco

1,9531 gold badge14 silver badges14 bronze badges

Collectives™ on Stack Overflow

C# optional parameter besides null for class parameter?

5 Answers 5

1 Comment

4 Comments

7 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

5 Answers 5

1 Comment

4 Comments

7 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related