È questo il modo giusto per smaltire SQLConnection

Question

Mi chiedevo se la mia implementazione di seguito è il modo più efficiente per smaltire SQLconnection in questo caso.

Conosco normalmente se sto utilizzando SqlConnection direttamente Posso semplicemente racchiudere la connessione all'interno di un blocco utilizzando per eliminarlo automaticamente, ma in questo caso volevo mantenere la connessione aperta e disponibile per Tutti i metodi in SQLRespository classe.

public class SqlRepository : IRepository 
{ 
    private readonly string connectionString; 
    private SqlConnection connection; 

    public SqlRepository(string connectionString) 
    { 
     this.connectionString = connectionString; 
     connection = new SqlConnection(connectionString); 
     connection.Open(); 
    } 

    public void Method_A() 
    { 
     // uses the SqlConnection to fetch data 
    }  

    public void Method_B() 
    { 
     // uses the SqlConnection to fetch data 
    }  

    public void Dispose() 
    {    
     connection.Dispose(); 
    } 
} 

Usage:

using (IRepository repository = new SqlRepository(connectionString)) 
{ 
    var item = repository.items;  
} 

Aggiornamento IRepository fa implementare IDisposable

Answer 1

Non mantenere la connessione aperta per le chiamate. Stai sconfiggendo il pool di connessioni.

Se si sta lavorando con una connessione in pool (come sqlserver), verrà raccolta e riutilizzata. Basta aprire e chiudere all'interno del metodo a & b.

Si potrebbe obiettare che se il chiamante fa quello che hai fatto usando con una chiamata di metodo va bene. Ma se si utilizza {} con sqlconnection all'interno di ciascun metodo worker (1) il codice sarà più semplice e (2) si è certi che il pool non verrà sconfitto (ovvero gli elementi di tenuta fuori dal pool quando altre richieste potrebbero usarlo) .

EDIT:

Aggiunta pseudo sulla base dei commenti.

Il motivo è problematico perché un chiamante può fare.

//pseudo code 
using (SqlRepository r) 
{ 
    r.MethodA(); 

    // other code here that takes some time. your holding a connection 
    // out of the pool and being selfish. other threads could have 
    // used your connection before you get a chance to use it again. 

    r.MethodB(); 
} // freed for others here. 

Questo ucciderà la scalabilità del server - fidati. Ho visto sistemi molto grandi soffocati da questo - di solito perché si stanno estendendo transazioni lato AT.

Un modello migliore:

class Repository 
{ 
    void MethodA() 
    { 
     using (Sqlconnection) 
     { 
      // db call 
     } 
    } 

    void MethodB() 
    { 
     using (Sqlconnection) 
     { 
      // you can even have multiple calls here (roundtrips) 
      // and start transactions. although that can be problematic 
      // for other reasons. 
     } 
    } 

Ora, la piscina è più efficace. Mi rendo conto che la domanda era sul modello monouso - e sì, puoi farlo. Ma ...

Non permetterei che la connessione si estenda per tutta la durata del repository.

Answer 2

Se si vuole fare in quel modo, assicurarsi di implementare IDisposable (Non posso dirvi se si nota questo sulla tua interfaccia IRepository o meno) e farò qualcosa del tipo:

 

     private bool disposed = false; 

     protected virtual void Dispose(bool disposing) 
     { 
      if (!this.disposed) 
      { 
       if (disposing) 
       { 
        _context.Dispose(); 
       } 
      } 
      this.disposed = true; 
     } 

     public void Dispose() 
     { 
      Dispose(true); 
      GC.SuppressFinalize(this); 
     } 

Ovviamente il _context qui è il tuo SqlConnection.

tuttavia - sei sicuro di volere una connessione per repository? Che dire delle operazioni che coprono più di un repository?

Answer 3

Assumendo IRepository eredita dal IDisposable, l'implementazione va bene a patto di non stanno mantenendo un'istanza della classe SqlRepository aperto più a lungo di quello necessario per eseguire una sequenza di 'logica' di query sul database.Il fatto che questa sequenza possa comprendere diverse chiamate di metodo non è un problema.

Non sono d'accordo con la risposta di @ bryanmac:

non mantengono la chiamate spanning aprire la connessione. Stai sconfiggendo il pool di connessioni.

fornito la sequenza di chiamate di metodo appartengono insieme e non mantenere la connessione aperta più a lungo di quanto serve per completare la sequenza logica, non vedo come questo in alcun modo sconfigge il pool di connessioni.

Un commento però. Si dovrebbe:

• O attuare la IDisposable modello standard (con un metodo protected void Dispose(bool disposing) che può essere ignorato nelle classi derivate

• o fare la classe sigillata, nel qual caso il vostro IDisposable implementazione esistente va bene

  .