Why use out keyword instead of assignment in c#?

Question

I've been investigating the out keyword in C# after reading the section about it in C# in Depth. I cannot seem to find an example that shows why the keyword is required over just assigning the value of a return statement. For example:

public void Function1(int input, out int output)
{
    output = input * 5;
}

public int Function2(int input)
{
    return input * 5;
}

...
int i;
int j;

Function1(5, out i);
j = Function2(5);

Both i and j now have the same value. Is it just the convenience of being able to initialize without the = sign or is there some other value derived that I'm not seeing? I've seen some similar answers mentioning that it shifts responsibility for initialization to the callee here. But all that extra instead of just assigning a return value and not having a void method signature?

Answer 1

Usually out is used for a method that returns something else, but you still need to get a different value from the method.

A good example is Int32.TryParse(input, out myVar) it will return true if it was successful and false otherwise. You can get the converted int via the out parameter.

int myOutVar;

if (Int32.TryParse("2", out myOutVar))
{
   //do something with the int
}else{
    //Parsing failed, show a message
}

Answer 2

The out / ref keywords in C# should only be used when you need to return multiple values. Even then you should first consider using a container type (such as Tuple) to return multiple values before you revert to out / ref. Whenever you're returning a single value it should just be returned.

Answer 3

A lot of times, using out can help by giving you a slight performance gain.

Consider the TryGetValue method on IDictionary (say myDictionary is an IDictionary<string, string>) Rather than doing this:

string value = String.Empty;
if (myDictionary.ContainsKey("foo"))
{
  value = myDictionary["foo"];
}

Both ContainsKey and the indexer need to look up the key in the dictionary, but you can avoid this double-lookup on the positive case by going:

string value;
if (!myDictionary.TryGetValue("foo", out value))
{
  value = String.Empty;
}

IMO, that's a decent reason for using out parameters.

Answer 4

Unfortunately we cannot do something like below in C#:

a,b = func(x,y,z);

something that we do in Python or other languages. out kind of overcomes that.

F# has overcome this with tuples I believe.

PS: Returning multiple values from a function might not be good always. Tiny types are good most of the times - http://www.martinfowler.com/bliki/DataClump.html

Answer 5

For example, Int32.TryParse returns boolean if it parsed correctly and with the out parameter changes the value. If the parsed value is 0 and it returns true it means the value you sent to parse was 0. If it returns false then the parser failed.

Answer 6

Some of it is for clarity. Take the TryParse() methods, like

Int32.TryParse("3", out myInt);

This returns a bool that indicates whether the string was able to be parsed into an int. If you just had

Int32.TryParse("3", myInt);

What happens when that's called? Is myInt assigned? Does TryParse return an int?

It's not readily apparent. But if I have an out parameter, then I know that the value is getting assigned, and that the return is something else.

Answer 7

Basically you do something like (my database read)

if (ReadSingle<UserRecord>(cmd, out user))
    Cache.Insert(cacheId, user, null,
        DateTime.MaxValue, TimeSpan.FromMinutes(3));

Or else you do something like:

user = ReadSingle<UserRecord>(cmd);
if(null != user)
   // Cache.Insert ...

It simplifies the code a little to use a boolean result (that a record was read from the database) and get the actual record into the variable via the out keyword.