¿Cómo comparto los recursos IDisponibles dentro de una clase?

Question

Estoy escribiendo algunas aplicaciones de consola para mover algunos datos entre bases de datos SQLite. Las clases para la conexión y varias declaraciones preparadas no son identificables, por lo que estoy creando una instancia de estos objetos usando utilizando bloques, como este:

using (SQLiteConnection sqlite_conn = new SQLiteConnection(connectionString))
{
    sqlite_conn.Open();
    using (SQLiteCommand sqlite_cmd = new SQLiteCommand())
    {
        sqlite_cmd.Connection = sqlite_conn;
        sqlite_cmd.CommandText = "INSERT INTO SOMETHING SOMETHING;";
        sqlite_cmd.ExecuteNonQuery();
    }
    sqlite_conn.Close();
}     

Pero, necesito poder crear estas conexiones en un método, y luego llamarlas en otros métodos. ¿Cuál es la forma más limpia y menos confusa de almacenar estas conexiones como variables de instancia? Quiero asegurarme de que sus métodos de .Dispose () sean llamados de manera inteligente, pero no puedo ver una buena manera de asegurar que toda la acción ocurra dentro del contexto de un solo utilizando el bloque .

Me doy cuenta de que esta es una pregunta de C # newb, así que por favor adapte sus respuestas como tal. Si tiene una solución sugerida, me encantaría que incluyera una muestra de código para ilustrar.

EDITAR: Mi caso de uso es una aplicación de consola. Alguien pasa las cadenas de conexión de origen y destino, y la aplicación de consola realiza una operación. ¿Realmente haría que mi propio programa de clase de consola implemente IDisposable como este?:

class Program : IDisposable
{
    private SQLiteConnection sourceConnection;
    private SQLiteConnection destinationConnection;

    public void Dispose()
    {
        sourceConnection.Dispose();
        destinationConnection.Dispose();
    }  
}

Answer 1

  

Necesito poder crear estas conexiones en un método y luego llamarlas en otros métodos. ¿Cuál es la forma más limpia y menos confusa para que yo almacene estas conexiones como variables de instancia?

En este caso, la clase donde se guardan estas variables de instancia debería implementarse como IDisposable, y al momento de la eliminación debe asegurarse de que las conexiones también estén eliminadas.

Además, cuando tiene varios IDisposables a la vez, puede reescribirlo de esta manera, agruparlos y reducir el anidamiento en el código:

using (SQLiteConnection sqlite_conn = new SQLiteConnection(connectionString))
using (SQLiteCommand sqlite_cmd = new SQLiteCommand())
{
    sqlite_conn.Open();

    sqlite_cmd.Connection = sqlite_conn;
    sqlite_cmd.CommandText = "INSERT INTO SOMETHING SOMETHING;";
    sqlite_cmd.ExecuteNonQuery();
} // no need to call .Close(): IDisposable normally handles it for you

Answer 2

Puede hacer que su implemento de clase sea IDisponible y asegurarse de que limpia la conexión, etc., dentro de su método de Disposición. Luego, el método que llama a su clase puede hacerlo usando (MyClass c ...).

Answer 3

Una forma es que su clase implemente IDisposable. En el método Dispose de su clase, llame a los métodos Dispose de la conexión y el comando, etc. Luego, puede usar una instancia de su clase en un bloque de uso.