Esempio n. 1
0
        private T _Execute <T>(QueryContext queryContext, Func <MySqlConnection, int, T> queryFunc)
        {
            Interlocked.Increment(ref _runningQueries);

            T result = default;

            try
            {
                do
                {
                    try
                    {
                        using (MySqlConnection connection = new MySqlConnection(_connectionString))
                        {
                            connection.Open();
                            result = queryFunc(connection, queryContext.CommandTimeOut);
                            connection.Close();
                            break;
                        }
                    }
                    catch (MySqlException ex)
                    {
                        //получаем обработчик ошибки
                        if (_exceptionHandlers.TryGetValue(ex.Number, out Action <Exception, QueryContext> action))
                        {
                            action?.Invoke(ex, queryContext);
                            ErrorProcessed?.Invoke(ex, queryContext);
                        }
                        else
                        {
                            Error?.Invoke(ex, queryContext);
                            return(result);
                        }
                    }
                    catch (Exception ex)
                    {
                        if (_exceptionHandlers.TryGetValue(-1, out Action <Exception, QueryContext> action))
                        {
                            action?.Invoke(ex, queryContext);
                            ErrorProcessed?.Invoke(ex, queryContext);
                        }
                        else
                        {
                            Error?.Invoke(ex, queryContext);
                            return(result);
                        }
                    }

                    //Если разрешено зацикливание запроса
                    if (queryContext.Retry)
                    {
                        Thread.Sleep(IntervalBetweenTrying);//делаем паузу в запросах
                    }
                } while (queryContext.Retry);
            }
            finally
            {
                Interlocked.Decrement(ref _runningQueries);
            }

            return(result);
        }
Esempio n. 2
0
        private T _Execute <T>(string query, bool loopQuery, Func <MySqlConnection, T> queryFunc)
        {
            Interlocked.Increment(ref runningQueries);

            T result = default(T);

            try
            {
                do
                {
                    try
                    {
                        using (MySqlConnection connection = new MySqlConnection(connectionString))
                        {
                            connection.Open();
                            result = queryFunc(connection);
                            break;
                        }
                    }
                    catch (MySqlException ex)
                    {
                        //получаем обработчик ошибки
                        if (ExceptionHandlers.TryGetValue(ex.Number, out Action <Exception> action))
                        {
                            action(ex);
                            ErrorProcessed?.Invoke(ex, query);
                        }
                        else
                        {
                            //стандартные обработчики ошибок
                            switch (ex.Number)
                            {
                            case 1042:    //ER_BAD_HOST_ERROR
                                ErrorProcessed?.Invoke(ex, query);
                                break;

                            case 1205:    //ER_LOCK_WAIT_TIMEOUT
                                ErrorProcessed?.Invoke(ex, query);
                                break;

                            case 1213:    //ER_LOCK_DEADLOCK
                                ErrorProcessed?.Invoke(ex, query);
                                break;

                            default:
                                Error?.Invoke(ex, query);
                                return(result);
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Error?.Invoke(ex, query);
                        break;
                    }

                    //Если разрешено зацикливание запроса
                    if (loopQuery)
                    {
                        Thread.Sleep(LoopTimeOut);//делаем паузу в запросах
                    }
                } while (loopQuery);
            }
            finally
            {
                Interlocked.Decrement(ref runningQueries);
            }
            return(result);
        }