Single responsibility principle: method DoDatabaseBackup is doing a lot of things - software-design

Question

I'm developing a C# library with .NET Framework 4.7 and Visual Studio 2017 Community.
I'm trying to understand and use single responsibility principle correctly.
I have this class to do a backup in a SQL Server 2012 Database:
public static class DbManagement
{
private static string sqlBackupStatement =
"BACKUP DATABASE [{0}] TO DISK = N'{1}' WITH COMPRESSION, COPY_ONLY, NAME=N'{2}'";
/// <summary>
/// Do backup for a database.
/// </summary>
/// <param name="connectionString">Connection's string to database</param>
/// <param name="path">Path to safe the database</param>
/// <param name="backupFileName">Backup's file name</param>
/// <param name="backupName">This name will be used to identify this backup.</param>
/// <returns>Database's execution result</returns>
public static int DoDatabaseBackup(
string connectionString,
string path,
string backupFileName,
string backupName)
{
if (string.IsNullOrWhiteSpace(connectionString))
throw new ArgumentNullException(nameof(connectionString));
if (string.IsNullOrWhiteSpace(path))
throw new ArgumentNullException(nameof(path));
if (string.IsNullOrWhiteSpace(backupFileName))
throw new ArgumentNullException(nameof(backupFileName));
if (string.IsNullOrWhiteSpace(backupName))
throw new ArgumentNullException(nameof(backupName));
string databaseName = GetDatabaseName(connectionString);
string fullPath = GetFullPath(path);
string pathWithFile = fullPath + backupFileName + "_" + DateTime.Now.ToString("yyyyMMddHHmm") + ".bak";
string description = string.Format("{0} - Full database Backup", backupName);
if (!Directory.Exists(fullPath))
Directory.CreateDirectory(fullPath);
string sqlStatement = string.Format(sqlBackupStatement, databaseName, pathWithFile, description);
TRZLDbContext context = new TRZLDbContext(connectionString);
return
context.Database.ExecuteSqlCommand(TransactionalBehavior.DoNotEnsureTransaction, sqlStatement);
}
private static string GetDatabaseName(string connectionString)
{
SqlConnectionStringBuilder sqlConnBuilder =
new SqlConnectionStringBuilder(connectionString);
return sqlConnBuilder.InitialCatalog;
}
private static string GetFullPath(string path)
{
StringBuilder builder = new StringBuilder(path);
if (!path.EndsWith("\\"))
builder.Append("\\");
DateTime today = DateTime.Now;
builder.Append(today.Year.ToString());
builder.Append("\\");
builder.Append(today.Month.ToString());
builder.Append("\\");
return builder.ToString();
}
}
I think a do a lot of things in method DoDatabaseBackup:
Get database name.
Get full path to store backup file.
Get full path with backup's file name.
Create backup's description.
Create directory where I will store the backup if it doesn't exist.
Create the SQL statement to do the backup.
And finally... do the backup.
Am I using Single Responsibility Principle correctly here? It it is not, do I have to move points 1 to 6 to 6 methods?

Answer 1

You could refactor this into a number of separate classes with distinct responsibilities. If you think of the types of objects that could be represented here you would have something like:
A connection string
A database backup
A backup statement
A backup file name
With SRP it's important to think about how objects may change. For example, the algorithm for changing the backup file name may change, so that may want to be represented in a separate class so that it can be swapped out for a new algorithm if necessary. You may need to change the SQL statement if you start using a different type of database. The connection string also has a dependency on SQL which may change in future.
I had a go at refactoring your above method and came up with the following:
public class ConnectionString
{
private readonly string connectionString;
public ConnectionString(string connectionString)
{
this.connectionString = connectionString;
}
public string DatabaseName()
{
SqlConnectionStringBuilder sqlConnBuilder =
new SqlConnectionStringBuilder(this.connectionString);
return sqlConnBuilder.InitialCatalog;
}
}
public class BackupFileName
{
private readonly string backupFilePath;
private readonly string backupFileName;
public BackupFileName(string backupFilePath, string backupFileName)
{
this.backupFilePath = backupFilePath;
this.backupFileName = backupFileName;
}
public string FullPath => this.backupFilePath;
public override string ToString()
{
return this.GetFullPath(this.backupFilePath) + this.backupFileName + "_" +
DateTime.Now.ToString("yyyyMMddHHmm") + ".bak";
}
private string GetFullPath(string path)
{
StringBuilder builder = new StringBuilder(path);
if (!path.EndsWith("\\"))
builder.Append("\\");
DateTime today = DateTime.Now;
builder.Append(today.Year.ToString());
builder.Append("\\");
builder.Append(today.Month.ToString());
builder.Append("\\");
return builder.ToString();
}
}
public class BackupStatement
{
private string sqlBackupStatement =
"BACKUP DATABASE [{0}] TO DISK = N'{1}' WITH COMPRESSION, COPY_ONLY, NAME=N'{2}'";
private readonly string databaseName;
private readonly string filePath;
private readonly string description;
public BackupStatement(string databaseName, string filePath, string description)
{
this.databaseName = databaseName;
this.filePath = filePath;
this.description = description;
}
public override string ToString()
{
return string.Format(sqlBackupStatement, databaseName, filePath, description);
}
}
public class DatabaseBackup
{
private readonly ConnectionString connectionString;
private readonly string backupName;
private readonly BackupFileName backupFileName;
public DatabaseBackup(
string connectionString,
string path,
string backupFileName,
string backupName)
{
if (string.IsNullOrWhiteSpace(connectionString))
throw new ArgumentNullException(nameof(connectionString));
if (string.IsNullOrWhiteSpace(path))
throw new ArgumentNullException(nameof(path));
if (string.IsNullOrWhiteSpace(backupFileName))
throw new ArgumentNullException(nameof(backupFileName));
if (string.IsNullOrWhiteSpace(backupName))
throw new ArgumentNullException(nameof(backupName));
this.connectionString = new ConnectionString(connectionString);
this.backupFileName = new BackupFileName(path, backupFileName);
this.backupName = backupName;
}
/// <summary>
/// Creates a backup for a database.
/// </summary>
/// <returns>Database's execution result</returns>
public int Create()
{
string description = string.Format("{0} - Full database Backup", this.backupName);
if (!Directory.Exists(this.backupFileName.FullPath))
Directory.CreateDirectory(this.backupFileName.FullPath);
TRZLDbContext context = new TRZLDbContext(this.connectionString.ToString());
return
context.Database.ExecuteSqlCommand(
TransactionalBehavior.DoNotEnsureTransaction,
new BackupStatement(
this.connectionString.DatabaseName(),
this.backupFileName.ToString(),
description).ToString());
}
}
It's not perfect, and each of the above classes should really be using interfaces (as per Dependency Inversion) but I hope it illustrates a point.

Answer 2

Both.
Don't recreate things like the backup name on the fly. Have a method/function/whatever that gives that to you.
Otherwise, it is fine for a function to do more than one thing to accomplish a goal which subsumes those things. That said, don't duplicate actions found elsewhere (like building a backup path).
The single responsibility principle exists to modularize unique objects to single places -- it is a generalization of the One Definition Rule. (Yeah, I know you're using Java. Sorry...LOL)