关于C#：in vs ref vs out


When to use in vs ref vs out

前几天有人问我什么时候应该使用参数关键字out，而不是ref。虽然我(我认为)理解了ref和out关键字(之前已经问过)之间的区别，最好的解释似乎是ref==in和out，但在某些(假设或代码)示例中，我应该始终使用out而不是ref。

既然ref更通用，为什么要使用out？只是句法上的糖分吗？

相关讨论

你应该使用out，除非你需要ref。

当需要将数据编组到另一个流程(可能成本高昂)时，这会产生很大的差异。因此，您希望避免在方法不使用初始值时对其进行封送处理。

除此之外，它还向声明或调用的读者显示初始值是相关的(并且可能被保留)还是丢弃的。

作为一个微小的区别，out参数不需要初始化。

out示例：

1
2
string a, b;
person.GetBothNames(out a, out b);

如果getbothnames是一种原子地检索两个值的方法，那么无论a和b是什么，该方法都不会更改行为。如果呼叫转到夏威夷的服务器，那么将初始值从这里复制到夏威夷将浪费带宽。使用ref的类似代码段：

1
2
string a = String.Empty, b = String.Empty;
person.GetBothNames(ref a, ref b);

可能会混淆读者，因为看起来a和b的初始值是相关的(尽管方法名会指示它们不是相关的)。

ref示例：

1
2
string name = textbox.Text;
bool didModify = validator.SuggestValidName(ref name);

这里的初始值与方法有关。

相关讨论

使用out表示参数未被使用，仅设置。这有助于调用者理解您总是在初始化参数。

此外，ref和out不仅仅用于值类型。它们还允许您重置引用类型从方法中引用的对象。

相关讨论

