What is the difference between ref and out? (C#)

Any succinct explanations?

Also Answered in: http://stackoverflow.com/questions/135234/difference-between-ref-and-out-parameters-in-net

From stackoverflow

• See this article on MSDN. They both accomplish subtly different things, really.

• Duplicate question: http://stackoverflow.com/questions/135234/difference-between-ref-and-out-parameters-in-net

• Ref and out parameter passing modes are used to allow a method to alter variables passed in by the caller. The difference between ref and out is subtle but important. Each parameter passing mode is designed to apply to a slightly different programming scenario. The important difference between out and ref parameters is the definite assignment rules used by each.

  The caller of a method which takes an out parameter is not required to assign to the variable passed as the out parameter prior to the call; however, the callee is required to assign to the out parameter before returning.

  source: MSDN

• Check out this Jon Skeet article about params in c#:

  http://www.yoda.arachsys.com/csharp/parameters.html

• Most succinct way of viewing it:

  ref = inout

  out = out

  Andrew Bullock : not the best explaination ive seen, tbh

  Binary Worrier : But it is the most succinct, which is what was asked for.

  Mike Christiansen : While it may be succinct, it's also extremely lacking.

• For the caller:

  • For a ref parameter, the variable has to be definitely assigned already
  • For an out parameter, the variable doesn't have to be definitely assigned, but will be after the method returns

  For the method:

  • A ref parameter starts off definitely assigned, and you don't have to assign any value to it
  • An out parameter doesn't start off definitely assigned, and you have to make sure that any time you return (without an exception) it will be definitely assigned

  So:

  int x;
  Foo(ref x); // Invalid: x isn't definitely assigned
  Bar(out x); // Valid even though x isn't definitely assigned
  Console.WriteLine(x); // Valid - x is now definitely assigned
  
  ...
  
  public void Foo(ref int y)
  {
      Console.WriteLine(y); // Valid
      // No need to assign value to y
  }
  
  public void Bar(out int y)
  {
      Console.WriteLine(y); // Invalid: y isn't definitely assigned
      if (someCondition)
      {
          // Invalid - must assign value to y before returning
          return;
      }
      else if (someOtherCondition)
      {
          // Valid - don't need to assign value to y if we're throwing
          throw new Exception();
      }
      else
      {
          y = 10;
          // Valid - we can return once we've definitely assigned to y
          return;
      }
  }
  

  JaredPar : What's really interesting though is the CLR has no concept of ref. It's a c# semantic.

  Jon Skeet : Don't you mean that the CLR understands ref but not out?

  Jon Skeet : (I thought that was the case, anyway - that the C# compiler just adds the [Out] attribute for out methods, and makes appropriate checks, but that it was otherwise just a ref parameter.)

  JaredPar : @Jon, doh! Yes your are correct. I have it backwards

  Jon Skeet : Thank goodness for that. The whole of my knowledge, identity, soul and being is derived from that fact. I was trembling on the brink... (Seriously though, I would have been surprised and slightly disturbed.)

• From the MSDN article that Alex mentions,

  The caller of a method which takes an out parameter is not required to assign to the variable passed as the out parameter prior to the call; however, the callee is required to assign to the out parameter before returning.

  In contrast ref parameters are considered initially assigned by the callee. As such, the callee is not required to assign to the ref parameter before use.

  So to sum up, inside the method you can consider ref parameters to be set, but not out parameters - you must set these. Outside the method they should act the same.