Allow using block to dispose Tuple contains some object with Dispose

[Thaina]

I wish this code be possible

class T : IDisposable
{
    public void Dispose() => ;
}

public (T left,T right) GetPair()
{
    return (l,r);
}

////

using(var (left,right) = GetPair())
{
    // DoSomething
}

Just be transpiled it to

{
    var _ = GetPair();
    using(var right = _.right)
    using(var left = _.left)
    {
        // DoSomething
    }
}

This could also allow writing using on multiple object in one line just by tuple deconstruction

using(var (left,middle,right) = (new T(),new T(),new T()))
{
    // DoSomething
}

//// became

using(var right = new T())
using(var middle = new T())
using(var left = new T())
{
    // DoSomething
}

Also I wish the using on tuple would allow on tuple with Any object contain dispose not All

public (T left,int x,T right) GetPairWithNumber()
{
    return (l,9,r);
}

////

using(var (left,i,right) = GetPairWithNumber(0))
{
    // DoSomething
}

//// became
var _ = GetPair();
using(var right = _.right)
{
    var i = _.x; // Skip using on tuple member that cannot be disposed
    using(var left = _.left)
    {
        // DoSomething
    }
}

[jnm2]

Just like the tuple-of-tasks GetAwaiter() extension methods, if we get #93, you'll be able to enable the syntax you're asking for here by defining the extension method Dispose(this (IDisposable, IDisposable) tuple).

Same, if we get extension interface implementations. (Can someone confirm whether the same thing would work with #164?)

[Thaina]

@jnm2 I was propose this so we could have mixed of disposable object and not disposable object in tuple like the last example I post. If it not support by tuple syntax itself, we then need to have Dispose extension for each permutation

[jnm2]

We can see what they say!

// Maybe
using (var x = GetDisposable(), var y = GetDisposable())
{
}

// Then
using (var x, var y) = GetDeconstructable()
{
}

Dunno, seems like a rare case but it does make sense.

[dmitriyse]

This is not a rare case.

[Thaina]

Well, thinking about it again maybe #93 would work if using would dispose the Tuple, not the deconstructed variable

public static void Dispose<T0,T1>(this (T0,T1) tuple)
{
    (tuple.Item0 as IDisposable)?.Dispose();
    (tuple.Item1 as IDisposable)?.Dispose();
}

using(var (x,y) = GetDeconstructable())
{

// Will it dispose the x and y? Or it would dispose the GetDeconstructable() ???
}

But then again it lose the Dispose by convention for each item. Not to mention using would more likely dispose the variable, not the assigned object

Really, just let using handle dispose on each deconstructed object would be better