what is use of out parameter in c#

Question

Can you please tell me what is the exact use of out parameter?

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

Answer 1

http://msdn.microsoft.com/en-us/vcsharp/aa336814.aspx

Out parameters are output only parameters meaning they can only passback a value from a function.We create a "out" parameter by preceding the parameter data type with the out modifier. When ever a "out" parameter is passed only an unassigned reference is passed to the function.

using System;
class ParameterTest
{
 static void Mymethod(out int Param1)
 {
  Param1=100;
 }
 static void Main()
 {
  int Myvalue=5;
  MyMethod(Myvalue);
  Console.WriteLine(out Myvalue);             
 }
}

Output of the above program would be 100 since the value of the "out" parameter is passed back to the calling part. Note

The modifier "out" should precede the parameter being passed even in the calling part. "out" parameters cannot be used within the function before assigning a value to it. A value should be assigned to the "out" parameter before the method returns.

Answer 2

The out method parameter keyword on a method parameter causes a method to refer to the same variable that was passed into the method. Any changes made to the parameter in the method will be reflected in that variable when control passes back to the calling method.

Declaring an out method is useful when you want a method to return multiple values. A method that uses an out parameter can still return a value. A method can have more than one out parameter.

To use an out parameter, the argument must explicitly be passed to the method as an out argument. The value of an out argument will not be passed to the out parameter.

A variable passed as an out argument need not be initialized. However, the out parameter must be assigned a value before the method returns.

An Example:

using System;
public class MyClass 
{
   public static int TestOut(out char i) 
   {
      i = 'b';
      return -1;
   }

   public static void Main() 
   {
      char i;   // variable need not be initialized
      Console.WriteLine(TestOut(out i));
      Console.WriteLine(i);
   }
}

Answer 3

The typical use case is a method that needs to return more than one thing, so it can't just use the return value. Commonly, the return value is used for a success flag while the out parameter(s) sets values when the method is successful.

The classic example is:

public bool TryGet( 
   string key,
   out string value
)

If it returns true, then value is set. Otherwise, it's not. This lets you write code such as:

string value;
if (!lookupDictionary.TryGet("some key", out value))
  value = "default";

Note that this doesn't require you to call Contains before using an indexer, which makes it faster and cleaner. I should also add that, unlike the very similar ref modifier, the compiler won't complain if the out parameter was never initialized.

Answer 4

from http://msdn.microsoft.com/en-us/vcsharp/aa336814.aspx

One way to think of out parameters is that they are like additional return values of a method. They are very convenient when a method returns more than one value, in this example firstName and lastName. Out parameters can be abused however. As a matter of good programming style if you find yourself writing a method with many out parameters then you should think about refactoring your code. One possible solution is to package all the return values into a single struct.

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. Ref parameters are passed both into and out of a method.

Answer 5

The best example of a good use of an out parameter are in the TryParse methods.

int result =-1;
if (!Int32.TryParse(SomeString, out result){
    // log bad input
}

return result;

Using TryParse instead of ParseInt removes the need to handle exceptions and makes the code much more elegant.

The out parameter essentially allows for more than one return values from a method.

Answer 6

Jon Skeet describes the different ways of passing parameters in great detail in this article. In short, an out parameter is a parameter that is passed uninitialized to a method. That method is then required to initialize the parameter before any possible return.

Answer 7

generally we cannot get the variables inside a function if we don't get by a return value. but use keyword "out" we can change it value by a function.

Answer 8

Besides allowing you to have multiple return values, another use is to reduce overhead when copying a large value type to a method. When you pass something to a method, a copy of the value of that something is made. If it's a reference type (string for example) then a copy of the reference (the value of a reference type) is made. However, when you copy a value type (a struct like int or double) a copy of the entire thing is made (the value of a value type is the thing itself). Now, a reference is 4 bytes (on 32-bit applications) and an int is 4 bytes, so the copying is not a problem. However, it's possible to have very large value types and while that's not recommended, it might be needed sometimes. And when you have a value type of say, 64 bytes, the cost of copying it to methods is prohibitive (especially when you use such a large struct for performance reasons in the first place). When you use out, no copy of the object is made, you simply refer to the same thing.

public struct BigStruct
{
  public int A, B, C, D, E, F, G, H, J, J, K, L, M, N, O, P;
}

SomeMethod(instanceOfBigStruct); // A copy is made of this 64-byte struct.

SomeOtherMethod(out instanceOfBigStruct); // No copy is made

A second use directly in line with this is that, because you don't make a copy of the struct, but refer to the same thing in the method as you do outside of the method, any changes made to the object inside the method, are persisted outside the method. This is already the case in a reference type, but not in value types.

Some examples:

 public void ReferenceExample(SomeReferenceType s)
 {
   s.SomeProperty = "a string"; // The change is persisted to outside of the method
 }

 public void ValueTypeExample(BigStruct b)
 {
   b.A = 5; // Has no effect on the original BigStruct that you passed into the method, because b is a copy!
 }

 public void ValueTypeExampleOut(out BigStruct b)
 {
   b = new BigStruct();
   b.A = 5; // Works, because you refer to the same thing here
 }

Now, you may have noticed that inside ValueTypeExampleOut I made a new instance of BigStruct. That is because, if you use out, you must assign the variable to something before you exit the method.

There is however, another keyword, ref which is identical except that you are not forced to assign it within the method. However, that also means you can't pass in an unassigned variable, which would make that nice Try.. pattern not compile when used with ref.

int a;
if(TrySomething(out a)) {}

That works because TrySomething is forced to assign something to a.

int a;
if(TrySomething(ref a)) {}

This won't work because a is unassigned (just declared) and ref requires that you only use it with an assigned variable.

This works because a is assigned:

int a = 0;
if(TrySomething(ref a)) {}

However, in both cases (ref and out) any changes made to a within the TrySomething method are persisted to a.

As I already said, changes made to a reference type are persisted outside the method in which you make them, because through the reference, you refer to the same thing.

However, this doesn't do anything:

public void Example(SomeReferenceType s)
{
  s = null;
}

Here, you just set the copy of a reference to s to null, which only exists within the scope of the method. It has zero effect on whatever you passed into the method.

If you want to do this, for whatever reason, use this:

public void Example1(ref SomeReferenceType s)
{
  s = null; // Sets whatever you passed into the method to null
}

I think this covers all use-cases of out and ref.