C#“出局”的真实示例参数有用吗？

Question

我正在阅读核心 C# 编程结构，但很难理解 out 参数修饰符。我通过阅读知道它的作用，但我试图想出当我使用它时的场景。

有人能给我一个现实世界的例子吗？谢谢。

Answer 1

使用 out 参数的主要动机是允许函数将多个值返回给调用者以及框架中其他人提供的示例。我将采用不同的方法来回答您的问题，首先探讨使用 out 参数背后的原因。我不会写出实际的例子，而是描述它们。

通常，只有一种返回值的机制，即函数的返回值。当然，您也可以使用全局（静态）或实例变量，但这通常不太实用也不安全（出于我不会在这里解释的原因）。 在 .NET 3.5 之前，没有一种真正实用的方法可以从函数返回多个值。如果 out 或 ref 修饰符不可用，您将有几个选择：

• 如果所有值都具有相同的类型，您可以返回一些值的集合。在大多数情况下，这完全没问题，您可以返回数字数组、字符串列表等。如果所有值都以完全相同的方式相关，那就完美了。即，所有数字都是容器中物品的数量，或者列表是聚会上客人的姓名。但是如果您返回的值代表不同的数量怎么办？如果它们有不同的类型怎么办？对象列表可以容纳所有对象，但这不是操作此类数据的非常直观的方式。

• 对于需要返回不同类型的多个值的情况，唯一实用的选择是创建一个新的类/结构类型来封装所有这些值并返回该类型的实例。这样做可以返回具有直观名称的强类型值，并且可以通过这种方式返回多个值。问题是，为了实现这一点，您必须使用特定名称和所有内容来定义类型，以便能够返回多个值。如果您只想返回两个值，而这两个值足够简单，以至于无法为其创建类型，该怎么办？您又多了几个选择：

  • 您可以创建一组泛型类型来包含固定数量的不同类型的值（如函数语言中的元组）。但以可重用的方式这样做并不那么有吸引力，因为它当时不是框架的一部分。它可以放入一个库中，但现在您只是为了这些简单类型而添加对该库的依赖项。 （很高兴 .NET 4.0 现在包含 Tuple 类型）但这仍然不能解决这些简单值的事实，这意味着简单任务会增加复杂性。

    李>

  • 使用的选项是包含一个 out 修饰符，它允许调用者将“引用”传递给变量，以便函数可以将引用的变量设置为另一种方式返回一个值。出于同样的原因，这种返回值的方式在 C 和 C++ 中也以多种方式可用，并且在影响这一决定方面发挥了作用。然而，C# 中的区别在于，对于 out 参数，函数必须将值设置为某个值。如果不存在，则会导致编译器错误。这使得这种情况不太容易出错，因为通过使用 out 参数，您向调用者承诺您会将值设置为某个值并且他们可以使用它，编译器会确保您遵守该承诺。

关于 out（或 ref）修饰符的典型用法的注释，很少会看到超过一两个 out 参数。在这些情况下，创建封装类型几乎总是一个更好的主意。如果您只需要再返回一个值，您通常会使用它。

然而，自从 C#-3.0/.NET-3.5 引入了 .NET 4.0 中引入的匿名类型和元组以来，这些选项提供了替代方法来更轻松（且更直观）地返回不同类型的多个值。

Answer 2

您会在很多场景中使用它，但主要的场景是您的方法需要返回多个参数。以 int 类型的 TryParse 方法为例。在这种情况下，不是抛出异常，而是返回 bool 作为成功/失败标志，并且解析的 int 作为输出参数返回。如果您要调用 int.Parse(...) 您可能会抛出异常。

string str = "123456";
int val;
if ( !int.TryParse(str,out val) )
{
// do some error handling, notify user, etc.
}

Answer 3

当然，请查看任何 TryParse 方法，例如 int.TryParse：

这个想法是你实际上想要两条条信息：解析操作是否成功（返回值）， ，如果是这样，它的实际结果是什么（out 参数）。

用法：

string input = Console.ReadLine();
int value;

// First we check the return value, which is a bool
// indicating success or failure.
if (int.TryParse(input, out value))
{
    // On success, we also use the value that was parsed.
    Console.WriteLine(
        "You entered the number {0}, which is {1}.",
        value,
        value % 2 == 0 ? "even" : "odd"
    );
}
else
{
    // Generally, on failure, the value of an out parameter
    // will simply be the default value for the parameter's
    // type (e.g., default(int) == 0). In this scenario you
    // aren't expected to use it.
    Console.WriteLine(
        "You entered '{0}', which is not a valid integer.",
        input
    );
}

