Comment puis-je rendre ma méthode de base de données plus à l'épreuve du futur?

Question

Je travaille actuellement sur une nouvelle application avec un transfert de données de base de données entre deux bases de données. J'ai actuellement une méthode écrite, mais il semble que je puisse rendre ce code beaucoup plus compact. J'ai lu un article qui utilisait l'instruction Using, mais je ne suis pas sûr comment je peux l'implémenter dans mon code. En outre, je tiens à préciser que j'ai les déclarations publiques suivantes :

private IDbConnection ExportConnection = new OleDbConnection(Helper.CnnVal("ExportDatabase"));
    private IDbConnection SchoolConnection;
    private DataTable exportDb = new DataTable();
    private DataTable schoolDb = new DataTable();
    private OleDbCommandBuilder cb;
    private OleDbDataAdapter dataAdapterSchool;
    private OleDbDataAdapter dataAdapterExport;
    private OleDbCommand dbCommand;
    private string ZoekQuery { get; set; }
    private DataAccess db = new DataAccess();
    private string SchoolConnectionString;
    private string selectSchoolQuery;

Voici la méthode :

public void InlezenClientGegevens()
{
    if ((bool)Checbox.IsChecked)
    {
        SchoolConnectionString = $@"I removed the string for privacy reasons";
        try
        {
            ExportConnection.Open();
            ZoekQuery = $"SELECT * FROM Client WHERE Cliëntnummer BETWEEN '{TxtVan.Text}' AND '{TxtTm.Text}'";
            dbCommand = new OleDbCommand(ZoekQuery, (OleDbConnection)ExportConnection);
            dataAdapterExport = new OleDbDataAdapter(ZoekQuery, (OleDbConnection)ExportConnection);
            dbCommand.ExecuteNonQuery();
            dataAdapterExport.AcceptChangesDuringFill = false;
            dataAdapterExport.Fill(exportDb);
            ExportConnection.Close();
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
        SchoolConnection = new OleDbConnection(SchoolConnectionString);
        try
        {
            SchoolConnection.Open();
            selectSchoolQuery = "SELECT * FROM Info";
            dbCommand = new OleDbCommand(selectSchoolQuery, (OleDbConnection)SchoolConnection);
            dataAdapterSchool = new OleDbDataAdapter(selectSchoolQuery, (OleDbConnection)SchoolConnection);
            dbCommand.ExecuteNonQuery();
            dataAdapterSchool.FillSchema(schoolDb, SchemaType.Source);
            dataAdapterSchool.Fill(schoolDb);
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
        try
        {
            cb = new OleDbCommandBuilder(dataAdapterSchool);
            cb.GetUpdateCommand();
            schoolDb.Merge(exportDb, false, MissingSchemaAction.Add);
            dataAdapterSchool.Update(schoolDb);
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }

    }
}

ÉDIT :

public void InlezenClientGegevens()
{
    if ((bool)Checkbox.IsChecked)
    {
        try
        {
            using (var connection = new OleDbConnection(Helper.CnnVal("ExportDatabase")))
            {
                var ZoekQuery = $"SELECT * FROM client WHERE Cliëntnummer BETWEEN '{TxtVan.Text}' AND '{TxtTm.Text}'";
                using (var dbcommand = new OleDbCommand(ZoekQuery, connection))
                {
                    using (var exportAdapter = new OleDbDataAdapter(ZoekQuery, connection))
                    {
                        exportAdapter.AcceptChangesDuringFill = false;
                        exportAdapter.Fill(exportDb);
                    }
                }
            }
            using (var connection = new OleDbConnection($"))
            {
                var ZoekQuery = "SELECT * FROM info";
                using (var dbcommand = new OleDbCommand(ZoekQuery, connection))
                {

                    using (var SchoolAdapter = new OleDbDataAdapter(ZoekQuery, connection))
                    {
                        SchoolAdapter.FillSchema(schoolDb, SchemaType.Source);
                        SchoolAdapter.Fill(schoolDb);
                        using (var cb = new OleDbCommandBuilder(SchoolAdapter))
                        {
                            cb.GetUpdateCommand();
                            schoolDb.Merge(exportDb, false, MissingSchemaAction.Add);
                            SchoolAdapter.Update(schoolDb);
                        }
                    }
                }
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }          
    }
}

Answer 1

Vous n'avez pas besoin d'ouvrir ou de fermer la connexion si vous utilisez DataAdappter.Fill. Je recommanderais également d'utiliser l'instruction using pour tout ce qui implémente IDisposable (comme pour OleDbConnection et OleDbCommand, ce n'est pas nécessaire pour DataTable). Vous devriez donc créer la connexion dans la méthode.

Vous devriez également utiliser des paramètres pour vos requêtes au lieu de la concaténation de chaînes pour éviter les injections SQL. Vous devriez également essayer de convertir d'abord l'entrée, pour voir si c'est vraiment un int:

public void InlezenClientGegevens()
{
    bool validVan = int.TryParse(TxtVan.Text, out int van);
    bool validTm = int.TryParse(TxtTm.Text, out int tm);
    if (!validVan || !validTm)
    {
        // inform user
        return;
    }

    if (Checkbox.IsChecked)
    {
        try
        {
            using (OleDbConnection connection = new OleDbConnection(Helper.CnnVal("ExportDatabase")))
            {
                string zoekQuery = $"SELECT * FROM client WHERE Cliëntnummer BETWEEN ? AND ?";
                using (OleDbCommand dbCommand = new OleDbCommand(zoekQuery, connection))
                {
                    dbCommand.Parameters.Add(new OleDbParameter("Van", OleDbType.Integer).Value = van);
                    dbCommand.Parameters.Add(new OleDbParameter("Tm", OleDbType.Integer).Value = tm);
                    using (OleDbDataAdapter exportAdapter = new OleDbDataAdapter(dbCommand))
                    {
                        exportAdapter.Fill(exportDb);
                    }
                }
            }
            // ...
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message);
        }
    }
}