Solución final

La conexión se agregó al grupo de conexiones. Así que lo cerré, pero aún permanecía físicamente abierto. Con el parámetro ConnectionString "Pooling = false" o los métodos estáticos MySqlConnection.ClearPool (conexión) y MySqlConnection.ClearAllPools, se puede evitar el problema. Tenga en cuenta que el problema era que la conexión aún estaba viva cuando cerré la aplicación. Aunque lo cerré. Entonces, o no uso la agrupación de conexiones en absoluto o borro la agrupación específica antes de cerrar la conexión y el problema se resuelve. Me tomaré mi tiempo para descubrir cuál es la mejor solución en mi caso.

¡Gracias a todos los que respondieron! Me ayudó a comprender mejor los conceptos de C # y aprendí mucho de los útiles aportes. :)

===

Problema original:

He buscado durante un tiempo y no he encontrado la solución para mi problema: soy nuevo en C # e intento escribir una clase para facilitar las conexiones MySql. Mi problema es que después de abrir una conexión y cerrarla. Todavía está abierto en la base de datos y se anula.

Estoy usando la declaración 'using' ', por supuesto, pero la conexión aún está abierta y se cancela después de salir del programa.

Así es como se ve mi código:

using (DatabaseManager db = new DatabaseManager())
{
using (MySqlDataReader result = db.DataReader("SELECT * FROM module WHERE Active=1 ORDER BY Sequence ASC"))
{
    foreach (MySqlDataReader result in db.DataReader("SELECT * FROM module WHERE Active=1 ORDER BY Sequence ASC"))
    {
        //Do stuff here
    }
}
}

El administrador de base de datos de clase abre la conexión y la cierra cuando se elimina:

public DatabaseManager()
{
    this.connectionString = new MySqlConnectionStringBuilder("Server=localhost;Database=businessplan;Uid=root;");
    connect();
}
private bool connect()
{
    bool returnValue = true;
    connection = new MySqlConnection(connectionString.GetConnectionString(false));
    connection.Open();
}

public void Dispose()
{
    Dispose(true);
}

public void Dispose(bool disposing)
{
    if (disposing)
    {
        if (connection.State == System.Data.ConnectionState.Open)
        {
            connection.Close();
            connection.Dispose();
        }
    }
    //GC.SuppressFinalize(this);//Updated
}
//Updated
//~DatabaseManager()
//{
//  Dispose(false);
//}

Entonces, lo verifiqué en el depurador y el método Dispose () se llama y se ejecuta correctamente. ¿Qué me estoy perdiendo? ¿Hay algo que hice mal o entendí mal?

¡Se agradece cualquier ayuda!

Greetings, Simon

P.S .: por si acaso, el método DataReader () - (versión actualizada):

public IEnumerable<IDataReader> DataReader(String query)
    {
        using (MySqlCommand com = new MySqlCommand())
        {
            com.Connection = connection;
            com.CommandText = query;
            using (MySqlDataReader result = com.ExecuteReader(System.Data.CommandBehavior.CloseConnection))
            {
                while (result.Read())
                {
                    yield return (IDataReader)result;
                }
            }
        }
    }

Ok, traté de usar el rendimiento de rendimiento:

foreach (MySqlDataReader result in db.DataReader("SELECT * FROM module WHERE Active=1 ORDER BY Sequence ASC"))
{
    //...
}

Y cambié el método DataReader:

public IEnumerable<IDataReader> DataReader(String query)
    {
        using (MySqlCommand com = new MySqlCommand())
        {
            com.Connection = connection;
            com.CommandText = query;
            using (MySqlDataReader result = com.ExecuteReader())
            {
                while (result.Read())
                {
                    yield return (IDataReader)result;
                }
            }
        }
    }

Funciona de la forma en que puedo recuperar los datos, pero aún tengo el mismo problema: la conexión no está cerrada correctamente. :