modernizing code. We should really be splitting these into individual packages

Author: mariodivece

mail.js

@@ -23,4 +23,4 @@ server.on('error', err => {
     console.log('Error %s', err.message);
 });
 server.listen(1030);
-console.log('We can now sent emails to port 1030!');
+console.log('We can now send emails through port 1030!');

src/Swan.Lite/CompositeHashCode.cs

@@ -90,7 +90,7 @@ public static int Using(params object?[] fields)
         {
             unchecked
             {
-                return fields.Where(f => !(f is null))
+                return fields.Where(f => f is not null)
                     .Aggregate(InitialSeed, (current, field) => (Multiplier * current) + field.GetHashCode());
             }
         }

src/Swan.Lite/Cryptography/Hasher.cs

@@ -6,27 +6,21 @@
 namespace Swan.Cryptography
 {
     /// <summary>
-    /// Use this class to compute a hash in MD4, SHA1, SHA256 or SHA512.
+    /// Use this class to compute a hash in MD5, SHA1, SHA256 or SHA512.
     /// </summary>
     public static class Hasher
     {
-        private static readonly Lazy<MD5> Md5Hasher = new(MD5.Create, true);
-        private static readonly Lazy<SHA1> SHA1Hasher = new(SHA1.Create, true);
-        private static readonly Lazy<SHA256> SHA256Hasher = new(SHA256.Create, true);
-        private static readonly Lazy<SHA512> SHA512Hasher = new(SHA512.Create, true);
-
         /// <summary>
         /// Computes the MD5 hash of the given stream.
         /// Do not use for large streams as this reads ALL bytes at once.
         /// </summary>
         /// <param name="this">The stream.</param>
-        /// <param name="createHasher">if set to <c>true</c> [create hasher].</param>
         /// <returns>
         /// The computed hash code.
         /// </returns>
         /// <exception cref="ArgumentNullException">stream.</exception>
         [Obsolete("Use a better hasher.")]
-        public static byte[] ComputeMD5(Stream @this, bool createHasher = false)
+        public static byte[] ComputeMD5(this Stream @this)
         {
             if (@this == null)
                 throw new ArgumentNullException(nameof(@this));
@@ -52,7 +46,7 @@ public static byte[] ComputeMD5(Stream @this, bool createHasher = false)
             }
             while (readAheadBytesRead != 0);
 
-            return md5.Hash;
+            return md5.Hash ?? Array.Empty<byte>();
         }
 
         /// <summary>
@@ -72,8 +66,17 @@ public static byte[] ComputeMD5(string value, bool createHasher = false) =>
         /// <param name="createHasher">if set to <c>true</c> [create hasher].</param>
         /// <returns>The computed hash code.</returns>
         [Obsolete("Use a better hasher.")]
-        public static byte[] ComputeMD5(byte[] data, bool createHasher = false) =>
-            (createHasher ? MD5.Create() : Md5Hasher.Value).ComputeHash(data);
+        public static byte[] ComputeMD5(byte[] data, bool createHasher = false)
+        {
+            if (createHasher)
+            {
+                using var hasher = MD5.Create();
+                hasher.ComputeHash(data);
+            }
+
+            return MD5.HashData(data);
+        }
+
 
         /// <summary>
         /// Computes the SHA-1 hash of the given string using UTF8 byte encoding.
@@ -88,7 +91,14 @@ public static byte[] ComputeMD5(byte[] data, bool createHasher = false) =>
         public static byte[] ComputeSha1(string @this, bool createHasher = false)
         {
             var inputBytes = Encoding.UTF8.GetBytes(@this);
-            return (createHasher ? SHA1.Create() : SHA1Hasher.Value).ComputeHash(inputBytes);
+
+            if (createHasher)
+            {
+                using var hasher = SHA1.Create();
+                return hasher.ComputeHash(inputBytes);
+            }
+
+            return SHA1.HashData(inputBytes);
         }
 
         /// <summary>
@@ -103,7 +113,13 @@ public static byte[] ComputeSha1(string @this, bool createHasher = false)
         public static byte[] ComputeSha256(string value, bool createHasher = false)
         {
             var inputBytes = Encoding.UTF8.GetBytes(value);
-            return (createHasher ? SHA256.Create() : SHA256Hasher.Value).ComputeHash(inputBytes);
+            if (createHasher)
+            {
+                using var hasher = SHA256.Create();
+                return hasher.ComputeHash(inputBytes);
+            }
+
+            return SHA256.HashData(inputBytes);
         }
 
         /// <summary>
@@ -118,7 +134,14 @@ public static byte[] ComputeSha256(string value, bool createHasher = false)
         public static byte[] ComputeSha512(string value, bool createHasher = false)
         {
             var inputBytes = Encoding.UTF8.GetBytes(value);
-            return (createHasher ? SHA512.Create() : SHA512Hasher.Value).ComputeHash(inputBytes);
+
+            if (createHasher)
+            {
+                using var hasher = SHA512.Create();
+                return hasher.ComputeHash(inputBytes);
+            }
+
+            return SHA512.HashData(inputBytes);
         }
     }
 }

