Question

这个问题的最佳解决方案是什么？我正在尝试创建一个具有几个类类型可选参数的函数，其中null是一个有意义的值，不能用作默认值。如，

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，因为null是有意义的。我不能使用一些占位符类实例Class1 optional1 = defaultForOptional1，因为这些可选参数的编译时常量要求我提出了以下选项：

为每种可能的组合提供重载，这意味着此方法有8次重载。
为每个可选参数添加一个布尔参数，指示是否使用默认值，这会使签名变得混乱。

有没有人为此提出一些聪明的解决方案？

谢谢！

编辑：我最后编写了一个包装类，因此我没有必要继续重复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() });

你最终没有一组指数的重载，你仍然可以合理地调用它。

这类似于Process使用ProcessStartInfo所采用的方法。

Answer 2

为每种可能的组合提供重载，这意味着此方法有8次重载。

这是我的偏好。它使情况非常清晰和可维护。在内部，您可以映射到单个初始化例程以减少重复的代码。

Answer 3

我希望null表示“没有”，并且在static readonly上有一个Class1 Class2成员，Class1等， Class2等名为None。然后，不是使null有意义，而是可以使用null作为“无”，就像它最初的预期一样。

如果这令人困惑：

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

请注意，如果您的案例中的null表示“无”以外的内容（例如“MissingData”或其他内容），则应该为该成员命名。另请注意：这将使其他人在将来阅读和使用您的代码更有意义。

Answer 4

您可以创建一个Flags枚举，您可以传递该枚举以标记要使用的类。

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

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

然后简单地传递该枚举以标记要使用的类。我想知道你为什么用null来表示 null 以外的东西？虽然这可能是一个解决方案，但我真的很想说＆＃34;重新考虑你的设计＆＃34;。

Answer 5

是的，尝试使用一个对象。定义一个封装可能选择的类。当在对象中设置选项时，如果通过使用原始属性的setter设置了该对象，则可以存储该对象。

一个例子：

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

}

C＃可选参数除了null参数外？

5 个答案: