C# 中可选 ref 参数的解决方法

Question

我正在尝试编写一种方法，该方法引用布尔标志并修改它们。布尔值都是单独声明的（即不在可索引数据结构中），并且方法的调用者应该能够决定要修改哪些布尔值。

示例代码（有效）：

class Program
{
    private static bool b1, b2, b3, b4, b5;

    private static void doSomething(ref bool setTrue, ref bool setFalse, ref bool invert)
    {
        setTrue = true;
        setFalse = false;
        invert = !invert;
    }

    static void Main(string[] args)
    {
        Console.WriteLine("Pre: {0}, {1}, {2}, {3}, {4}", b1, b2, b3, b4, b5);
        doSomething(ref b1, ref b3, ref b5);
        Console.WriteLine("Post: {0}, {1}, {2}, {3}, {4}", b1, b2, b3, b4, b5);
    }
}

输出，如预期：

Pre: False, False, False, False, False
Post: True, False, False, False, True

到目前为止，一切顺利。现在这些参数在方法上应该是可选的。也就是说，调用者可以选择使用 setTrue 和 invert 效果，但不能选择 setFalse 效果。

基本上，我想做的是：

doSomething(ref b1, null, ref b5); // error CS1503: Argument 2: cannot convert from '<null>' to 'ref bool'

然后像这样声明 doSomething 方法：

private static void doSomething(ref bool setTrue, ref bool setFalse, ref bool invert)
{
    if(setTrue != null) setTrue = true;
    if(setFalse != null) setFalse = false;
    if(invert != null) invert = !invert;
}

请注意，我不想想要检查该值是否为 null。这些值是真正的布尔值，不能为空（将它们声明为 bool? 并不能真正解决我的问题）。我只想让调用者能够提供 null 作为参考。

虽然该方法的实现可能更复杂，但我真的希望将调用减少到一行。 （即避免只为这次调用声明临时变量。）

一种可能性是为函数声明（八个）重载，并给定或未给定布尔值的所有组合，但是我需要想出一些方案来确保它们都有独特的签名。 （我坚持使用 C# 3.0，所以没有命名参数。）

我错过了什么吗？有干净的解决方法吗？目前我能想到的唯一（勉强）可接受的替代方案是传入带有变量名称（或 null）的字符串，然后使用反射将它们解析为实际字段。

PS：正如您可能想知道为什么我尝试做一些如此奇怪的事情一样，一些背景知识：doSomething 方法是库的一部分。 doSomething 的调用来自生成的 C# 代码。是的，将所有这些布尔值（实际项目中约为 200 个）作为单独的字段确实在大局中有意义，但推理与这个问题并不真正相关。

Answer 1

如果您确实想要有可选参数，唯一的解决方案是使用指针，因为它们可以为空，这与ref不同。

private static unsafe void doSomething(bool* setTrue, bool* setFalse, bool* invert)
{
    if (setTrue  != null) *setTrue  = true;
    if (setFalse != null) *setFalse = false;
    if (invert   != null) *invert   = !*invert;
}

浑身都是丑陋的。但是嘿，可选参数！

Answer 2

更新...

如果您需要在单个方法调用中潜在地操作所有三个字段，那么我认为您需要使用反射来相对干净地完成它。然而，这可以通过使用表达式树来实现某种程度的类型安全；您不需要将字段名称作为字符串传递。

DoSomething(() => b1, () => b3, () => b5);
DoSomething(() => b1, null, () => b5);

// ...

public static void DoSomething(Expression<Func<bool>> trueFieldSelector,
                               Expression<Func<bool>> falseFieldSelector,
                               Expression<Func<bool>> invertFieldSelector)
{
    FieldInfo fieldInfo;
    object obj;

    if (GetInfo(trueFieldSelector, out fieldInfo, out obj))
        fieldInfo.SetValue(obj, true);

    if (GetInfo(falseFieldSelector, out fieldInfo, out obj))
        fieldInfo.SetValue(obj, false);

    if (GetInfo(invertFieldSelector, out fieldInfo, out obj))
        fieldInfo.SetValue(obj, !(bool)fieldInfo.GetValue(obj));
}

private static bool GetInfo(Expression<Func<bool>> fieldSelector,
                            out FieldInfo fieldInfo, out object obj)
{
    if (fieldSelector == null)
    {
        fieldInfo = null;
        obj = null;
        return false;
    }

    var me = fieldSelector.Body as MemberExpression;
    if (me == null)
        throw new ArgumentException("Select a field!", "fieldSelector");

    fieldInfo = me.Member as FieldInfo;
    if (fieldInfo == null)
        throw new ArgumentException("Select a field!", "fieldSelector");

    var ce = me.Expression as ConstantExpression;
    obj = (ce == null) ? null : ce.Value;

    return true;
}

