[4.0-C#] Problema apertura/chiusura connessione

[GabbOne]

ok l'errore è proprio nel finally(sempre eseguito) della dllGruppi (anche se esternamente) nn pui utilizzare un reader chiuso ...

curioso che microsoft abbbia implementato un oggettto fatto in questo modo ciaps

[fermat]

Originariamente inviato da djciko
il metodo che ho scritto nel post precedente e' quello errato, l'ho riportato per evidenziare l'errore.

ok, cmq hai risolto

bhe io in verità ho risolto levando il finally ma così nn eseguo la chiusura della connessione.....

[djciko]

Originariamente inviato da fermat
bhe io in verità ho risolto levando il finally ma così nn eseguo la chiusura della connessione.....

la connessione va chiusa dopo aver fatto tutto ciò che serve con il reader.

Questo è uno degli esempi in rete
(nota che la connessione ed il reader non vengono chiusi finchè tutte le operazioni non sono completate)

[Visual Basic]

Public Sub ReadMyData(myConnString As String)
    Dim mySelectQuery As String = "SELECT OrderID, CustomerID FROM Orders"
    Dim myConnection As New SqlConnection(myConnString)
    Dim myCommand As New SqlCommand(mySelectQuery, myConnection)
    myConnection.Open()
    Dim myReader As SqlDataReader
    myReader = myCommand.ExecuteReader()
    ' Always call Read before accessing data.
    While myReader.Read()
        Console.WriteLine((myReader.GetInt32(0) & ", " & myReader.GetString(1)))
    End While
    ' always call Close when done reading.
    myReader.Close()
    ' Close the connection when done with it.
    myConnection.Close()
End Sub 'ReadMyData

Qui un altro esempio
http://msdn.microsoft.com/it-it/libr...der.close.aspx

[rsdpzed]

public void funcA()
{
    SqlDataReader drA = funcB();  //drA chiuso
}

public SqlDataReader funcB()
{
    //...
    SqlDataReader drB = cmd.ExecuteReader();
    //...
    return drB;  //Ora l'oggetto viene puntato da drA, ma se sei in try prima di passare a funcA viene eseguito il finally
    //..
    finally  //Questo blocco viene eseguito anche se sopra nel try hai fatto un return
    {
        drB.CLose();  //l'oggetto viene chiuso e drA sarà chiuso.
        conn.close(); 
    }
}

Lo scope di drB è limitato al metodo funcB. Nel momento in cui ritorni drB non fai una copia che viene riversata in drA ma passi semplicemente il riferimento all'oggetto a drA.
Ora drA e drB puntano allo stesso oggetto e la conseguenza di ciò è che lo scope dell'ogetto ora è anche funcA. Il Garbage collector non distruggerà drB alla fine della funcB.
A questo aggiungi che il blocco finally viene sempre eseguito anche se nel try fai una return perciò nel momento in cui tu chiudi la drB con drB.Close() nel finally, finisce che il drA in funcA è chiuso quindi inutilizzabile.
E non puoi nemmeno chiudere la conessione perchè SqlDataReader ha bisogno di una connessione aperta.
La soluzione non è "non chiudere la connessione". La soluzione è che il dataReader non andrebbe usato in quel modo ma andrebbe: aperto, letto magari per popolare una colection in memoria (List<Gruppi>), chiuso. Al limite passi la collection come datasource al controllo (DDL).

[fermat]

oppure potrei riempire un DataSet e passare quello all'Objectdatasource?

[rsdpzed]

cmq..
Si perchè il dataset è sconnesso, perciò non lo chiudi nel finally. Anzi se guardo sotto tu hai un metodo che gia fa cosi e che non ti da problemi se non sbaglio.
In ogni modo visto che stai usando gli ObjectDataSource la cosa piu opportuna sarebbe utilizzare oggetti in memoria. Però fai come meglio ti trovi.

[fermat]

Originariamente inviato da rsdpzed
cmq..
Si perchè il dataset è sconnesso, perciò non lo chiudi nel finally. Anzi se guardo sotto tu hai un metodo che gia fa cosi e che non ti da problemi se non sbaglio.
In ogni modo visto che stai usando gli ObjectDataSource la cosa piu opportuna sarebbe utilizzare oggetti in memoria. Però fai come meglio ti trovi.

che intendi per oggetti in memoria?

[djciko]

Originariamente inviato da fermat
che intendi per oggetti in memoria?

Intende gli oggetti che non hanno bisogno di essere connessi al DB, con una Connection aperta.

Cioè che 'vivono' anche senza legami con il DBase dopo la loro creazione.
In altre parole, Dataset - Datatable.

E' l'uso che fai del Datareader che è errato, tutto qui..

[fermat]

ah ok.
ho optato per questa soluzione:

        public DataSet ddlGruppi(int par)
        {
            DataSet ds = null;
            SqlDataAdapter adapter = null;
            SqlCommand cmd = null;
            try
            {
                conn.Open();
                if (par == 0)
                {
                    cmd = new SqlCommand("select_gruppi", conn);
                    cmd.CommandType = CommandType.StoredProcedure;
                    adapter = new SqlDataAdapter(cmd);
                }
                else
                {
                    cmd = new SqlCommand("select_gruppi_soluzione", conn);
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.Parameters.AddWithValue("@soluzione#", par);
                    adapter = new SqlDataAdapter(cmd);
                }
                ds = new DataSet();
                adapter.Fill(ds);
                return ds;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                ds.Dispose();
                adapter.Dispose();
                conn.Close();
            }
        }

funziona ma nn so se è quella ottimale.

[djciko]

 
        public DataSet ddlGruppi(int par)
        {
            DataSet ds = null;
            SqlDataAdapter adapter = null;
            SqlCommand cmd = null;
            try
            {
                conn.Open();
                if (par == 0)
                {
                    cmd = new SqlCommand("select_gruppi", conn);
                    cmd.CommandType = CommandType.StoredProcedure;
                    adapter = new SqlDataAdapter(cmd);
                }
                else
                {
                    cmd = new SqlCommand("select_gruppi_soluzione", conn);
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.Parameters.AddWithValue("@soluzione#", par);
                    adapter = new SqlDataAdapter(cmd);
                }
                ds = new DataSet();
                adapter.Fill(ds);          
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
            finally
            {
                ds.Dispose();
                adapter.Dispose();
                conn.Close();
            }
            return ds;
        }

Cosi' dovrebbe andare meglio, altrimenti dovresti avere un warning dovuto al fatto che non restituisci il valore in ogni percorso del codice. Vedi se va