private void AttachDb(string filepath, bool detachMoveReattach)
{
    try
    {
        string missingFiles = string.Empty;

        foreach (string database in DB_NAMES)
            foreach (string extension in EXTENSIONS)
            {
                string path = Path.Combine(filepath, database + extension);
                if (!File.Exists(path))
                {
                    if (missingFiles != string.Empty)
                        missingFiles += Environment.NewLine;

                    missingFiles += database + extension;
                }
            }

        if (missingFiles != string.Empty)
            throw new Exception("The following database files are missing:" + Environment.NewLine + missingFiles);

        using (SqlConnection sqlConnection = new SqlConnection(GetConnectionString(MASTER_DB_NAME)))
        {
            sqlConnection.Open();

            foreach (string database in DB_NAMES)
            {
                string mdfFilepath = Path.Combine(filepath, database + EXT_DATA);
                string ldfFilepath = Path.Combine(filepath, database + EXT_LOG);

                SqlCommand attachCmd = new SqlCommand(SQL_ATTACH, sqlConnection);
                attachCmd.Parameters.Add(new SqlParameter("@Database", database));
                attachCmd.Parameters.Add(new SqlParameter("@MdfFilepath", mdfFilepath));
                attachCmd.Parameters.Add(new SqlParameter("@LdfFilepath", ldfFilepath));

                attachCmd.ExecuteNonQuery();
            }

            // Gets rid of error
            SqlConnection.ClearAllPools();
        }

        string successMessage = string.Empty;
        if (detachMoveReattach)
            successMessage = "Detach, move, and reattach successful.";
        else
            successMessage = "Attach successful.";

        MessageBox.Show(successMessage, "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

        btnAttachDb.Enabled = false;

        btnDetachDb.Enabled = true;
        btnDetachMove.Enabled = true;
        btnDetachMoveReattach.Enabled = true;
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error attaching databases." + Environment.NewLine + ex.Message);
    }
}

private List<string> DetachDb(bool startOfChain)
{
    try
    {
        List<string> filepaths = GetDbPaths();

        using (SqlConnection sqlConnection = new SqlConnection(GetConnectionString(MASTER_DB_NAME)))
        {
            sqlConnection.Open();

            foreach (string database in DB_NAMES)
            {
                SqlCommand singleUserCmd = new SqlCommand(string.Format(SQL_SINGLE_USER, database), sqlConnection);

                singleUserCmd.ExecuteNonQuery();

                SqlCommand detachCmd = new SqlCommand(SQL_DETACH, sqlConnection);
                detachCmd.Parameters.Add(new SqlParameter("@Database", database));

                detachCmd.ExecuteNonQuery();
            }
        }

        string locationString = string.Empty;
        if (filepaths.Count == 1)
            locationString = "Folder containing database files:" + Environment.NewLine + filepaths[0];
        else
        {
            locationString = "Locations of database files:";

            foreach (string filepath in filepaths)
                locationString += Environment.NewLine + filepath;
        }

        if (!startOfChain)
            MessageBox.Show("Detach successful. " + locationString, "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

        btnAttachDb.Enabled = true;

        btnDetachDb.Enabled = false;
        btnDetachMove.Enabled = false;
        btnDetachMoveReattach.Enabled = false;

        return filepaths;
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error detaching databases." + Environment.NewLine + ex.Message);
    }

    return null;
}

private bool MoveDb(List<string> srcFilepaths, string destFilepath, bool detachAndMove, bool detachMoveReattach)
{
    try
    {
        if (srcFilepaths.Count == 1)
        {
            string justPath = srcFilepaths[0];

            srcFilepaths = new List<string>();

            foreach (string database in DB_NAMES)
                foreach (string extension in EXTENSIONS)
                    srcFilepaths.Add(Path.Combine(justPath, database + extension));
        }

        foreach (string filepath in srcFilepaths)
        {
            string destFilename = Path.Combine(destFilepath, Path.GetFileName(filepath));
            File.Move(filepath, destFilename);
        }

        if (!detachMoveReattach)
        {
            string successMessage = string.Empty;
            if (detachAndMove)
                successMessage = "Detach and move successful.";
            else
                successMessage = "Move successful.";

            MessageBox.Show(successMessage, "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }

        return true;
    }
    catch (Exception ex)
    {
        MessageBox.Show("Error copying databases." + Environment.NewLine + ex.Message);
    }

    return false;
}

        private const string CONNECTION_STRING = "Data Source=.\\SQLEXPRESS;Initial Catalog={0};Trusted_Connection=Yes;";

        private const string MASTER_DB_NAME = "master";
        private const string ****_DB_NAME = "****Data";
        private const string ***_DB_NAME = "***Data";
        private readonly string[] DB_NAMES = new string[] { ****_DB_NAME, ***_DB_NAME };

        private const string EXT_DATA = ".mdf";
        private const string EXT_LOG = "_log.ldf";
        private readonly string[] EXTENSIONS = new string[] { EXT_DATA, EXT_LOG };

        private const string SQL_DB_EXISTS = "SELECT * FROM sys.databases WHERE name = @Database";
        private const string SQL_SINGLE_USER = "ALTER DATABASE {0} SET SINGLE_USER WITH ROLLBACK IMMEDIATE";
        private const string SQL_DETACH = "EXEC sp_detach_db @Database";
        private const string SQL_ATTACH = "EXEC sp_attach_db @Database, @MdfFilepath, @LdfFilepath";

        private string GetConnectionString(string dbName)
        {
            return string.Format(CONNECTION_STRING, dbName);
        }

        private List<string> GetDbPaths()
        {
            List<string> filepaths = new List<string>();

            foreach (string database in DB_NAMES)
                using (SqlConnection sqlConnection = new SqlConnection(GetConnectionString(database)))
                {
                    sqlConnection.Open();

                    SqlCommand getPathCmd = new SqlCommand("select physical_name from sys.database_files", sqlConnection);
                    using (SqlDataReader dataReader = getPathCmd.ExecuteReader())
                        while (dataReader.Read())
                            filepaths.Add(dataReader["physical_name"] as string);
                }

            List<string> filesToFind = new List<string>();
            foreach (string database in DB_NAMES)
                foreach (string extension in EXTENSIONS)
                    filesToFind.Add((database + extension).ToLower());

            List<string> justPaths = new List<string>();
            foreach (string filepath in filepaths)
                if (filesToFind.Contains(Path.GetFileName(filepath).ToLower()))
                    justPaths.Add(Path.GetDirectoryName(filepath));

            List<string> singlePath = justPaths.Distinct().ToList();

            switch (singlePath.Count)
            {
                default:
                case 0:
                    return null;
                case 1:
                    return singlePath;
                case 4:
                    return filepaths;
            }
        }