从语义上讲，您是正确的，ref提供了"in"和"out"功能，而out只提供"out"功能。有一些事情需要考虑：

  • out要求接受参数的方法必须在返回之前的某一点为变量赋值。您可以在一些关键/值数据存储类(如Dictionary)中找到这种模式，在这些类中您有类似TryGetValue的函数。此函数接受一个out参数，该参数保存检索后的值。调用方向该函数传递一个值是没有意义的，因此使用out来保证调用后变量中会有一个值，即使它不是"真实"数据(在TryGetValue的情况下，该键不存在)。
  • 处理互操作代码时，out和ref参数的排列方式不同。

    • 另外，值得一提的是，尽管引用类型和值类型的值性质不同，但应用程序中的每个变量都指向保存值的内存位置，即使对于引用类型也是如此。碰巧，对于引用类型，内存位置中包含的值是另一个内存位置。将值传递给函数(或执行任何其他变量赋值)时，该变量的值将被复制到另一个变量中。对于值类型，这意味着复制类型的整个内容。对于引用类型，这意味着将复制内存位置。不管怎样，它都会创建包含在变量中的数据的副本。它所具有的唯一真正相关性是处理赋值语义；当分配变量或传递值(默认值)时，当对原始(或新)变量进行新赋值时，它不会影响其他变量。对于引用类型，是的，对实例所做的更改在两侧都可用，但这是因为实际变量只是指向另一个内存位置的指针；变量的内容(内存位置)实际上没有更改。

    通过ref关键字表示原始变量和函数参数实际上都指向相同的内存位置。这同样只影响赋值语义。如果一个新值被分配给其中一个变量，那么由于另一个变量指向同一个内存位置，新值将反映在另一个变量上。

    相关讨论

    它取决于编译上下文(参见下面的示例)。

    out和ref都表示通过引用传递的变量，但是ref要求在传递变量之前对其进行初始化，这可能是封送上下文中的一个重要区别(互操作：umanagedtomanagedttransition或反之亦然)。

    MSDN警告：


    Do not confuse the concept of passing by reference with the concept of reference types. The two concepts are not the same. A method parameter can be modified by ref regardless of whether it is a value type or a reference type. There is no boxing of a value type when it is passed by reference.

    来自官方的msdn文档：

    • out：


    The out keyword causes arguments to be passed by reference. This is similar to the ref keyword, except that ref requires that the variable be initialized before being passed

    • ref：


    The ref keyword causes an argument to be passed by reference, not by value. The effect of passing by reference is that any change to the parameter in the method is reflected in the underlying argument variable in the calling method. The value of a reference parameter is always the same as the value of the underlying argument variable.

    我们可以在分配参数时验证out和ref是否确实相同：

    CIL实例：

    考虑下面的例子

    1
    2
    3
    4
    5
    6
    7
    static class outRefTest{
        public static int myfunc(int x){x=0; return x; }
        public static void myfuncOut(out int x){x=0;}
        public static void myfuncRef(ref int x){x=0;}
        public static void myfuncRefEmpty(ref int x){}
        // Define other methods and classes here
    }

    在CIL中，myfuncOut和myfuncRef的指令与预期相同。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    outRefTest.myfunc:
    IL_0000:  nop        
    IL_0001:  ldc.i4.0    
    IL_0002:  starg.s     00
    IL_0004:  ldarg.0    
    IL_0005:  stloc.0    
    IL_0006:  br.s        IL_0008
    IL_0008:  ldloc.0    
    IL_0009:  ret        

    outRefTest.myfuncOut:
    IL_0000:  nop        
    IL_0001:  ldarg.0    
    IL_0002:  ldc.i4.0    
    IL_0003:  stind.i4    
    IL_0004:  ret        

    outRefTest.myfuncRef:
    IL_0000:  nop        
    IL_0001:  ldarg.0    
    IL_0002:  ldc.i4.0    
    IL_0003:  stind.i4    
    IL_0004:  ret        

    outRefTest.myfuncRefEmpty:
    IL_0000:  nop        
    IL_0001:  ret

    nop:无操作，ldloc:本地加载，stloc:本地堆栈，ldarg:加载参数，bs.s:分支到目标….

    (见：CIL说明清单)

    下面是我从这篇关于C out和Ref的代码项目文章中提取的一些注释。

  • 只有当我们期望一个函数或一个方法有多个输出时，才应该使用它。对结构的思考也是一个很好的选择。
  • ref和out是关键字，它们指示如何将数据从调用者传递到被调用者，反之亦然。
  • 在REF中，数据双向传递。从呼叫者到被呼叫者，反之亦然。
  • 输入输出数据从被调用方到调用方只传递一种方式。在这种情况下，如果调用者试图将数据发送给被调用者，它将被忽略/拒绝。

    • 如果你是一个有视觉效果的人，那么请看这段你的视频，这段视频实际上证明了两者的区别：https://www.youtube.com/watch？V= LydCy5 Zulxa

    下图更直观地显示了差异

    C# Out Vs Ref

    相关讨论

    如果计划读写参数，则需要使用ref。如果你只打算写，你需要使用out。实际上，当您需要多个返回值时，或者当您不想使用正常的返回机制进行输出时(但这应该很少见)。

    有一些语言机制可以帮助这些用例。ref参数在传递给方法之前必须已初始化(强调它们是读写的)，并且out参数在赋值之前不能被读取，并且保证在方法结束时被写入(强调它们是只写的)。违反这些原则会导致编译时错误。

    1
    2
    3
    4
    int x;
    Foo(ref x); // error: x is uninitialized

    void Bar(out int x) {}  // error: x was not written to

    例如，int.TryParse返回bool并接受out int参数：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    int value;
    if (int.TryParse(numericString, out value))
    {
        /* numericString was parsed into value, now do stuff */
    }
    else
    {
        /* numericString couldn't be parsed */
    }

    这是一个很明显的例子，您需要输出两个值：数值结果和转换是否成功。clr的作者决定在这里选择out，因为他们不关心int以前可能是什么。

    对于ref，您可以查看Interlocked.Increment：

    1
    2
    int x = 4;
    Interlocked.Increment(ref x);

    Interlocked.Increment原子地增加x的值。由于您需要读取x来增加它，因此在这种情况下，ref更合适。你完全关心在它被传给Increment之前x是什么。

    在下一个版本的c_中，甚至可以在out参数中声明变量，从而更加强调其仅输出的性质：

    1
    2
    3
    4
    5
    6
    7
    8
    if (int.TryParse(numericString, out int value))
    {
        // 'value' exists and was declared in the `if` statement
    }
    else
    {
        // conversion didn't work, 'value' doesn't exist here
    }
    相关讨论

    听起来如何：
    BR/>out=仅初始化/填充参数(参数必须为空)返回纯文本
    BR/>ref=reference，标准参数(可能有值)，但函数可以修改它。

    相关讨论

    out是ref的约束版本。

    在方法体中，在离开方法之前需要分配给所有out参数。另外，分配给out参数的值被忽略，而ref要求分配这些值。

    因此，out允许您执行以下操作：

    1
    int a, b, c = foo(out a, out b);

    其中ref要求分配a和b。

    相关讨论

    您可以在两个上下文(每个上下文都是详细信息的链接)中使用out上下文关键字作为参数修饰符，或在接口和委托中的泛型类型参数声明中使用。本主题讨论参数修饰符，但是您可以看到关于泛型类型参数声明的其他主题。

    out关键字使参数通过引用传递。这与ref关键字类似，只是ref要求在传递变量之前对其进行初始化。要使用out参数，方法定义和调用方法都必须显式使用out关键字。例如：C.*

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    class OutExample
    {
        static void Method(out int i)
        {
            i = 44;
        }
        static void Main()
        {
            int value;
            Method(out value);
            // value is now 44
        }
    }

    虽然作为out参数传递的变量在传递之前不必初始化，但被调用的方法必须在方法返回之前赋值。

    虽然ref和out关键字导致不同的运行时行为，但它们在编译时不被视为方法签名的一部分。因此，如果唯一的区别是一个方法使用ref参数，另一个方法使用out参数，则不能重载方法。例如，以下代码将不会编译：C.*

    1
    2
    3
    4
    5
    6
    7
    class CS0663_Example
    {
        // Compiler error CS0663:"Cannot define overloaded
        // methods that differ only on ref and out".
        public void SampleMethod(out int i) { }
        public void SampleMethod(ref int i) { }
    }

    但是，如果一个方法采用ref或out参数，而另一个方法两者都不使用，则可以进行重载，如下所示：C.*

    1
    2
    3
    4
    5
    class OutOverloadExample
    {
        public void SampleMethod(int i) { }
        public void SampleMethod(out int i) { i = 5; }
    }

    属性不是变量，因此不能作为out参数传递。

    有关传递数组的信息，请参见使用ref和out传递数组(C编程指南)。

    下列方法不能使用ref和out关键字：

    1
    2
    3
    Async methods, which you define by using the async modifier.

    Iterator methods, which include a yield return or yield break statement.

    例子

    当您希望方法返回多个值时，声明out方法非常有用。下面的示例使用out返回三个变量和一个方法调用。注意，第三个参数被指定为空。这使得方法可以选择性地返回值。C.*

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class OutReturnExample
    {
        static void Method(out int i, out string s1, out string s2)
        {
            i = 44;
            s1 ="I've been returned";
            s2 = null;
        }
        static void Main()
        {
            int value;
            string str1, str2;
            Method(out value, out str1, out str2);
            // value is now 44
            // str1 is now"I've been returned"
            // str2 is (still) null;
        }
    }

    只是为了澄清OP的评论，即在ref和out上的使用是"对方法外部声明的值类型或结构的引用"，该引用已经在错误中建立。

    考虑在StringBuilder上使用ref，它是一种引用类型：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    private void Nullify(StringBuilder sb, string message)
    {
        sb.Append(message);
        sb = null;
    }

    // -- snip --

    StringBuilder sb = new StringBuilder();
    string message ="Hi Guy";
    Nullify(sb, message);
    System.Console.WriteLine(sb.ToString());

    // Output
    // Hi Guy

    根据本协议：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    private void Nullify(ref StringBuilder sb, string message)
    {
        sb.Append(message);
        sb = null;
    }

    // -- snip --

    StringBuilder sb = new StringBuilder();
    string message ="Hi Guy";
    Nullify(ref sb, message);
    System.Console.WriteLine(sb.ToString());

    // Output
    // NullReferenceException

    如何在C中使用in或out或ref？

    • C#中的所有关键字都具有相同的功能，但有一些边界。
    • 不能用调用的方法修改in参数。
    • 可以修改ref参数。
    • ref在被调用方使用之前必须初始化，它可以在方法中读取和更新。
    • 调用方必须修改out参数。
    • out参数必须在方法中初始化
    • 作为in参数传递的变量必须在方法调用中传递之前初始化。但是，被调用的方法不能赋值或修改参数。

    下列方法不能使用in、ref和out关键字：

    • 异步方法，通过使用async修饰符定义。
    • 迭代器方法，包括yield return或yield break语句。

    why do you ever want to use out?

    让其他人知道，当变量从被调用的方法返回时，它将被初始化！

    如上所述：对于out参数，调用方法必须在方法返回之前赋值。

    例子：

    1
    2
    3
    Car car;
    SetUpCar(out car);
    car.drive();  // You know car is initialized.

    基本上，ref和out都用于在方法之间传递对象/值。

    out关键字使参数通过引用传递。这类似于ref关键字，只是ref要求在传递变量之前对其进行初始化。

    out：参数未初始化，必须在方法中初始化

    ref：参数已经初始化，可以在方法中读取和更新。

    "ref"用于引用类型是什么？

    您可以将给定的引用更改为其他实例。

    你知道吗？

  • 尽管ref和out关键字会导致不同的运行时行为，但它们在编译时不被视为方法签名的一部分。因此，如果唯一的区别是一个方法接受ref参数，另一个接受out参数，则不能重载方法。

  • 不能将ref和out关键字用于以下类型的方法：

    • 异步方法，通过使用异步修饰符定义。
    • 迭代器方法，包括yield返回或yield break语句。

  • 属性不是变量，因此不能作为输出参数传递。

    • 关于C 7的额外说明：在C 7中，不需要使用out预先声明变量。这样的代码：

    1
    2
    3
    4
    5
    6
    public void PrintCoordinates(Point p)
    {
      int x, y; // have to"predeclare"
      p.GetCoordinates(out x, out y);
      WriteLine($"({x}, {y})");
    }

    可以这样写：

    1
    2
    3
    4
    5
    public void PrintCoordinates(Point p)
    {
      p.GetCoordinates(out int x, out int y);
      WriteLine($"({x}, {y})");
    }

    资料来源：C 7的新功能。

    作为引用传递的参数在传递给方法之前必须初始化，而out参数在传递给方法之前不需要初始化。

    应注意，从7.2版开始，in是一个有效的关键字：

    The in parameter modifier is available in C# 7.2 and later. Previous versions generate compiler error CS8107 ("Feature 'readonly references' is not available in C# 7.0. Please use language version 7.2 or greater.") To configure the compiler language version, see Select the C# language version.

    ...

    The in keyword causes arguments to be passed by reference. It makes the formal parameter an alias for the argument, which must be a variable. In other words, any operation on the parameter is made on the argument. It is like the ref or out keywords, except that in arguments cannot be modified by the called method. Whereas ref arguments may be modified, out arguments must be modified by the called method, and those modifications are observable in the calling context.