请注意，像这样使用反射会相对较慢。如果它不够快，那么您可能需要更深入地研究反射，可能使用 DynamicMethod 创建委托，然后将它们缓存在字典中以供重复使用。 （尽管我不会为此烦恼，除非您确定简单的反射会阻碍您。）

---

原始答案...

使用单独的方法并仅调用不是会更干净吗根据需要使用它们，而不是尝试将其全部整合到一个方法中？

SetTrue(ref b1);
SetFalse(ref b3);
Invert(ref b5);

// ...

public static void SetTrue(ref bool field)
{
    DoCommonStuff();
    field = true;
}

public static void SetFalse(ref bool field)
{
    DoCommonStuff();
    field = false;
}

public static void Invert(ref bool field)
{
    DoCommonStuff();
    field = !field;
}

private static void DoCommonStuff()
{
    // ...
}

我假设还需要做一些常见的事情。如果不是，那么简单地执行 b1 = true、b2 = false、b3 = !b3 会更更清晰> 直接等并完全避免方法调用。

Answer 3

您不能仅将值或空引用作为 ref 参数传递，它必须是一个变量。您可能知道，值类型不能为空，除非您将它们设置为可为空。

C# 4.0 不允许为可选 ref 指定默认值/ out 参数，所以我不相信除了大量繁琐的方法重载之外，还有任何可行的方法可以使用 C# 3.0 来解决这个问题。

Answer 4

创建您自己的容器类型以传递到您的方法中怎么样？这应该是非常简单的解决方案。

Answer 5

为什么你不只为你的函数编写一个新类型？它既简单又干净。

private static void doSomething(MyNewTypeWith3Bools object)
{    
    object.SetTrue = true;
    object.SetFalse = false;
    object.Invert = !object.Invert;
}

private static void doSomething(MyNewTypetWith2Bools object)
{    
    object.SetTrue = true;
    object.Invert = !object.Invert;
}
...

Answer 6

您将永远无法使用 ref 或 out 执行 doSomething(ref b1, null, ref b5); （即将 null 作为参数传递） > 参数，因为 ref 或 out 参数必须是可赋值变量。

您可以使用数组或列表作为参数传递给该方法，但我假设您之后需要解压此列表以分配各个值。

另一种选择是创建您自己的布尔类型来包装布尔值，但这需要更改对布尔值的所有引用。

这篇 stackoverflow 帖子讨论了更改使用 Func 将值类型转换为引用类型。不确定它对您的解决方案是否可行，但我认为这是一个很好的方法。

Answer 7

如果您创建一个类来保存布尔参数怎么样？也许可以将其称为“状态”或类似的名称。它会有布尔吗？作为字段。

然后，您可以将状态对象传递给 doSomethingMethod，它将调用适当的生成方法并通过 ref 传递所有参数。

这个方法的好处是你只需要设置你要使用的布尔值，包装方法就会弄清楚要做什么。例如，如果某些参数未设置，则不会将它们传递给生成的方法。

public class MyBooleanStateClass
{ 
  public bool? setTrue { get; set; }
  public bool? setFalse { get; set; }
  public bool? Invert { get; set; }
}
private static void doSomething(MyBooleanStateClass state)
{
   if(state.setTrue.HasValue())
     // do something with setTrue
   // repeat for all the others
}

然后你的其他方法可以干净地调用它

class Program
{
    static void Main(string[] args)
    {
        var state = new MyBooleanState() { Invert = false };
        doSomething(state);
        Console.WriteLine("Invert is now: {0}", state.Invert);
    }
}

Answer 8

这似乎是一个需要代码生成器尖叫的问题。为您需要的所有函数创建重载，或者只是从一个小型代码生成器创建您需要的所有包装器。

就我个人而言，我会添加一个“中间”层将所有布尔值转储到数组中。

Answer 9

你试图做的事情是错误的：

• 你试图以一种减少更改和重组的方式编写代码，但将来你将有更多的维护和复杂性

通常这应该以另一种方式进行：

• 当你看到某些东西时进行重组正在变得或将变得复杂且难以阅读，因为您等待的时间越长，它就会变得更加困难，在某些时候您会陷入困境

现在用非最佳实践答案来回答您的问题，因为如果不进行重组，就没有：

使用虚拟引用参数：

doSomething(ref b1, ref dummy, ref b5, ref dummy, ref b7);

这可能会工作，但正如你清楚地看到它是一个黑客......

你可能会抱怨你需要在所有需要调用它的地方声明虚拟变量，但事实并非如此。您可以对 hacks 进行修改并进行修改以简化调用代码，尽管这样做并不酷：

    public static class dummy
    {
        public static bool boolean;
    }


//...

   doSomething(ref b1, ref dummy.boolean, ref b5, ref dummy.boolean, ref b7);