Connessioni dati C# La migliore pratica?

Question

Ok, quindi questo è uno di quei tipi di argomenti supponenti, ma sulla base delle tue conoscenze, opinioni e pratica corrente, qual è il modo migliore per impostare il seguente scenario?

Sto costruendo una vasta applicazione per l'inserimento dei dati, e per esteso intendo che ho solo l'impostazione di base che comprende circa il 15-25% del programma complessivo e ho circa 15 moduli che sono parzialmente configurati. (Hanno ancora bisogno di lavoro) Sto usando SQL Compact 4.0 come database di back-end, non ho davvero bisogno di un database più espansivo dato che non sto memorizzando i dati di un MMO, e per il momento questa è solo un'applicazione locale .

Mi piacerebbe essere in grado di configurarlo per essere visualizzato come una singola finestra che cambia solo in varie pagine basate su un sistema di menu, ma non riesco a trovare un buon tutorial su come sarebbe compiuto, quindi se qualcuno ne conosce qualcuno, per favore illuminami.

Lo scenario in questione, tuttavia, è come connettersi ai database. Sto usando 2 database SQLCE, uno che memorizza dati costanti che si basano su servizi e personale, e un secondo che memorizza i dati in continua evoluzione o nuovi dati inseriti in base al primo database. Ho visto molti metodi diversi su come impostarlo e attualmente sto usando uno in cui ho un BaseForm da cui ereditano tutte le altre forme. All'interno del BaseForm ho metodi e variabili comuni a molte forme, riducendo così al minimo la quantità di codice che si sta ripetendo.

Questo include le stringhe di connessione a entrambi i database e 2 metodi che aprono una connessione a uno di essi. In questo modo:

internal SqlCeConnection dataConn = new SqlCeConnection(@"Data Source = |DataDirectory|\opi_data.sdf"); 
internal SqlCeConnection logConn = new SqlCeConnection(@"Data Source = |DataDirectory|\opi_logs.sdf"); 
internal SqlCeCommand command; 

internal void openDataConnection() // Opens a connection to the data tables 
     { 
      try 
      { 
       if(dataConn.State == ConnectionState.Closed) 
        dataConn.Open(); 
      } 
      catch(SqlCeException ex) 
      { 
       MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); 
      } 
     } 

     internal void openLogConnection() // Opens a connection to the log tables 
     { 
      try 
      { 
       if(logConn.State == ConnectionState.Closed) 
        logConn.Open(); 
      } 
      catch (SqlCeException ex) 
      { 
       MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); 
      } 
     } 

Poi ogni volta che ho bisogno di una connessione aperta ho semplicemente chiamare il metodo di connessione aperta che corrisponde alla base di dati che ho bisogno l'accesso e quindi chiuderlo in una finally. In questo modo una connessione non è mai aperta per molto tempo, solo quando è necessario. Ovviamente questo significa che ci sono molte chiamate ai metodi di connessione aperti. Quindi questo è il modo migliore per implementare questo tipo di scenario, o ci sono modi migliori?

È meglio aprire una connessione non appena viene caricato un modulo e chiuderlo alla chiusura del modulo? Ho dei casi in cui più moduli sono aperti alla volta e ognuno probabilmente avrebbe bisogno di una connessione aperta ai database, quindi se lo si chiude, gli altri sarebbero fregati? O dovrei aprire una connessione ad entrambi i database all'avvio dell'applicazione? Qualsiasi input sarebbe apprezzato. Grazie.

Answer 1

Le connessioni sono raggruppate da .NET, pertanto la loro creazione in genere non è un'operazione costosa. Mantenere le connessioni aperte per lunghi periodi di tempo, tuttavia, può causare problemi.

La maggior parte delle "best practice" ci dice di aprire le connessioni il più tardi possibile (giusto prima di eseguire qualsiasi SQL) e di chiuderle il prima possibile (subito dopo che è stato estratto l'ultimo bit di dati).

Un modo efficace di fare questo automaticamente è con using dichiarazioni:

using (SqlConnection conn = new SqlConnection(...)) 
{ 
    using(SqlCommand cmd = new SqlCommand(..., conn)) 
    { 
     conn.Open(); 
     using(DataReader dr = cmd.ExecuteReader()) // or load a DataTable, ExecuteScalar, etc.  
     { 
      ... 
     { 
    } 
} 

In questo modo, le risorse sono chiusi e smaltiti, anche se viene generata un'eccezione.

In breve, aprire una connessione quando l'app si apre o quando si apre ogni modulo non è probabilmente l'approccio migliore.

Answer 2

Penso che sia meglio semplicemente aprirli all'avvio dell'applicazione, dal momento che hai bisogno di cose dal tuo database, giusto? Non sono un esperto in questo, è solo la mia opinione ... Ho programmato alcune applicazioni simili e ho fatto il connessione all'inizio del modulo principale. L'unico modulo in cui ho creato una connessione separata era il modulo di accesso.