Allow using statement in out variable declaration

[adam-frisby]

C# 8.0 introduced the using declaration, which is convenient but cannot be used with out parameters. This leads to the awkward code below.

TextReader reader = null;
try
{
    if (this.TryOpenReader(sourceName, out reader))
    {
        ...
    }
}
finally
{
    reader?.Dispose();
}

This could be simplified if the following code was valid

if (this.TryOpenReader(sourceName, using out var reader))
{
    ...
}

[gabeluci]

This isn't quite as short as what you propose, but you can use an already-existing variable as the subject of a using, so you can do this:

if (this.TryOpenReader(sourceName, out var reader))
{
    using (reader) 
    {
        ...
    }
}

That is assuming, of course, that if TryOpenReader returns false, there is no need to dispose.

[adam-frisby]

The problem with that is if TryOpenReader doesn't return true, reader is not disposed of. In the real world, reader would most likely be null in this case, but it'll still trigger warnings

[theunrepentantgeek]

I think this idea (or one similar to it) has been discussed elsewhere, but I can't find a reference.

The effective scope is unclear - would reader be disposed at the end of the expression, at the end of the true side of the if block, or at the end of the enclosing block? I can see good arguments for each of those answers.

The advantage of a distinct using declaration is that it's not participating in the creation of a nested scope, so it's clear that disposal will happen at the end of the enclosing block.

[adam-frisby]

The same scoping rules which currently apply simply continues to apply.

This is valid code which demonstrates the scope of result is not limited to the if block

    static void Foo()
    {
        if (int.TryParse("1", out var result)) // 'result' enters scope
        {
            doSomething(result);
        }

        // 'result' is still in scope even here
        var x = result;

    } // 'result' exits scope

and thus

    static void Bar()
    {
        if (this.TryOpenReader(sourceName, using out var reader)) // 'reader' enters scope
        {
            doSomething(reader);
        }

        // 'reader' is still in scope even here
        var x = reader?.readInt();

    } // 'reader' exits scope, 'reader' is disposed

I think the scope of a variable declared in an if statement is another topic and that ship has already sailed. If one wishes to limit the scope of the 'result' one could do the following.

    static void Foo()
    {
        {
            if (int.TryParse("1", out var result)) // 'result' enters scope
            {
                doSomething(result);
            }
            else
            {
                doSomethingElse();
            }
        } // 'result' exits scope

        // 'result' is not in scope here
    }

[ronnygunawan]

I think this idea (or one similar to it) has been discussed elsewhere, but I can't find a reference.

I think it's this one: #2894

[HaloFour]

This also works:

if (this.TryOpenReader(sourceName, out var reader)) using (reader)
{

}

[jaredpar]

I am simultaneously in awe and horrified by this sample.

[john-h-k]

This also works:

if (this.TryOpenReader(sourceName, out var reader)) using (reader)
{

}

The problem is this messes up auto formatters for me

[jeremy-visionaid]

Methods with IDisposable out parameters are really common in the macios bindings since almost all classes there are dispoable. This includes basically anything that returns an error (like IMTLLibrary? CreateDefaultLibrary(NSBundle bundle, out NSError error).

Allowing a using statement/keyword for in-line variable declarations would make code for iOS/MacCatalyst much more elegant IMHO.

[jeremy-visionaid]

Maybe I'll modify that to say "somewhat" common 😅 I was thinking about trying to enforce CA2000 in CI and it came up a fair bit in Apple platform code, but actually I can take care of most of it just by excluding NSError:
dotnet_code_quality.CA2000.excluded_symbol_names = NSError