C# try-catch-else

Question

One thing that has bugged me with exception handling coming from Python to C# is that in C# there doesn\'t appear to be any way of specifying an else clause. For example, in

Answer 1

You could write it like:

bool success = false;
try {
    reader = new StreamReader(path);
    success = true;
}
catch(Exception) {
    // Uh oh something went wrong with opening the file for reading
}
finally {
    if(success) {
        string line = reader.ReadLine();    
        char character = line[30];
    }
}   

Answer 2

Sounds like you want to do the second thing only if the first thing succeeded. And maybe catching different classes of exception is not appropriate, for example if both statements could throw the same class of exception.

try
{
    reader1 = new StreamReader(path1);
    // if we got this far, path 1 succeded, so try path2
    try
    {
        reader2 = new StreamReader(path2);

    }
    catch (OIException ex)
    {
        // Uh oh something went wrong with opening the file2 for reading
        // Nevertheless, have a look at file1. Its fine!
    }
}
catch (OIException ex)
{
    // Uh oh something went wrong with opening the file1 for reading.
    // So I didn't even try to open file2
}

Answer 3

Is there any similar construct I can use in C# to acheive the same thing?

No.

Wrap your index accessor with an "if" statement which is the best solution in your case in case of performance and readability.

if (line.length > 30) {
   char character = line [30];
} 

Answer 4

You can have multiple catch clauses, each specific to the type of exception you wish to catch. So, if you only want to catch IOExceptions, then you could change your catch clause to this:

try
{
    reader = new StreamReader(path);
    string line = reader.ReadLine();
    char character = line[30];
}
catch (IOException)
{    
}

Anything other than an IOException would then propagate up the call stack. If you want to also handle other exceptions, then you can add multiple exception clauses, but you must ensure they are added in most specific to most generic order. For example:

try
{
    reader = new StreamReader(path);
    string line = reader.ReadLine();
    char character = line[30];
}
catch (IOException)
{    
}
catch (Exception)
{
}

Answer 5

There might not be any native support for try { ... } catch { ... } else { ... } in C#, but if you are willing to shoulder the overhead of using a workaround, then the example shown below might be appealing:

using System;

public class Test
{
    public static void Main()
    {
        Example("ksEE5A.exe");
    }

    public static char Example(string path) {
        var reader = default(System.IO.StreamReader);
        var line = default(string);
        var character = default(char);
        TryElse(
            delegate {
                Console.WriteLine("Trying to open StreamReader ...");
                reader = new System.IO.StreamReader(path);
            },
            delegate {
                Console.WriteLine("Success!");
                line = reader.ReadLine();
                character = line[30];
            },
            null,
            new Case(typeof(NullReferenceException), error => {
                Console.WriteLine("Something was null and should not have been.");
                Console.WriteLine("The line variable could not cause this error.");
            }),
            new Case(typeof(System.IO.FileNotFoundException), error => {
                Console.WriteLine("File could not be found:");
                Console.WriteLine(path);
            }),
            new Case(typeof(Exception), error => {
                Console.WriteLine("There was an error:");
                Console.WriteLine(error);
            }));
        return character;
    }

    public static void TryElse(Action pyTry, Action pyElse, Action pyFinally, params Case[] pyExcept) {
        if (pyElse != null && pyExcept.Length < 1) {
            throw new ArgumentException(@"there must be exception handlers if else is specified", nameof(pyExcept));
        }
        var doElse = false;
        var savedError = default(Exception);
        try {
            try {
                pyTry();
                doElse = true;
            } catch (Exception error) {
                savedError = error;
                foreach (var handler in pyExcept) {
                    if (handler.IsMatch(error)) {
                        handler.Process(error);
                        savedError = null;
                        break;
                    }
                }
            }
            if (doElse) {
                pyElse();
            }
        } catch (Exception error) {
            savedError = error;
        }
        pyFinally?.Invoke();
        if (savedError != null) {
            throw savedError;
        }
    }
}

public class Case {
    private Type ExceptionType { get; }
    public Action<Exception> Process { get; }
    private Func<Exception, bool> When { get; }

    public Case(Type exceptionType, Action<Exception> handler, Func<Exception, bool> when = null) {
        if (!typeof(Exception).IsAssignableFrom(exceptionType)) {
            throw new ArgumentException(@"exceptionType must be a type of exception", nameof(exceptionType));
        }
        this.ExceptionType = exceptionType;
        this.Process = handler;
        this.When = when;
    }

    public bool IsMatch(Exception error) {
        return this.ExceptionType.IsInstanceOfType(error) && (this.When?.Invoke(error) ?? true);
    }
}

Answer 6

If you happen to be in a loop, then you can put a continue statement in the catch blocks. This will cause the remaining code of that block to be skipped.

If you are not in a loop, then there is no need to catch the exception at this level. Let it propagate up the call stack to a catch block that knows what to do with it. You do this by eliminating the entire try/catch framework at the current level.

I like try/except/else in Python too, and maybe they will get added to C# some day (just like multiple return values were). But if you think about exceptions a little differently, else blocks are not strictly necessary.