有趣的“参考参数”功能，有什么解决方法吗？

Question

我想知道对于值类型是否有任何可能的方式......

public static class ExtensionMethods {
    public static void SetTo(this Boolean source, params Boolean[] bools) {
        for (int i = 0; i < bools.Length; i++) {
            bools[i] = source;
        }
    }
}

那么这是可能的：

Boolean a = true, b, c = true, d = true, e;
b.SetTo(a, c, d, e);

当然，这不起作用，因为 bool 是值类型，所以它们作为值而不是引用传递给函数。

除了将值类型包装成引用类型（通过创建另一个类）之外，还有什么方法可以在使用 params 修饰符时通过引用（ref）将变量传递给函数？

Answer 1

这是不可能的。为了解释原因，首先阅读我的文章，为什么我们通过将值类型的局部变量放入堆栈来优化它们的释放：

https://web.archive.org/web/20100224071314/http://blogs.msdn.com/ericlippert/archive/2009/05/04/the-stack-is-an-implementation-detail-part-two.aspx

既然您已经理解了这一点，那么您应该清楚为什么不能将“ref bool”存储在数组中了。如果可以，那么您可以拥有一个比被引用的堆栈变量存活时间更长的数组。我们有两个选择：要么允许这样做，并且如果你弄错了程序会崩溃并可怕地死掉——这是 C 的设计者做出的选择。安全的。我们选择了后者。

但是让我们更深入地考虑一下。如果你想要传递“允许我设置变量的东西”，我们有 that。那只是一个代表：

static void DoStuff<T>(this T thing, params Action<T>[] actions)
{
    foreach(var action in actions) action(thing);
}
...
bool b = whatever;
b.DoStuff(x=>{q = x;}, x=>{r = x;} );

有意义吗？

Answer 2

不幸的是，Java 社区和现在的 .NET，开发人员决定以“安全”为名降低灵活性是首选解决方案，而要以更少的代码行数达到相同的结果，您必须选择非常复杂的（所有这些类结构、委托等）。

在 Delphi 中，我可以简单地做这样的事情：

var
  a: integer; f: double; n: integer;
sscanf(fmtstr, valuestr, [@a, @f, @n]);

//

在 C# 中你必须这样做：

int a; double f; int n;
object [] o = new object[];
sscanf(fmtstr, valuestr, ref o);
a = o[0];
f = o[1];
n = o[2];

这 5 行代码可以完成我在 1 行 Delphi 代码中可以做的事情。我认为某处有一个公式，代码中出现错误的可能性随着代码行数的增加而呈几何级数增加；所以如果你有 20 行代码，你的代码出现错误的可能性是 10 行代码的 4 倍。

当然，您可以通过使用带有所有那些奇怪的尖括号和奇怪的语法的委托来减少 # 行代码，但我认为这也是错误的避风港。

Answer 3

真的没有办法。你可以这样做：

public static void Main(string[] args)
{
    BooleanWrapper a = true, b = true, c = true, d = true, e = new BooleanWrapper();
    b.SetTo(a, c, d, e);
}

public static void SetTo(this BooleanWrapper sourceWrapper, params BooleanWrapper[] wrappers)
{
    foreach (var w in wrappers)
        w.Value = sourceWrapper.Value;
}

public class BooleanWrapper
{
    public BooleanWrapper() { }

    public BooleanWrapper(Boolean value)
    {
        Value = value;
    }

    public Boolean Value { get; set; }

    public static implicit operator BooleanWrapper(Boolean value)
    {
        return new BooleanWrapper(value);
    }
}

但话说回来，这有什么比这样做更好的呢：

public static void Main(string[] args)
{
    Boolean[] bools = new Boolean[5];
    bools.SetTo(bools[1]); // Note I changed the order of arguments. I think this makes more sense.
}

public static void SetTo(this Boolean[] bools, Boolean value)
{
    for(int i = 0; i < bools.Length; i++)
        bools[i] = value;
}

毕竟，数组是一系列变量。如果您需要一些行为类似于变量序列的东西，请使用数组。

Answer 4

这里有一些有趣的解决方案：

public delegate RecursionRefFunc<T> RecursionRefFunc<T>(ref T arg);

public static RecursionRefFunc<T> Boo<T>(ref T input)
{
    Console.WriteLine(input); // Work in here
    return Boo;
}

public static void Main(string[] args)
{
    int x1 = 1, x2 = 2, x3 = 3, x4 = 4, x5 = 5;
    Boo(ref x1)(ref x2)(ref x3)(ref x4)(ref x5);
}

// Output: //
// 1
// 2
// 3
// 4
// 5

委托可以递归声明。

在外面返回一个函数，然后再次调用。

而且你会被代码审查者杀死。

---

广告 OW<: href="https://github.com/CWKSC/MyLib_Csharp" rel="nofollow" target="_blank">CWKSC/MyLib_Csharp

Answer 5

即使bools 是引用类型，这也是不可能的。虽然class 是引用类型，但Boolean[] 中的变量仍然是值，只是值 是引用。分配引用的值只会更改该特定变量的值。 ref 变量数组的概念没有意义（因为数组本质上是一系列值）。