C# 4.0 可选 out/ref 参数

Question

C# 4.0 是否允许可选的 out 或 ref 参数？

Answer 1

不可以。

解决方法是使用另一个没有 out / ref 参数的方法进行重载，该方法仅调用您当前的方法。

public bool SomeMethod(out string input)
{
    ...
}

// new overload
public bool SomeMethod()
{
    string temp;
    return SomeMethod(out temp);
}

---

如果您有 C# 7.0，您可以简化：

// new overload
public bool SomeMethod()
{
    return SomeMethod(out _);    // declare out as an inline discard variable
}

（感谢@Oskar / @Reiner 指出了这一点。）

Answer 2

正如已经提到的，这是根本不允许的，但我认为这是非常有道理的。
但是，要添加更多详细信息，请引用 C# 4.0 规范，第 21.1 节：

构造函数、方法、索引器和委托类型的形式参数可以声明为可选：

固定参数：
   属性_opt 参数修饰符_opt 类型标识符 默认参数_opt
默认参数：
    = 表达式

• 带有默认参数的固定参数是可选参数，而固定参数没有默认参数是必需参数。
• 在正式参数列表中，必需参数不能出现在可选参数之后。
• ref 或 out 参数不能有默认参数。

Answer 3

不，但另一个很好的选择是让该方法使用通用模板类作为可选参数，如下所示：

public class OptionalOut<Type>
{
    public Type Result { get; set; }
}

然后您可以按如下方式使用它：

public string foo(string value, OptionalOut<int> outResult = null)
{
    // .. do something

    if (outResult != null) {
        outResult.Result = 100;
    }

    return value;
}

public void bar ()
{
    string str = "bar";

    string result;
    OptionalOut<int> optional = new OptionalOut<int> ();

    // example: call without the optional out parameter
    result = foo (str);
    Console.WriteLine ("Output was {0} with no optional value used", result);

    // example: call it with optional parameter
    result = foo (str, optional);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional.Result);

    // example: call it with named optional parameter
    foo (str, outResult: optional);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional.Result);
}

Answer 4

实际上有一种 C# 允许的方法可以做到这一点。这又回到了 C++，并且违反了 C# 良好的面向对象结构。

请谨慎使用此方法！

以下是使用可选参数声明和编写函数的方法：

unsafe public void OptionalOutParameter(int* pOutParam = null)
{
    int lInteger = 5;
    // If the parameter is NULL, the caller doesn't care about this value.
    if (pOutParam != null) 
    { 
        // If it isn't null, the caller has provided the address of an integer.
        *pOutParam = lInteger; // Dereference the pointer and assign the return value.
    }
}

然后像这样调用函数：

unsafe { OptionalOutParameter(); } // does nothing
int MyInteger = 0;
unsafe { OptionalOutParameter(&MyInteger); } // pass in the address of MyInteger.

为了编译该函数，您需要在项目选项中启用不安全代码。这是一个非常老套的解决方案，通常不应该使用，但如果您出于某种奇怪的、神秘的、神秘的、受管理启发的决定，确实需要 C# 中的可选输出参数，那么这将允许您做到这一点。

Answer 5

ICYMI：包含在 C# 7.0 枚举的新功能中 此处，现在允许“discards”作为 _ 形式的 out 参数，让您忽略不关心的 out 参数：

p.GetCooperatives(out var x ， 出去 _）; // 我只关心 x

PS 如果您也对“out var x”部分感到困惑，请阅读链接上有关“Out Variables”的新功能。

Answer 6

不可以，但您可以使用委托（例如 Action）作为替代方案。

当我遇到我认为需要可选输出参数的情况时，部分受到 Robin R 回答的启发，我改为使用 Action 委托。我借用了他的示例代码来修改 Action 的使用，以显示差异和相似之处：

public string foo(string value, Action<int> outResult = null)
{
    // .. do something

    outResult?.Invoke(100);

    return value;
}

public void bar ()
{
    string str = "bar";

    string result;
    int optional = 0;

    // example: call without the optional out parameter
    result = foo (str);
    Console.WriteLine ("Output was {0} with no optional value used", result);

    // example: call it with optional parameter
    result = foo (str, x => optional = x);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional);

    // example: call it with named optional parameter
    foo (str, outResult: x => optional = x);
    Console.WriteLine ("Output was {0} with optional value of {1}", result, optional);
}

这样做的优点是可选变量在源代码中显示为普通 int （编译器将其包装在闭包类中，而不是我们将其显式包装在用户定义的类中）。

该变量需要显式初始化，因为编译器无法假定在函数调用退出之前将调用 Action。

它并不适合所有用例，但对于我的实际用例（一个为单元测试提供数据的函数，以及新的单元测试需要访问返回值中不存在的某些内部状态的函数）效果很好。

Answer 7

