public class DatabaseMigration
{
        /// <summary>
        /// Initializes a new instance of the DatabaseMigration class specifying a factory function for the database connection.
        /// </summary>
        /// <param name="connectionFactory">The connection factory is a function that returns a constructed object 
        /// of interface IDbConnection. It ensures, that the connection is used only by the migrator
        /// and no other function, because the connection returned by the connectionFactory is
        /// used and disposed after the migration process. The connection isn't reusable.</param>
        public DatabaseMigrationMinimal(Func<IDbConnection> connectionFactory)
        {
            this.ConnectionFactory = connectionFactory;
            if (this.ConnectionFactory == null){
                throw new ArgumentNullException("No connection factory provided");
            }
        }

        #region Properties
        
        /// <summary>
        /// Gets or privetly sets the ConnectionFactory creating the IDbConnection instance.
        /// </summary>
        protected Func<IDbConnection> ConnectionFactory
        {
            get;
            private set;
        }

        /// <summary>
        /// Holds the Connection created by the Connection factory.
        /// </summary>
        protected IDbConnection Connection
        {
            get;
            private set;
        }

        /// <summary>
        /// Gets or sets the folder containing migration scripts.
        /// Default: SqlForward.DatabaseScripts from AppConfig AppSettings.
        /// </summary>
        public string DatabaseScripts
        {
            get;
            set;
        } = ConfigurationManager.AppSettings["SqlForward.DatabaseScripts"];

        /// <summary>
        /// Gets or sets the initialization script file name (is assumed to be in the DatabaseScripts folder).
        /// Default: SqlForward.Initialization from AppConfig AppSettings.
        /// </summary>
        public string InitializationScript
        {
            get;
            set;
        } = ConfigurationManager.AppSettings["SqlForward.Initialization"];
}

protected virtual void ExecuteScriptInTransaction(string script)
{
    using (IDbTransaction transaction = this.Connection.BeginTransaction())
    {
        string migrationName = Path.GetFileNameWithoutExtension(script);
        Stopwatch watch = new Stopwatch();
        try
        {
            watch.Start();
            string scriptCommand = File.ReadAllText(script);
            IDbCommand initializationCommand = this.Connection.CreateCommand();
            initializationCommand.CommandText = scriptCommand;
            initializationCommand.Transaction = transaction;
            initializationCommand.ExecuteNonQuery();
            transaction.Commit();

        }
        catch (Exception ex)
        {
            // More sophisticated error tracking here :)
            Trace.WriteLine($"Error on migration {migrationName} (time: {watch.Elapsed}) {ex}"); 
            transaction.Rollback();
            throw; 
        }
    }
}

private void InitializeScriptLogTable()
{
    string scriptLogCreation = Path.Combine(this.DatabaseScripts, InitializationScript);
    ExecuteScriptInTransaction(scriptLogCreation);
}

private List<string> GetExecutedScripts()
{
    IDbCommand executedScriptsCommand = this.Connection.CreateCommand();
    executedScriptsCommand.CommandText = @"SELECT [ScriptName],[ScriptDate] FROM ScriptLog";

    List<string> executedScriptNames = new List<string>();
    IDataReader reader = executedScriptsCommand.ExecuteReader();
    while (reader.Read())
    {
        executedScriptNames.Add(reader.GetString(0));
    }
    reader.Close();
    return executedScriptNames;
}

private List<string> GetScriptsToExecute()
{
    var files = new List<string>(Directory.GetFiles(this.DatabaseScripts, "*.sql"));
    files.Sort();
    return files;
}

private void RecordMigrationExecuted(string fileName)
{
    IDbCommand insertScriptLog = this.Connection.CreateCommand();
    insertScriptLog.CommandText = "INSERT INTO ScriptLog(ScriptName, ScriptDate) VALUES(@name, GETDATE());";
    AddParameterToCommand(insertScriptLog, DbType.String, "name", fileName);
    insertScriptLog.ExecuteNonQuery();
}

//helper method:
private IDataParameter AddParameterToCommand(IDbCommand command, DbType type, string name, object value)
{
    IDataParameter parameter = command.CreateParameter();
    parameter.ParameterName = name;
    parameter.DbType = type;
    parameter.Value = value;
    command.Parameters.Add(parameter);
    return parameter;
}

// Main Entry point to start executing pending migrations.
public void Synchronize()
{
    using (this.Connection = this.ConnectionFactory())
    {
        if (this.Connection.State == ConnectionState.Closed)
        {
            this.Connection.Open();
        }

        InitializeScriptLogTable();

        IterateMigrations(GetExecutedScripts(), GetScriptsToExecute());
    }
}

private void IterateMigrations(List<string> executedScriptNames, List<string> files)
{
    foreach (var file in files)
    {
        string fileName = Path.GetFileName(file);
        if (!executedScriptNames.Contains(fileName))
        {
            ExecuteScriptInTransaction(file);
            RecordMigrationExecuted(fileName);
        }
    }
}