src/Swan.Lite/Extensions.ByteArrays.cs

@@ -428,17 +428,17 @@ public static async Task<byte[]> ReadBytesAsync(this Stream stream, long length,
 
             try
             {
-                var buff = new byte[bufferLength];
+                Memory<byte> buff = new byte[bufferLength];
                 while (length > 0)
                 {
                     if (length < bufferLength)
                         bufferLength = (int)length;
 
-                    var read = await stream.ReadAsync(buff, 0, bufferLength, cancellationToken).ConfigureAwait(false);
+                    var read = await stream.ReadAsync(buff, cancellationToken).ConfigureAwait(false);
                     if (read == 0)
                         break;
 
-                    dest.Write(buff, 0, read);
+                    await dest.WriteAsync(buff.Slice(0, bufferLength), cancellationToken);
                     length -= read;
                 }
             }

src/Swan.Lite/Extensions.Dates.cs

@@ -195,16 +195,16 @@ public static string ToRfc1123String(this DateTime @this)
             if (string.IsNullOrWhiteSpace(parts) || parts == "*")
                 return null;
 
-            if (parts.Contains(","))
+            if (parts.Contains(",", StringComparison.Ordinal))
             {
                 return parts.Split(',').Select(int.Parse).Contains(value);
             }
 
             var stop = DateRanges[type];
 
-            if (parts.Contains("/"))
+            if (parts.Contains("/", StringComparison.Ordinal))
             {
-                var multiple = int.Parse(parts.Split('/').Last());
+                var multiple = int.Parse(parts.Split('/').Last(), CultureInfo.InvariantCulture);
                 var start = type is "dayOfMonth" or "month" ? 1 : 0;
 
                 for (var i = start; i <= stop; i += multiple)
@@ -213,11 +213,11 @@ public static string ToRfc1123String(this DateTime @this)
                 return false;
             }
 
-            if (parts.Contains("-"))
+            if (parts.Contains("-", StringComparison.Ordinal))
             {
                 var range = parts.Split('-');
-                var start = int.Parse(range.First());
-                stop = Math.Max(stop, int.Parse(range.Last()));
+                var start = int.Parse(range.First(), CultureInfo.InvariantCulture);
+                stop = Math.Max(stop, int.Parse(range.Last(), CultureInfo.InvariantCulture));
 
                 if ((type is "dayOfMonth" or "month") && start == 0)
                     start = 1;
@@ -228,7 +228,7 @@ public static string ToRfc1123String(this DateTime @this)
                 return false;
             }
 
-            return int.Parse(parts) == value;
+            return int.Parse(parts, CultureInfo.InvariantCulture) == value;
         }
     }
 }

src/Swan.Lite/Extensions.Strings.cs

@@ -34,8 +34,8 @@ public static class StringExtensions
             return x[0] + " " + x.Substring(1, x.Length - 1);
         });
 
-        private static readonly Lazy<string[]> InvalidFilenameChars =
-            new(() => Path.GetInvalidFileNameChars().Select(c => c.ToStringInvariant()).ToArray());
+        private static readonly Lazy<char[]> InvalidFilenameChars =
+            new(() => Path.GetInvalidFileNameChars().ToArray());
 
         #endregion
 
@@ -51,14 +51,15 @@ public static string ToStringInvariant(this object? @this)
             if (@this == null)
                 return string.Empty;
 
+            if (@this is string stringValue)
+                return stringValue;
+
             var itemType = @this.GetType();
 
-            if (itemType == typeof(string))
-                return @this as string ?? string.Empty;
+            if (Definitions.BasicTypesInfo.Value.TryGetValue(itemType, out var info))
+                return info.ToStringInvariant(@this);
 
-            return Definitions.BasicTypesInfo.Value.ContainsKey(itemType)
-                ? Definitions.BasicTypesInfo.Value[itemType].ToStringInvariant(@this)
-                : @this.ToString();
+            return @this.ToString() ?? string.Empty;
         }
 
         /// <summary>
@@ -288,9 +289,32 @@ public static string ToSafeFilename(this string? value) =>
             value == null
                 ? throw new ArgumentNullException(nameof(value))
                 : InvalidFilenameChars.Value
-                    .Aggregate(value, (current, c) => current.Replace(c, string.Empty))
+                    .Aggregate(value, (current, c) => current.RemoveChar(c))
                     .Slice(0, 220);
 
