refactor(core): improve code readability and maintainability

This commit refactors several files to enhance code readability, maintainability, and consistency. It includes updates to namespaces, variable naming conventions, and the use of modern C# features.

- Add `System.Diagnostics.CodeAnalysis` namespace to multiple files.
- Rename variables and fields to follow consistent naming conventions.
- Replace `ArgumentNullException` checks with `ArgumentNullException.ThrowIfNull`.
- Use `[GeneratedRegex]` attribute for regex patterns.
- Convert classes to partial and use primary constructors.
- Refactor methods to use expression-bodied members and discard operator (`_ =`).
- Update `Microsoft.Data.SqlClient` package version to `6.0.0`.
- Remove `GlobalSuppressions.cs` file.

These changes improve the overall structure and clarity of the codebase, making it easier to maintain and extend in the future.

Author: JaCraig

src/SQLHelper.DB/ExtensionMethods/DbCommandExtensions.cs

@@ -20,6 +20,7 @@ limitations under the License.
 using System;
 using System.Data;
 using System.Data.Common;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -33,13 +34,13 @@ public static class DbCommandExtensions
         /// <summary>
         /// The bad database types
         /// </summary>
-        private static readonly DbType[] BadDbTypes = {
+        private static readonly DbType[] _BadDbTypes = [
             DbType.Time,
             DbType.SByte,
             DbType.UInt16,
             DbType.UInt32,
             DbType.UInt64
-        };
+        ];
 
         /// <summary>
         /// Adds a parameter to the call (for strings only)
