Question

Im making a system which should be running 24/7, with timers to control it. There are many calls to the database, and at some point, two methods are trying to open a connection, and one of them will fail. I’ve tried to make a retry method, so my methods would succeed. With the help from Michael S. Scherotter and Steven Sudit’s methods in Better way to write retry logic without goto, does my method look like this:

        int MaxRetries = 3;
        Product pro = new Product();
        SqlConnection myCon = DBcon.getInstance().conn();

        string barcod = barcode;

        string query = string.Format("SELECT * FROM Product WHERE Barcode  = @barcode");

        for (int tries = MaxRetries; tries >= 0; tries--) //<-- 'tries' at the end, are unreachable?. 
        {
            try
            {

                myCon.Open();
                SqlCommand com = new SqlCommand(query, myCon);
                com.Parameters.AddWithValue("@barcode", barcode);
                SqlDataReader dr = com.ExecuteReader();
                if (dr.Read())
                {
                    pro.Barcode = dr.GetString(0);
                    pro.Name = dr.GetString(1);
                }

                    break;
                }
                catch (Exception ex)
                {
                    if (tries == 0)
                        Console.WriteLine("Exception: "+ex);
                        throw;

                }
                }



        myCon.Close();
        return pro;

When running the code, the program stops at the “for(…..)”, and the exception: The connection was not closed. The connection’s current state is open… This problem was the reason why I’m trying to make this method! If anyone knows how to resovle this problem, please write. Thanks

Answer 1

Edited for new information

How about using Transactions to preserve data integrity, getting on-the-fly connections for multiple access and wrapping them in Using statements to ensure connections are closed? eg

        Using (SqlConnection myCon = new SqlConnection('ConnectionString'))
        {
          myCon.Open();
          var transaction = myCon.BeginTransaction();    
          try 
          { 
            // ... do some DB stuff - build your command with SqlCommand but use your transaction and your connection
           var sqlCommand = new SqlCommand(CommandString, myCon, transaction);
           sqlCommand.Parameters.Add(new Parameter()); // Build up your params
           sqlCommand.ExecuteNonReader(); // Or whatever type of execution is best
           transaction.Commit();  // Yayy!
        } 
        catch (Exception ex) 
        { 
            transaction.RollBack();  // D'oh!
            // ... Some logging
        } 

        myCon.Close();
    }

This way even if you forget to Close the connection, it will still be done implicitly when the connection gets to the end of its Using statement.