+        /// <summary>
+        /// Removes all instances of the given character from a string.
+        /// </summary>
+        /// <param name="value">The string to be searched.</param>
+        /// <param name="find">The character to be removed.</param>
+        /// <returns>The newly-formed string without the given char.</returns>
+        public static string RemoveChar(this string? value, char find)
+        {
+            if (value == null)
+                throw new ArgumentNullException(nameof(value));
+
+            var builder = new StringBuilder(value.Length);
+            foreach (var c in value)
+            {
+                if (c == find)
+                    continue;
+
+                builder.Append(c);
+            }
+
+            return builder.ToString();
+        }
+
         /// <summary>
         /// Formats a long into the closest bytes string.
         /// </summary>
@@ -378,7 +402,7 @@ public static bool Contains(this string value, params char[] chars) =>
         /// <param name="chars">The chars.</param>
         /// <returns>The string with the characters replaced.</returns>
         public static string ReplaceAll(this string value, string replaceValue, params char[] chars) =>
-            chars.Aggregate(value, (current, c) => current.Replace(new string(new[] { c }), replaceValue));
+            chars.Aggregate(value, (current, c) => current.Replace(new string(c, 1), replaceValue, StringComparison.Ordinal));
 
         /// <summary>
         /// Convert hex character to an integer. Return -1 if char is something

src/Swan.Lite/Formatters/CsvWriter.cs

@@ -264,18 +264,18 @@ public void WriteLine(IEnumerable<string> items)
 
                     // Determine if we need the string to be enclosed 
                     // (it either contains an escape, new line, or separator char)
-                    needsEnclosing = textValue.IndexOf(SeparatorCharacter) >= 0
-                                     || textValue.IndexOf(EscapeCharacter) >= 0
-                                     || textValue.IndexOf('\r') >= 0
-                                     || textValue.IndexOf('\n') >= 0;
+                    needsEnclosing = textValue.Contains(SeparatorCharacter, StringComparison.Ordinal)
+                                     || textValue.Contains(EscapeCharacter, StringComparison.Ordinal)
+                                     || textValue.Contains('\r', StringComparison.Ordinal)
+                                     || textValue.Contains('\n', StringComparison.Ordinal);
 
                     // Escape the escape characters by repeating them twice for every instance
                     textValue = textValue.Replace($"{EscapeCharacter}",
-                        $"{EscapeCharacter}{EscapeCharacter}");
+                        $"{EscapeCharacter}{EscapeCharacter}", StringComparison.Ordinal);
 
                     // Enclose the text value if we need to
                     if (needsEnclosing)
-                        textValue = string.Format($"{EscapeCharacter}{textValue}{EscapeCharacter}", textValue);
+                        textValue = $"{EscapeCharacter}{textValue}{EscapeCharacter}";
 
                     // Get the bytes to write to the stream and write them
                     output = _encoding.GetBytes(textValue);

src/Swan.Lite/Formatters/HumanizeJson.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
@@ -126,8 +127,8 @@ private void AppendList(IEnumerable<object> objects)
 
         private void AppendString(string stringValue)
         {
-            if (stringValue.Length + _indentStr.Length <= 96 && stringValue.IndexOf('\r') < 0 &&
-                stringValue.IndexOf('\n') < 0)
+            if (stringValue.Length + _indentStr.Length <= 96 && !stringValue.Contains('\r', StringComparison.Ordinal) &&
+                !stringValue.Contains('\n', StringComparison.Ordinal))
             {
                 _builder.Append($"{stringValue}");
                 return;

src/Swan.Lite/Formatters/Json.Deserializer.cs

@@ -166,10 +166,10 @@ private void ExtractValue()
             private static string Unescape(string str)
             {
                 // check if we need to unescape at all
-                if (str.IndexOf(StringEscapeChar) < 0)
+                if (!str.Contains(StringEscapeChar, StringComparison.Ordinal))
                     return str;
 
-                var builder = new StringBuilder(str.Length);
+                var builder = new StringBuilder(str.Length * 2);
                 for (var i = 0; i < str.Length; i++)
                 {
                     if (str[i] != StringEscapeChar)

src/Swan.Lite/Formatters/Json.Serializer.cs

@@ -245,13 +245,20 @@ private string ResolveDictionary(IDictionary items, int depth)
                 var writeCount = 0;
                 foreach (var key in items.Keys)
                 {
+                    var keyName = key is not null
+                        ? key.ToString()
+                        : string.Empty;
+
+                    if (key == null || string.IsNullOrWhiteSpace(keyName))
+                        continue;
+
                     // Serialize and append the key (first char indented)
                     Append(StringQuotedChar, depth + 1);
-                    Escape(key.ToString(), _builder);
+                    Escape(keyName, _builder);
                     _builder
                         .Append(StringQuotedChar)
                         .Append(ValueSeparatorChar)
-                        .Append(" ");
+                        .Append(' ');
 
                     // Serialize and append the value
                     var serializedValue = Serialize(items[key], depth + 1, _options, _excludedNames);