Added new extensions.

Author: D-Diyare

src/FluentExtensions/Enumerators/DigitalStorage.cs

@@ -0,0 +1,10 @@
+namespace FluentExtensions.Enumerators
+{
+    public enum DigitalStorage
+    {
+        KB,
+        MB,
+        GB,
+        TB
+    }
+}

src/FluentExtensions/Enumerators/Position.cs

@@ -0,0 +1,8 @@
+namespace FluentExtensions.Enumerators
+{
+    public enum Position
+    {
+        Start,
+        End
+    }
+}

src/FluentExtensions/FluentExtensions.csproj

@@ -8,10 +8,20 @@
         <RepositoryUrl>https://github.com/D-Diyare/FluentExtensions</RepositoryUrl>
         <RepositoryType>git</RepositoryType>
         <PackageReadmeFile>README.md</PackageReadmeFile>
-        <PackageTags>Fluent, Extensions, .NET, DotNet </PackageTags>
-        <PackageReleaseNotes>Initial Release</PackageReleaseNotes>
+        <PackageTags>extension, datetime, date, dotnet, extension-methods, fluent, string-matching, stringextensions, fluentextension, fluentextensions, numericxtensions</PackageTags>
+        <PackageReleaseNotes>
+          New Extensions Added:
+- string AddToEnd(this string text, string textToAdd, bool addSpaceBeforeAddition = true);
+- string AddToStart(this string text, string textToAdd, bool addSpaceafterAddition = true);
+- string ReplaceMultipleWithOne(this string source, string[] values, string value)
+- string Take(this string source, int characters, Position from = Position.Start);
+- double ToKB(this int number, DigitalStorage from = DigitalStorage.KB);
+- double ToMB(this int number, DigitalStorage from = DigitalStorage.MB);
+- double ToGB(this int number, DigitalStorage from = DigitalStorage.GB);
+- double ToTB(this int number, DigitalStorage from = DigitalStorage.TB);
+        </PackageReleaseNotes>
         <PackageProjectUrl>https://github.com/D-Diyare/FluentExtensions</PackageProjectUrl>
-        <Version>1.1</Version>
+        <Version>1.2</Version>
         <Copyright>Copyright © Diyare Abdulla 2021</Copyright>
         <Title>FluentExtensions</Title>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>

src/FluentExtensions/NumberEx.cs

@@ -1,4 +1,5 @@
-using System;
+using FluentExtensions.Enumerators;
+using System;
 using System.Globalization;
 using System.Linq;
 using System.Text;
@@ -7,6 +8,7 @@ namespace FluentExtensions
 {
     public static class NumberEx
     {
+
         /// <summary>
         /// Determines whether the given target is even.
         /// </summary>
@@ -261,5 +263,91 @@ public static string GenerateRandomString(this int length, bool isUpperCase = fa
             return str.ToString();
         }
 
+        /// <summary>
+        /// Converts given number to kilobytes.
+        /// </summary>
+        /// <param name="number">Number to convert.</param>
+        /// <returns>Kilobytes based on given number.</returns>
+        public static double ToKB(this int number, DigitalStorage from = DigitalStorage.KB)
+        {
+            switch (from)
+            {
+                case DigitalStorage.MB:
+                    return number * 1000;
+                case DigitalStorage.GB:
+                    return number * 1000000;
+                case DigitalStorage.TB:
+                    return number * 1000000000;
+                case DigitalStorage.KB:
+                default:
+                    return number;
+            }
+        }
+
+        /// <summary>
+        /// Converts given number to megabytes.
+        /// </summary>
+        /// <param name="number">Number to convert.</param>
+        /// <param name="from">From type.</param>
+        /// <returns>Megabytes based on given number and given type to convert from.</returns>
+        public static double ToMB(this int number, DigitalStorage from = DigitalStorage.MB)
+        {
+            switch (from)
+            {
+                case DigitalStorage.KB:
+                    return number * 0.001;
+                case DigitalStorage.GB:
+                    return number * 1000;
+                case DigitalStorage.TB:
+                    return number * 1000000;
+                case DigitalStorage.MB:
+                default:
+                    return number;
+            }
+        }
+
+        /// <summary>
+        /// Converts given number to gigabytes.
+        /// </summary>
+        /// <param name="number">Number to convert.</param>
+        /// <param name="from">From type.</param>
+        /// <returns>Gigabytes based on given number and given type to convert from.</returns>
+        public static double ToGB(this int number, DigitalStorage from = DigitalStorage.GB)
+        {
+            switch (from)
+            {
+                case DigitalStorage.KB:
+                    return number.ToMB(DigitalStorage.KB) * 0.001;
+                case DigitalStorage.MB:
+                    return number * 0.001;
+                case DigitalStorage.TB:
+                    return number * 1000;
+                case DigitalStorage.GB:
+                default:
+                    return number;
+            }
+        }
+
+        /// <summary>
+        /// Converts given number to terabytes.
+        /// </summary>
+        /// <param name="number">Number to convert.</param>
+        /// <param name="from">From type.</param>
+        /// <returns>Gigabytes based on given number and given type to convert from.</returns>
+        public static double ToTB(this int number, DigitalStorage from = DigitalStorage.TB)
+        {
+            switch (from)
+            {
+                case DigitalStorage.KB:
+                    return number.ToGB(DigitalStorage.KB) * 0.001;
+                case DigitalStorage.MB:
+                    return number.ToGB(DigitalStorage.MB) * 0.001;
+                case DigitalStorage.GB:
+                    return number * 0.001;
+                case DigitalStorage.TB:
+                default:
+                    return number;
+            }
+        }
     }
 }

