out

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out

You can use the out contextual keyword in two contexts:

• As a parameter modifier, which lets pass an argument to a method by reference rather than by value.

• In generic type parameter declarations for interfaces and delegates, which specifies that a type parameter is covariant.

out parameter modifier (C# Reference)

https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/out-parameter-modifier

When should I use out parameters?

Out is good when you have a TryNNN function and it's clear that the out-parameter will always be set even if the function does not succeed.

This allows you rely on the fact that the local variable you declare will be set rather than having to place checks later in your code against null.

(A comment below indicates that the parameter could be set to null, so you may want to verify the documentation for the function you're calling to be sure if this is the case or not.)

It makes the code a little clearer and easier to read.

Another case is when you need to return some data and a status on the condition of the method like:

public bool DoSomething(int arg1, out string result);

In this case the return can indicate if the function succeeded and the result is stored in the out parameter.

Admittedly, this example is contrived because you can design a way where the function simply returns a string, but you get the idea.

A disadvantage is that you have to declare a local variable to use them:

string result;
if (DoSomething(5, out result))
    UpdateWithResult(result);

Instead of:

UpdateWithResult(DoSomething(5));

However, that may not even be a disadvantage, it depends on the design you're going for.

In the case of DateTime, both means (Parse and TryParse) are provided.

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

Output parameters

Like reference parameters, output parameters don't create a new storage location, but use the storage location of the variable specified on the invocation. Output parameters need the out modifier as part of both the declaration and the invocation - that means it's always clear when you're passing something as an output parameter.

Output parameters are very similar to reference parameters. The only differences are:

• The variable specified on the invocation doesn't need to have been assigned a value before it is passed to the function member. If the function member completes normally, the variable is considered to be assigned afterwards (so you can then "read" it).
• The parameter is considered initially unassigned (in other words, you must assign it a value before you can "read" it in the function member).
• The parameter must be assigned a value before the function member completes normally.

Here is some example code showing this, with an int parameter (int is a value type, but if you understood reference parameters properly, you should be able to see what the behaviour for reference types is):

void Foo (out int x)
{
    // Can't read x here - it's considered unassigned

    // Assignment - this must happen before the method can complete normally
    x = 10;

    // The value of x can now be read:
    int a = x;
}

...

// Declare a variable but don't assign a value to it
int y;

// Pass it in as an output parameter, even though its value is unassigned
Foo (out y);

// It's now assigned a value, so we can write it out:
Console.WriteLine (y);