[C#/Db(qualsiasi)]gestione open/close

[RaouL_BennetH]

Ciao a tutti :)

leggendo il 3d in sezione relativo ai linguaggi managed ed unmanaged, ho letto l'intervento di alcuni di voi che, se non ho capito male, sanno come fare per gestire correttamente le connessioni ad un database.

Per gestire correttamente intendo non solo come aprirle, ma anche come chiuderle.

Io generalmente ho provato in diversi modi, sia utilizzando lo 'using' garantendomi così una chiamata al metodo dispose, sia 'piazzando' io un close ed un dispose dopo averlo ritenuto opportuno.

Chiedo quindi a voi, mi potreste fare degli esempi su quale sia la pratica considerata corretta per gestire le connessioni ai database?

Grazie mille :)

RaouL.

[gugoXX]

La using e' meglio


string queryString =
"SELECT OrderID, CustomerID FROM dbo.Orders;";

using (SqlConnection connection =
new SqlConnection(connectionString))
{
SqlCommand command =
new SqlCommand(queryString, connection);
connection.Open();

SqlDataReader reader = command.ExecuteReader();

// Call Read before accessing data.
while (reader.Read())
{
Console.WriteLine(String.Format("{0}, {1}",
reader[0], reader[1]));
}

// Call Close when done reading.
reader.Close();
}

Con la using non e' necessario la close della connessione perche' e' implicita (e neppure del datareader in realta')

Ma se proprio vuoi strafare impari ad usare LINQ to SQL e la parte funzionale del C# e, a patto per ora di usare un Database SqlServer, ti togli tanti problemi.

[RaouL_BennetH]

Grazie :)

Per il momento devo utilizzare ancora il .net 2.0 e come database non ho molta scelta fra:

mysql e postgresql

Ancora una piccola domanda:

Trattandosi di applicazioni client io generalmente mi creo delle classi apposite per tutte le operazioni da fare sul database e dal classico 'bottone' istanzio solo la classe e chiamo il metodo che mi serve. E' una buona pratica oppure c'è qualcosa che si può migliorare?

cioè, per esempio, per fare una qualsiasi operazione di insert, delete o update io faccio:



public int DbAction(string commandString)
{
try
{
DbClass db = new DbClass();
db.OpenConnection();
db.commandString = commandString;
SqlCommand cmd = new SqlCommand(db.commandString, db.ActiveConnection);
int i = cmd.ExecuteNonQuery();
//blablacode
return i;
}
catch(SqlException ex)
{
//blablacode
return 0;
}
}

//poi, da qualsiasi form chiamo il metodo passando i vari sqlparameter
//senza dover ripetere ogni volta la stessa sequenza di comandi



Grazie mille :)

RaouL.

[RaouL_BennetH]

Uhm.. c'è qualcosa che non mi torna:


using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using Npgsql;
using System.Text;


namespace TestPSql
{
class DbConnection
{
private string connectionString = ConfigurationManager.ConnectionStrings["TestPsql.Properties.Settings.dbConnection"].ConnectionString;

public void PrimoTest(string commandString)
{
try
{
using (NpgsqlConnection cn = new NpgsqlConnection(connectionString))
{
cn.Open();
NpgsqlCommand cmd = new NpgsqlCommand(commandString, cn);
cmd.ExecuteNonQuery();
}
}
catch (NpgsqlException ex)
{
System.Windows.Forms.MessageBox.Show(ex.Code);
}
}

}
}

//dal form

private void Form1_Load(object sender, EventArgs e)
{
DbConnection db = new DbConnection();
db.PrimoTest("SELECT * FROM test");
}



Succede questo:

dopo aver ottenuto i miei risultati, se vedo le connessioni attive sulla macchina dove gira postgresql, mi trovo sempre la connessione del client aperta. L'unico momento in cui si chiude la connessione è quando chiudo l'applicazione.

Idee ?

[gugoXX]

Uhm.. c'è qualcosa che non mi torna:

Succede questo:

dopo aver ottenuto i miei risultati, se vedo le connessioni attive sulla macchina dove gira postgresql, mi trovo sempre la connessione del client aperta. L'unico momento in cui si chiude la connessione è quando chiudo l'applicazione.

Idee ?

E' corretto (meglio, e' plausibile).
Se si dovesse veramente aprire e chiudere una connessione ogni volta che si esegue un comando, l'overhead del protocollo di negoziazione supererebbe il tempo necessario per eseguire un comando, con la conseguenza che di fronte a comandi corti e banali l'applicazione si siederebbe.
Non sarebbe neppure corretto aprire una connessione e lasciarla aperta per sempre, altrimenti un eventuale crash la lascerebbe aperta.
Quindi e' stato deciso di demandare la gestione delle connessioni al .NET framework.
Tu dal punto di vista utente pensi di aprire e chiudire le connessioni, ma il pool delle connessioni e' in realta' gestito dal framework, e la cui apertura ma soprattutto le chiusure vengono gestite automaticamente.
In pratica fai le cose come si deve e non preoccuparti di cosa succede sotto la coperta.

[RaouL_BennetH]

E' corretto (meglio, e' plausibile).
Se si dovesse veramente aprire e chiudere una connessione ogni volta che si esegue un comando, l'overhead del protocollo di negoziazione supererebbe il tempo necessario per eseguire un comando, con la conseguenza che di fronte a comandi corti e banali l'applicazione si siederebbe.
Non sarebbe neppure corretto aprire una connessione e lasciarla aperta per sempre, altrimenti un eventuale crash la lascerebbe aperta.
Quindi e' stato deciso di demandare la gestione delle connessioni al .NET framework.
Tu dal punto di vista utente pensi di aprire e chiudire le connessioni, ma il pool delle connessioni e' in realta' gestito dal framework, e la cui apertura ma soprattutto le chiusure vengono gestite automaticamente.
In pratica fai le cose come si deve e non preoccuparti di cosa succede sotto la coperta.


Ah ecco!

In effetti avrei potuto intuirlo anche da solo dato che avevo provato ad aprire la connessione, chiuderla ed eseguire una select dopo aver chiuso la connessione.. giustamente l'eccezione sollevata mi diceva che non potevano essere eseguiti comandi con la connessione chiusa.

Allora però mi resta il dubbio sulle affermazioni di alcuni programmatori che ritengono di essere loro a gestire le connessioni in maniera autonoma.

Grazie davvero. :)

RaouL.