@@ -55,10 +56,8 @@ public static DbCommand AddParameter(
             string value = "",
             ParameterDirection direction = ParameterDirection.Input)
         {
-            if (command is null)
-                throw new ArgumentNullException(nameof(command));
-            if (string.IsNullOrEmpty(id))
-                throw new ArgumentNullException(nameof(id));
+            ArgumentNullException.ThrowIfNull(command, nameof(command));
+            ArgumentNullException.ThrowIfNullOrEmpty(id, nameof(id));
             var Length = string.IsNullOrEmpty(value) ? 1 : value.Length;
             if (direction == ParameterDirection.Output
                 || direction == ParameterDirection.InputOutput
@@ -68,8 +67,8 @@ public static DbCommand AddParameter(
                 Length = -1;
             }
 
-            var Parameter = command.GetOrCreateParameter(id);
-            Parameter.Value = string.IsNullOrEmpty(value) ? DBNull.Value : (object)value;
+            DbParameter Parameter = command.GetOrCreateParameter(id);
+            Parameter.Value = string.IsNullOrEmpty(value) ? DBNull.Value : value;
             Parameter.IsNullable = string.IsNullOrEmpty(value);
             Parameter.DbType = DbType.String;
             Parameter.Direction = direction;
@@ -94,10 +93,8 @@ public static DbCommand AddParameter(
             object? value = null,
             ParameterDirection direction = ParameterDirection.Input)
         {
-            if (command is null)
-                throw new ArgumentNullException(nameof(command));
-            if (string.IsNullOrEmpty(id))
-                throw new ArgumentNullException(nameof(id));
+            ArgumentNullException.ThrowIfNull(command, nameof(command));
+            ArgumentNullException.ThrowIfNullOrEmpty(id, nameof(id));
             return command.AddParameter(id, type.To<DbType>(), value, direction);
         }
 
@@ -114,16 +111,14 @@ public static DbCommand AddParameter(
         public static DbCommand AddParameter<TDataType>(
             this DbCommand command,
             string id,
-            TDataType value = default,
+            TDataType? value = default,
             ParameterDirection direction = ParameterDirection.Input)
         {
-            if (command is null)
-                throw new ArgumentNullException(nameof(command));
-            if (string.IsNullOrEmpty(id))
-                throw new ArgumentNullException(nameof(id));
+            ArgumentNullException.ThrowIfNull(command, nameof(command));
+            ArgumentNullException.ThrowIfNullOrEmpty(id, nameof(id));
             return command.AddParameter(
                 id,
-                GenericEqualityComparer<TDataType>.Comparer.Equals(value, default!) ? typeof(TDataType).To<DbType>() : value?.GetType().To<DbType>() ?? DbType.Int32,
+                GenericEqualityComparer<TDataType>.Comparer.Equals(value!, default!) ? typeof(TDataType).To<DbType>() : value?.GetType().To<DbType>() ?? DbType.Int32,
                 value,
                 direction);
         }
@@ -145,11 +140,9 @@ public static DbCommand AddParameter(
             object? value = null,
             ParameterDirection direction = ParameterDirection.Input)
         {
-            if (command is null)
-                throw new ArgumentNullException(nameof(command));
-            if (string.IsNullOrEmpty(id))
-                throw new ArgumentNullException(nameof(id));
-            var Parameter = command.GetOrCreateParameter(id);
+            ArgumentNullException.ThrowIfNull(command, nameof(command));
+            ArgumentNullException.ThrowIfNullOrEmpty(id, nameof(id));
+            DbParameter Parameter = command.GetOrCreateParameter(id);
             Parameter.IsNullable = value is null || DBNull.Value == value;
             if (Parameter.IsNullable)
             {
@@ -163,7 +156,7 @@ public static DbCommand AddParameter(
             {
                 Parameter.Value = value;
             }
-            if (type != default && !BadDbTypes.Contains(type))
+            if (type != default && !_BadDbTypes.Contains(type))
                 Parameter.DbType = type;
             Parameter.Direction = direction;
             return command;
@@ -179,7 +172,7 @@ public static DbCommand AddParameter(
         {
             if (command?.Connection is null)
                 return null;
-            command.Open(retries);
+            _ = command.Open(retries);
             command.Transaction = command.Connection.BeginTransaction();
             return command.Transaction;
         }
@@ -202,7 +195,7 @@ public static DbCommand AddParameter(
         /// <returns>The DBCommand object</returns>
         public static DbCommand? Close(this DbCommand command)
         {
-            if (!(command?.Connection is null)
+            if (command?.Connection is not null
                 && command.Connection.State != ConnectionState.Closed)
             {
                 command.Connection.Close();
@@ -230,11 +223,12 @@ public static DbCommand AddParameter(
         /// <param name="defaultValue">Default value if there is an issue</param>
         /// <param name="retries">The retries.</param>
         /// <returns>The object of the first row and first column</returns>
-        public static TDataType ExecuteScalar<TDataType>(this DbCommand command, TDataType defaultValue = default, int retries = 0)
+        [return: NotNullIfNotNull(nameof(defaultValue))]
+        public static TDataType? ExecuteScalar<TDataType>(this DbCommand command, TDataType? defaultValue = default, int retries = 0)
         {
             if (command is null)
                 return defaultValue;
-            command.Open(retries);
+            _ = command.Open(retries);
             return command.ExecuteScalar().To(defaultValue);
         }
 
@@ -246,11 +240,12 @@ public static TDataType ExecuteScalar<TDataType>(this DbCommand command, TDataTy
         /// <param name="defaultValue">Default value if there is an issue</param>
         /// <param name="retries">The retries.</param>
         /// <returns>The object of the first row and first column</returns>
-        public static async Task<TDataType> ExecuteScalarAsync<TDataType>(this DbCommand command, TDataType defaultValue = default, int retries = 0)
+        [return: NotNullIfNotNull(nameof(defaultValue))]
+        public static async Task<TDataType?> ExecuteScalarAsync<TDataType>(this DbCommand command, TDataType? defaultValue = default, int retries = 0)
         {
             if (command is null)
                 return defaultValue;
-            command.Open(retries);
+            _ = command.Open(retries);
             var ReturnValue = await command.ExecuteScalarAsync().ConfigureAwait(false);
             return ReturnValue.To(defaultValue);
         }
@@ -263,15 +258,14 @@ public static async Task<TDataType> ExecuteScalarAsync<TDataType>(this DbCommand
         /// <returns>The DbParameter associated with the ID</returns>
         public static DbParameter GetOrCreateParameter(this DbCommand command, string id)
         {
-            if (command is null)
-                throw new ArgumentNullException(nameof(command));
+            ArgumentNullException.ThrowIfNull(command, nameof(command));
             if (command.Parameters.Contains(id))
             {
                 return command.Parameters[id];
             }
-            var Parameter = command.CreateParameter();
+            DbParameter Parameter = command.CreateParameter();
             Parameter.ParameterName = id;
-            command.Parameters.Add(Parameter);
+            _ = command.Parameters.Add(Parameter);
             return Parameter;
         }
 
@@ -286,9 +280,9 @@ public static DbParameter GetOrCreateParameter(this DbCommand command, string id
         /// if the parameter exists (and isn't null or empty), it returns the parameter's value.
         /// Otherwise the default value is returned.
         /// </returns>
-        public static TDataType GetOutputParameter<TDataType>(this DbCommand command, string id, TDataType defaultValue = default)
+        public static TDataType? GetOutputParameter<TDataType>(this DbCommand command, string id, TDataType? defaultValue = default)
         {
-            return !(command?.Parameters[id] is null) ?
+            return command?.Parameters[id] is not null ?
                 command.Parameters[id].Value.To(defaultValue) :
                 defaultValue;
         }
@@ -301,26 +295,28 @@ public static TDataType GetOutputParameter<TDataType>(this DbCommand command, st
         /// <returns>The DBCommand object</returns>
         public static DbCommand? Open(this DbCommand command, int retries = 0)
         {
-            Exception? holder = null;
+            Exception? Holder = null;
             while (retries >= 0)
             {
                 try
                 {
-                    if (!(command?.Connection is null)
+                    if (command?.Connection is not null
                         && command.Connection.State != ConnectionState.Open)
                     {
                         command.Connection.Open();
                     }
 
                     return command;
                 }
-                catch (Exception e)
+                catch (Exception E)
                 {
-                    holder = e;
+                    Holder = E;
                 }
                 --retries;
             }
-            throw holder!;
+            if (Holder is not null)
+                throw Holder;
+            return command;
         }
 
         /// <summary>

src/SQLHelper.DB/ExtensionMethods/IDataRecordExtensions.cs

@@ -18,6 +18,7 @@ limitations under the License.
 using ObjectCartographer;
 using System;
 using System.Data;
+using System.Diagnostics.CodeAnalysis;
 
 namespace SQLHelperDB.ExtensionMethods
 {
@@ -37,14 +38,15 @@ public static class IDataRecordExtensions
         /// if the parameter exists (and isn't null or empty), it returns the parameter's value.
         /// Otherwise the default value is returned.
         /// </returns>
-        public static TDataType GetParameter<TDataType>(this IDataRecord reader, string id, TDataType defaultValue = default)
+        [return: NotNullIfNotNull(nameof(defaultValue))]
+        public static TDataType? GetParameter<TDataType>(this IDataRecord reader, string id, TDataType? defaultValue = default)
         {
             if (reader is null)
                 return defaultValue;
-            for (var x = 0; x < reader.FieldCount; ++x)
+            for (var X = 0; X < reader.FieldCount; ++X)
             {
-                if (reader.GetName(x) == id)
-                    return reader.GetParameter(x, defaultValue);
+                if (reader.GetName(X) == id)
+                    return reader.GetParameter(X, defaultValue);
             }
             return defaultValue;
         }
@@ -60,7 +62,8 @@ public static TDataType GetParameter<TDataType>(this IDataRecord reader, string
         /// if the parameter exists (and isn't null or empty), it returns the parameter's value.
         /// Otherwise the default value is returned.
         /// </returns>
-        public static TDataType GetParameter<TDataType>(this IDataRecord reader, int position, TDataType defaultValue = default)
+        [return: NotNullIfNotNull(nameof(defaultValue))]
+        public static TDataType? GetParameter<TDataType>(this IDataRecord reader, int position, TDataType? defaultValue = default)
         {
             if (reader is null)
                 return defaultValue;

src/SQLHelper.DB/GlobalSuppressions.cs

@@ -28,7 +28,16 @@ namespace SQLHelperDB.HelperClasses.BaseClasses
     /// Parameter base class
     /// </summary>
     /// <typeparam name="TDataType">Data type of the parameter</typeparam>
-    public abstract class ParameterBase<TDataType> : IParameter<TDataType>
+    /// <remarks>Constructor</remarks>
+    /// <param name="id">ID of the parameter</param>
+    /// <param name="type">Database type</param>
+    /// <param name="value">Value of the parameter</param>
+    /// <param name="direction">Direction of the parameter</param>
+    /// <param name="parameterStarter">
+    /// What the database expects as the parameter starting string ("@" for SQL Server, ":" for
+    /// Oracle, etc.)
+    /// </param>
+    public abstract class ParameterBase<TDataType>(string id, DbType type, object? value = null, ParameterDirection direction = ParameterDirection.Input, string parameterStarter = "@") : IParameter<TDataType>
     {
         /// <summary>
         /// Constructor
@@ -70,41 +79,20 @@ protected ParameterBase(string id, SqlDbType type, object? value = null, Paramet
         {
         }
 
-        /// <summary>
-        /// Constructor
-        /// </summary>
-        /// <param name="id">ID of the parameter</param>
-        /// <param name="type">Database type</param>
-        /// <param name="value">Value of the parameter</param>
-        /// <param name="direction">Direction of the parameter</param>
-        /// <param name="parameterStarter">
-        /// What the database expects as the parameter starting string ("@" for SQL Server, ":" for
-        /// Oracle, etc.)
-        /// </param>
-        protected ParameterBase(string id, DbType type, object? value = null, ParameterDirection direction = ParameterDirection.Input, string parameterStarter = "@")
-        {
-            ID = id;
-            Value = (TDataType)value!;
-            DatabaseType = type;
-            Direction = direction;
-            BatchID = id;
-            ParameterStarter = parameterStarter;
-        }
-
         /// <summary>
         /// Database type
         /// </summary>
-        public DbType DatabaseType { get; set; }
+        public DbType DatabaseType { get; set; } = type;
 
         /// <summary>
         /// Direction of the parameter
         /// </summary>
-        public ParameterDirection Direction { get; set; }
+        public ParameterDirection Direction { get; set; } = direction;
 
         /// <summary>
         /// The Name that the parameter goes by
         /// </summary>
-        public string ID { get; set; }
+        public string ID { get; set; } = id;
 
         /// <summary>
         /// Gets the internal value.
@@ -115,28 +103,25 @@ protected ParameterBase(string id, DbType type, object? value = null, ParameterD
         /// <summary>
         /// Starting string of the parameter
         /// </summary>
-        public string ParameterStarter { get; set; }
+        public string ParameterStarter { get; set; } = parameterStarter;
 
         /// <summary>
         /// Parameter value
         /// </summary>
-        public TDataType Value { get; set; }
+        public TDataType Value { get; set; } = (TDataType)value!;
 
         /// <summary>
         /// Batch ID
         /// </summary>
-        protected string BatchID { get; set; }
+        protected string BatchID { get; set; } = id;
 
         /// <summary>
         /// != operator
         /// </summary>
         /// <param name="first">First item</param>
         /// <param name="second">Second item</param>
         /// <returns>returns true if they are not equal, false otherwise</returns>
-        public static bool operator !=(ParameterBase<TDataType> first, ParameterBase<TDataType> second)
-        {
-            return !(first == second);
-        }
+        public static bool operator !=(ParameterBase<TDataType> first, ParameterBase<TDataType> second) => !(first == second);
 
         /// <summary>
         /// The == operator
@@ -147,8 +132,8 @@ protected ParameterBase(string id, DbType type, object? value = null, ParameterD
         public static bool operator ==(ParameterBase<TDataType> first, ParameterBase<TDataType> second)
         {
             return ReferenceEquals(first, second)
-                || (!(first is null)
-                    && !(second is null)
+                || (first is not null
+                    && second is not null
                     && first.GetHashCode() == second.GetHashCode());
         }
 
@@ -183,7 +168,7 @@ public string AddParameter(string command)
         /// </summary>
         /// <param name="obj">Object to compare to</param>
         /// <returns>True if they are equal, false otherwise</returns>
-        public override bool Equals(object obj)
+        public override bool Equals(object? obj)
         {
             return (obj is ParameterBase<TDataType> OtherParameter)
                 && OtherParameter.DatabaseType == DatabaseType
@@ -201,10 +186,10 @@ public override bool Equals(object obj)
         /// </returns>
         public override int GetHashCode()
         {
-            var hashCode = 2030399226;
-            hashCode = (hashCode * -1521134295) + DatabaseType.GetHashCode();
-            hashCode = (hashCode * -1521134295) + EqualityComparer<string>.Default.GetHashCode(ID);
-            return (hashCode * -1521134295) + EqualityComparer<TDataType>.Default.GetHashCode(Value);
+            var HashCode = 2030399226;
+            HashCode = (HashCode * -1521134295) + DatabaseType.GetHashCode();
+            HashCode = (HashCode * -1521134295) + EqualityComparer<string>.Default.GetHashCode(ID);
+            return (HashCode * -1521134295) + EqualityComparer<TDataType>.Default.GetHashCode(Value!);
         }
 
         /// <summary>