许多开发人员抱怨 out 参数是“代码味道”；但在许多情况下它们可能是迄今为止最合适的选择。一个非常重要的现代例子是多线程代码；通常，需要 out 参数来允许返回值不足以实现的“原子”操作。

例如，考虑一下 Monitor.TryEnter(object, ref bool)，它获取一个锁并原子地设置一个 bool，这是不可能的可以仅通过返回值来实现，因为锁获取必然发生在将返回值分配给 bool 变量之前。 （是的，从技术上讲，ref 和 out 并不相同；但它们非常接近）。

另一个很好的例子是 .NET 4.0 新增的 System.Collections.Concurrent 命名空间中的集合类可用的一些方法；它们提供类似的线程安全操作，例如 ConcurrentQueue.TryDequeue(out T) 和 ConcurrentDictionary.TryRemove(TKey, out TValue)。

Answer 4

输出参数遍布整个 .NET 框架。我最常看到的一些用法是 TryParse 方法，它返回一个布尔值（指示解析是否有效），实际结果通过输出参数返回。虽然当您需要返回多个值时使用类也是很常见的地方，但在这样的示例中，它有点严厉。有关输出参数的更多信息，请参阅 Jon Skeet 的文章：C# 中的参数传递 。

Answer 5

很简单，当您有一种返回多个值的方法时。
最“著名”的案例之一是 Dictionary.TryGetValue：

string value = "";

if (openWith.TryGetValue("tif", out value))
{
    Console.WriteLine("For key = \"tif\", value = {0}.", value);
}
else
{
    Console.WriteLine("Key = \"tif\" is not found.");
}

Answer 6

正如其他人所说 - 输出参数允许我们从方法调用中返回多个值，而不必将结果包装在结构/类中。

xxx.TryParse 方法的添加极大地简化了字符串值（通常来自 UI）和原始类型之间转换所需的编码。

您可能必须编写才能实现相同功能的示例如下：

/// <summary>
/// Example code for how <see cref="int.TryParse(string,out int)"/> might be implemented.
/// </summary>
/// <param name="integerString">A string to convert to an integer.</param>
/// <param name="result">The result of the parse if the operation was successful.</param>
/// <returns>true if the <paramref name="integerString"/> parameter was successfully 
/// parsed into the <paramref name="result"/> integer; false otherwise.</returns>
public bool TryParse(string integerString, out int result)
{
    try
    {
        result = int.Parse(integerString);
        return true;
    }
    catch (OverflowException)
    {
        // Handle a number that was correctly formatted but 
        // too large to fit into an Int32.
    }
    catch (FormatException)
    {
        // Handle a number that was incorrectly formatted 
        // and so could not be converted to an Int32.
    }

    result = 0; // Default.
    return false;
}

此处避免的两个异常检查使调用代码更具可读性。我相信实际的 .NET 实现完全避免了异常，因此性能也更好。同样，此示例显示了 IDictionary.TryGetValue(...) 如何使代码更简单、更高效：

private readonly IDictionary<string,int> mDictionary = new Dictionary<string, int>();

public void IncrementCounter(string counterKey)
{
    if(mDictionary.ContainsKey(counterKey))
    {
        int existingCount = mDictionary[counterKey];

        mDictionary[counterKey] = existingCount + 1;
    }
    else
    {
        mDictionary.Add(counterKey, 1);
    }
}

public void TryIncrementCounter(string counterKey)
{
    int existingCount;
    if (mDictionary.TryGetValue(counterKey, out existingCount))
    {
        mDictionary[counterKey] = existingCount + 1;
    }
    else
    {
        mDictionary.Add(counterKey, 1);
    }
}

这一切都归功于 out 参数。

Answer 7

bool Int32.TryParse(String, out Int);

或类似的东西，如Dictionary.TryGetValue。

但我认为这并不是一种很好的做法，当然，使用 Int32 等 API 提供的 API 来避免 Try-Catch 是例外。

Answer 8

//out key word is used in function instead of return. we can use multiple parameters by using out key word
public void outKeyword(out string Firstname, out string SecondName)
{
    Firstname = "Muhammad";
    SecondName = "Ismail";

}
//on button click Event
protected void btnOutKeyword_Click(object sender, EventArgs e)
{
    string first, second;
    outKeyword(out first, out second);
    lblOutKeyword.Text = first + "  " + second;
}