try / catch块未捕获异常

Question

I am having an issue where an exception is not being caught by try/catch block. The issue occurs at command.ExecuteReader() , however it never gets caught. I am running in debug mode and have already tried a few suggested options in regards to the debugger settings with no avail.

I do want to mention that I am using SQLite as my provider, and I can see that it throws an SQLiteException, however the issue remains. Would there be any specific scenario where an exception is not caught? (with exception of StackOverflowException, ThreadAbortedException etc...)

    public IEnumerable<dynamic> Query(string sql, params object[] parms)
    {
        try
        {
            return QueryCore(sql, parms);
        }
        catch (Exception ex)
        {
            throw new DbException(sql, parms, ex);
        }
    }

    private IEnumerable<dynamic> QueryCore(string sql, params object[] parms)
    {
        using (var connection = CreateConnection())
        {
            using (var command = CreateCommand(sql, connection, parms))
            {
                using (var reader = command.ExecuteReader())
                {
                    while (reader.Read())
                    {
                        yield return reader.ToExpando();
                    }
                }
            }
        }
    }

I also want to add that if I produce a correct query against the database, I get results back, however when I break the query, the exception is thrown, however not caught.

Answer 1

This happens because you are returning the data with the yield keyword. This makes the data actual data method to run only when it's results are enumerated.

You probably don't want this to happen, especially because if the results are enumerated twice (eg two seperate foreach loops) the data will be read twice. You can do this to make the enumeration to happen immediately and catch any exception:

public IEnumerable<dynamic> Query(string sql, params object[] parms)
{
    try
    {
        return QueryCore(sql, parms).ToArray();
    }
    catch (Exception ex)
    {
        throw new DbException(sql, parms, ex);
    }
}

Yielding is good for situations where getting an item takes some time, and you don't want to get ALL the items before you can loop through them. So another possible solution, that might be better for the readability of your code (that I assume doesn't need to yield) will be this:

public IEnumerable<dynamic> Query(string sql, params object[] parms)
{
    try
    {
        return QueryCore(sql, parms);
    }
    catch (Exception ex)
    {
        throw new DbException(sql, parms, ex);
    }
}

private IEnumerable<dynamic> QueryCore(string sql, params object[] parms)
{
    using (var connection = CreateConnection())
    {
        using (var command = CreateCommand(sql, connection, parms))
        {
            using (var reader = command.ExecuteReader())
            {
                var results = new List<dynamic>();
                while (reader.Read())
                {
                    results.Add(reader.ToExpando());
                }

                return results;
            }
        }
    }
}