src/FluentExtensions/StringEx.cs

@@ -301,7 +301,60 @@ public static async Task<string> ReadFromDiskAsync(this string path)
                 return await outputFile.ReadToEndAsync().ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Adds text to end of another text.
+        /// </summary>
+        /// <param name="text">Source text.</param>
+        /// <param name="textToAdd">Text to add.</param>
+        /// <param name="addSpaceBeforeAddition">Whether to add space before the addition.</param>
+        /// <returns>A Combined string of the old and new text.</returns>
+        public static string AddToEnd(this string text, string textToAdd, bool addSpaceBeforeAddition = true)
+        {
+            var additionText = addSpaceBeforeAddition ? string.Concat(" ", textToAdd) : textToAdd;
+            return string.Concat(text, additionText);
+        }
 
+        /// <summary>
+        /// Adds text to start of another text.
+        /// </summary>
+        /// <param name="text">Source text.</param>
+        /// <param name="textToAdd">Text to add.</param>
+        /// <param name="addSpaceAfterAddition">Whether to add space after the addition.</param>
+        /// <returns>A Combined string of the old and new text.</returns>
+        public static string AddToStart(this string text, string textToAdd, bool addSpaceAfterAddition = true)
+        {
+            var additionText = addSpaceAfterAddition ? string.Concat(textToAdd, " ") : textToAdd;
+            return string.Concat(additionText, text);
+        }
 
+        /// <summary>
+        /// Gets portion of string based on given characters and position to get. 
+        /// </summary>
+        /// <param name="source">Text to take the portion from.</param>
+        /// <param name="characters">Number of characters to get.</param>
+        /// <param name="from">Whether to take the portion for the start or from the end.</param>
+        /// <returns>A portion of string based on given characters and position to get.</returns>
+        public static string Take(this string source, int characters, Position from = Position.Start)
+        {
+            var position = from == Position.Start ? 0 : source.Length;
+            var startIndex = from == Position.End ? (position - characters) : position;
+            return source.Substring(startIndex, characters);
+        }
+
+        /// <summary>
+        /// Replaces multiple values inside a string with one value.
+        /// </summary>
+        /// <param name="source">Text to apply replaces.</param>
+        /// <param name="values">Values to replace.</param>
+        /// <param name="value">value to replace values with.</param>
+        /// <returns>A Text based on replaced values.</returns>
+        public static string ReplaceMultipleWithOne(this string source, string[] values, string value)
+        {
+            string result = source;
+            foreach (var val in values)
+                result = result.Replace(val, value);
+
+            return result;
+        }
     }
 }