对于 C# 6.0 及更低版本，使用不带 out 参数的重载方法来调用带 out 参数的方法。当特别询问 C# 4.0 是否可以有可选的 out 参数时，我不确定为什么 C# 7.0 for .NET Core 甚至是该线程的正确答案。答案是否定的！

Answer 8

对于简单类型，您可以使用不安全代码来执行此操作，尽管这不是惯用的也不推荐。就像这样：

// unsafe since remainder can point anywhere
// and we can do arbitrary pointer manipulation
public unsafe int Divide( int x, int y, int* remainder = null ) {
    if( null != remainder ) *remainder = x % y;
    return x / y;
}

也就是说，没有理论上的原因 C# 最终不能允许使用安全代码执行类似上面的操作，如下所示：

// safe because remainder must point to a valid int or to nothing
// and we cannot do arbitrary pointer manipulation
public int Divide( int x, int y, out? int remainder = null ) {
    if( null != remainder ) *remainder = x % y;
    return x / y;
}

不过事情可能会变得有趣：

// remainder is an optional output parameter
// (to a nullable reference type)
public int Divide( int x, int y, out? object? remainder = null ) {
    if( null != remainder ) *remainder = 0 != y ? x % y : null;
    return x / y;
}

Answer 9

直接的问题已经在其他好评如潮的答案中得到了回答，但有时根据您想要实现的目标考虑其他方法是值得的。

如果您想要一个可选参数来允许调用者可能从您的方法中请求额外的数据作为某些决策的基础，则另一种设计是将该决策逻辑移至您的方法中，并允许调用者有选择地传递该值例如，这里有一个确定向量的罗盘点的方法，在该方法中我们可能希望传回向量的大小，以便调用者可以决定是否应该在罗盘之前达到某个最小阈值点判断距离原点足够远，因此明确有效：

public enum Quadrant {
    North,
    East,
    South,
    West
}

// INVALID CODE WITH MADE-UP USAGE PATTERN OF "OPTIONAL" OUT PARAMETER
public Quadrant GetJoystickQuadrant([optional] out magnitude)
{
    Vector2 pos = GetJoystickPositionXY();
    float azimuth = Mathf.Atan2(pos.y, pos.x) * 180.0f / Mathf.PI;
    Quadrant q;
    if (azimuth > -45.0f && azimuth <= 45.0f) q = Quadrant.East;
    else if (azimuth > 45.0f && azimuth <= 135.0f) q = Quadrant.North;
    else if (azimuth > -135.0f && azimuth <= -45.0f) q = Quadrant.South;
    else q = Quadrant.West;
    if ([optonal.isPresent(magnitude)]) magnitude = pos.Length();
    return q;
}

在这种情况下，我们可以将“最小幅度”逻辑移至方法中，最终得到一个更清晰的实现，特别是因为计算幅度涉及平方根如果我们只想比较大小，那么计算效率很低，因为我们可以使用平方值来完成：

public enum Quadrant {
    None, // Too close to origin to judge.
    North,
    East,
    South,
    West
}

public Quadrant GetJoystickQuadrant(float minimumMagnitude = 0.33f)
{
    Vector2 pos = GetJoystickPosition();
    if (minimumMagnitude > 0.0f && pos.LengthSquared() < minimumMagnitude * minimumMagnitude)
    {
        return Quadrant.None;
    }
    float azimuth = Mathf.Atan2(pos.y, pos.x) * 180.0f / Mathf.PI;
    if (azimuth > -45.0f && azimuth <= 45.0f) return Quadrant.East;
    else if (azimuth > 45.0f && azimuth <= 135.0f) return Quadrant.North;
    else if (azimuth > -135.0f && azimuth <= -45.0f) return Quadrant.South;
    return Quadrant.West;
}

当然，这可能并不总是可行。由于其他答案提到了 C# 7.0，如果您真正做的是返回两个值并允许调用者选择忽略一个值，那么惯用的 C# 将返回两个值的元组，并使用 C# 7.0 的元组和位置初始化器和 _“discard”参数：

public (Quadrant, float) GetJoystickQuadrantAndMagnitude()
{
    Vector2 pos = GetJoystickPositionXY();
    float azimuth = Mathf.Atan2(pos.y, pos.x) * 180.0f / Mathf.PI;
    Quadrant q;
    if (azimuth > -45.0f && azimuth <= 45.0f) q = Quadrant.East;
    else if (azimuth > 45.0f && azimuth <= 135.0f) q = Quadrant.North;
    else if (azimuth > -135.0f && azimuth <= -45.0f) q = Quadrant.South;
    else q = Quadrant.West;
    return (q, pos.Length());
}

(Quadrant q, _) = GetJoystickQuadrantAndMagnitude();
if (q == Quadrant.South)
{
    // Do something.
}

Answer 10

像这样又怎样呢？

public bool OptionalOutParamMethod([Optional] ref string pOutParam)
{
    return true;
}

您仍然需要从 C# 向参数传递一个值，但它是一个可选的引用参数。

Answer 11

void foo(ref int? n)
{
    return null;
}