[Proposal] try if: only execute try-catch-finally block if a condition evaluates to true

[Matsyir]

Try-catch is often used in contexts that are already heavy on indentation, for example within a callback function's declaration, after an API call return, within a few nested using statements, or even nested within another try-catch if trying to perform commonly problematic actions with untrusted user input involved, and more... I'm sure we've all been in such a situation before, already 6 indents deep, and it's time for yet another try-catch.

Sometimes (often, I find), you'll also want a try-catch to only execute after a condition is met, which is yet another indentation. It could be helpful for readability & conciseness to provide an alternate syntax for try-catch, where you can provide a condition to be met before evaluating the try-catch itself.

Consider the following code:

if (someCondition)
{
    try
    {
        someFunction();
    }
    catch (Exception e)
    {
        Console.WriteLine("Exception caught: " + e);
    }
    finally
    {
        someOtherFunction();
    }
}

Could be reduced to the following with such a feature:

try if (someCondition)
{
    someFunction();
}
catch (Exception e)
{
    Console.WriteLine("Exception caught: " + e);
}
finally
{
    someOtherFunction();
}

Presumably, the finally would also only execute if the condition evaluated to true, since the whole try-catch isn't being executed at all if the condition doesn't evaluate to true. This would also reflect the behavior from the "existing" example code from above.

In my opinion this feature seems very intuitive to use, and it also remains optional for anyone to use or ignore. I don't think there could be any unintended side-effects, though I don't know much when it comes to the actual language development.

I do not think this should include any support for anything regarding else, else if, try else, try else if, etc. The try if on its own is simple and intuitive, but those could get messy (there are ways they could work, and be useful, but it would get unnecessarily complicated IMO). If you need to use some variation of else, you can keep using the original syntax.

I realize that there are other ways to address over-indenting in these situations, and that over-indenting can be a good indicator that a process is due for a slight re-factor. Still, I think this alternate syntax could be very helpful in terms of readability and will also help to make well-organized code even more organized/readable.

[HaloFour]

You can already do this:

if (someCondition) try
{
    someFunction();
}
catch (Exception e)
{
    Console.WriteLine("Exception caught: " + e);
}
finally
{
    someOtherFunction();
}

[Matsyir]

Wow, thank you. Can't believe I couldn't find this/figure this out before taking the time to write this. I did search for it!

[333fred]

Important caveat: I don't know whether, from the original proposal, @Matsyir wants someCondition to enter the catch if it throws, or finally block. The syntax in the original proposal looks like it does want that, given try if.

[Matsyir]

Interesting caveat, but no - that's not really what I had in mind. The intended behavior should be just like the original code, so the condition is unrelated to the catch or finally. From my understanding, @HaloFour's answer should be the behavior I'm after.

[HaloFour]

A caveat might be that some formatters might fight you.

[333fred]

Excellent, then I definitely don't want the syntax you proposed, because that what it implies to me 😆.