Re-work the Visitor pattern.

Add models for KB, MB, GB, TB, PT.
Add converters.
Update the solution structure.

Behavioral/DesignPatterns.Visitor/Context.cs

@@ -0,0 +1,30 @@
+// using AutoFixture;
+//
+// namespace DesignPatterns.Visitor;
+//
+// public class Context
+// {
+//     private readonly IFixture fixture = new Fixture();
+//     private readonly Random random = new Random();
+//
+//     public (ICollection<IAmount> itemsInBytes, ICollection<IAmount> itemsInGB) GetData()
+//     {
+//         var inBytes = GetSizesInBytes().ToList();
+//         var inGB = GetSizesInGB().ToList();
+//         return (inBytes, inGB);
+//     }
+//
+//     private static IEnumerable<IAmount> GetSizesInBytes()
+//     {
+//         yield return new AmountInBytes { Value = 1073741824 };
+//         yield return new AmountInBytes { Value = 2147483648 };
+//         yield return new AmountInBytes { Value = 3221225472 };
+//     }
+//
+//     private static IEnumerable<IAmount> GetSizesInGB()
+//     {
+//         yield return new AmountInGB { Value = 10 };
+//         yield return new AmountInGB { Value = 20 };
+//         yield return new AmountInGB { Value = 30 };
+//     }
+// }

Behavioral/DesignPatterns.Visitor/Converters/GigaBytesToBytesConverter.cs

@@ -0,0 +1,24 @@
+using DesignPatterns.Visitor.Models;
+
+namespace DesignPatterns.Visitor.Converters;
+
+public class GigaBytesToBytesConverter : ISizeConverter<ISize>
+{
+    public ISize Convert(ISize size)
+    {
+        if (size is SizeInGigaBytes gigaBytes)
+        {
+            return new SizeInBytes
+            {
+                Value = gigaBytes.Value * 1024 * 1024 * 1024
+            };
+        }
+
+        throw new InvalidOperationException("Could not convert GigaBytes to Bytes.");
+    }
+
+    public bool CanConvert(ISize size)
+    {
+        return size is SizeInGigaBytes;
+    }
+}

Behavioral/DesignPatterns.Visitor/Converters/KiloBytesToBytesConverter.cs

@@ -0,0 +1,24 @@
+using DesignPatterns.Visitor.Models;
+
+namespace DesignPatterns.Visitor.Converters;
+
+public class KiloBytesToBytesConverter : ISizeConverter<ISize>
+{
+    public ISize Convert(ISize size)
+    {
+        if (size is SizeInKiloBytes kiloBytes)
+        {
+            return new SizeInBytes
+            {
+                Value = kiloBytes.Value * 1024
+            };
+        }
+
+        throw new InvalidOperationException("Could not convert KiloBytes to Bytes.");
+    }
+
+    public bool CanConvert(ISize size)
+    {
+        return size is SizeInKiloBytes;
+    }
+}

Behavioral/DesignPatterns.Visitor/Converters/MegaBytesToBytesConverter.cs

@@ -0,0 +1,24 @@
+using DesignPatterns.Visitor.Models;
+
+namespace DesignPatterns.Visitor.Converters;
+
+public class MegaBytesToBytesConverter : ISizeConverter<ISize>
+{
+    public ISize Convert(ISize size)
+    {
+        if (size is SizeInMegaBytes megaBytes)
+        {
+            return new SizeInBytes
+            {
+                Value = megaBytes.Value * 1024 * 1024
+            };
+        }
+
+        throw new InvalidOperationException("Could not convert MegaBytes to Bytes.");
+    }
+
+    public bool CanConvert(ISize size)
+    {
+        return size is SizeInMegaBytes;
+    }
+}

Behavioral/DesignPatterns.Visitor/Converters/PetaBytesToBytesConverter.cs

@@ -0,0 +1,24 @@
+using DesignPatterns.Visitor.Models;
+
+namespace DesignPatterns.Visitor.Converters;
+
+public class PetaBytesToBytesConverter : ISizeConverter<ISize>
+{
+    public ISize Convert(ISize size)
+    {
+        if (size is SizeInPetaBytes petaBytes)
+        {
+            return new SizeInBytes
+            {
+                Value = petaBytes.Value * 1024 * 1024 * 1024 * 1024 * 1024
+            };
+        }
+
+        throw new InvalidOperationException("Could not convert PetaBytes to Bytes.");
+    }
+
+    public bool CanConvert(ISize size)
+    {
+        return size is SizeInPetaBytes;
+    }
+}

Behavioral/DesignPatterns.Visitor/Converters/TeraBytesToBytesConverter.cs

@@ -0,0 +1,24 @@
+using DesignPatterns.Visitor.Models;
+
+namespace DesignPatterns.Visitor.Converters;
+
+public class TeraBytesToBytesConverter : ISizeConverter<ISize>
+{
+    public ISize Convert(ISize size)
+    {
+        if (size is SizeInTeraBytes gigaBytes)
+        {
+            return new SizeInBytes
+            {
+                Value = gigaBytes.Value * 1024 * 1024 * 1024 * 1024
+            };
+        }
+
+        throw new InvalidOperationException("Could not convert TeraBytes to Bytes.");
+    }
+
+    public bool CanConvert(ISize size)
+    {
+        return size is SizeInTeraBytes;
+    }
+}

DesignPatterns.Visitor/DesignPatterns.Visitor.csproj → Behavioral/DesignPatterns.Visitor/DesignPatterns.Visitor.csproj

@@ -9,12 +9,6 @@
         <RootNamespace>DesignPatterns.Visitor</RootNamespace>
     </PropertyGroup>
 
-    <ItemGroup>
-      <Content Include="..\.dockerignore">
-        <Link>.dockerignore</Link>
-      </Content>
-    </ItemGroup>
-
     <ItemGroup>
       <PackageReference Include="AutoFixture" Version="4.18.1" />
     </ItemGroup>

Behavioral/DesignPatterns.Visitor/Handler.cs

@@ -0,0 +1,15 @@
+// namespace DesignPatterns.Visitor;
+//
+// public class Handler(IEnumerable<IVisitor> visitors)
+// {
+//     public IEnumerable<IAmount> Process(ICollection<IAmount> sizes)
+//     {
+//         var result = new List<IAmount>();
+//         foreach (var visitor in visitors)
+//         {
+//             result.AddRange(sizes.Select(size => size.Accept(visitor)));
+//         }
+//
+//         return result;
+//     }
+// }

DesignPatterns.Visitor/ISize.cs → Behavioral/DesignPatterns.Visitor/ISize.cs

@@ -4,5 +4,5 @@ public interface ISize
 {
     double Value { get; }
     string Unit { get; }
-    ISize Accept(IVisitor visitor);
+    ISize Accept(IVisitor<ISize, ISize> visitor);
 }

Behavioral/DesignPatterns.Visitor/ISizeConverter.cs

@@ -0,0 +1,7 @@
+namespace DesignPatterns.Visitor;
+
+public interface ISizeConverter<in T> where T : ISize
+{
+    ISize Convert(T size);
+    bool CanConvert(T size);
+}

Behavioral/DesignPatterns.Visitor/IVisitor.cs

@@ -0,0 +1,6 @@
+namespace DesignPatterns.Visitor;
+
+public interface IVisitor<in TInput, out TResult>
+{
+    TResult Visit(TInput size); 
+}

Behavioral/DesignPatterns.Visitor/Models/Size.cs

@@ -0,0 +1,12 @@
+namespace DesignPatterns.Visitor.Models;
+
+public record class Size : ISize
+{
+    public double Value { get; init; }
+    public virtual string Unit { get; init; }
+
+    public ISize Accept(IVisitor<ISize, ISize> visitor)
+    {
+        return visitor.Visit(this);
+    }
+}

Behavioral/DesignPatterns.Visitor/Models/SizeInBytes.cs

@@ -0,0 +1,6 @@
+namespace DesignPatterns.Visitor.Models;
+
+public record class SizeInBytes : Size
+{
+    public override string Unit => "Bytes";
+}

Behavioral/DesignPatterns.Visitor/Models/SizeInGigaBytes.cs

@@ -0,0 +1,6 @@
+namespace DesignPatterns.Visitor.Models;
+
+public record class SizeInGigaBytes : Size
+{
+    public override string Unit => "GB";
+}

Behavioral/DesignPatterns.Visitor/Models/SizeInKiloBytes.cs

@@ -0,0 +1,6 @@
+namespace DesignPatterns.Visitor.Models;
+
+public record class SizeInKiloBytes : Size
+{
+    public override string Unit => "KB";
+}

Behavioral/DesignPatterns.Visitor/Models/SizeInMegaBytes.cs

@@ -0,0 +1,6 @@
+namespace DesignPatterns.Visitor.Models;
+
+public record class SizeInMegaBytes : Size
+{
+    public override string Unit => "MB";
+}

Behavioral/DesignPatterns.Visitor/Models/SizeInPetaBytes.cs

@@ -0,0 +1,6 @@
+namespace DesignPatterns.Visitor.Models;
+
+public record class SizeInPetaBytes : Size
+{
+    public override string Unit => "PB";
+}

Behavioral/DesignPatterns.Visitor/Models/SizeInTeraBytes.cs

@@ -0,0 +1,6 @@
+namespace DesignPatterns.Visitor.Models;
+
+public record class SizeInTeraBytes : Size
+{
+    public override string Unit => "TB";
+}

Behavioral/DesignPatterns.Visitor/Program.cs

@@ -0,0 +1,41 @@
+using DesignPatterns.Visitor;
+using DesignPatterns.Visitor.Converters;
+
+// var context = new Context();
+// var discountVisitor = new SizeVisitor();
+// var handler = new Handler(new[] { discountVisitor });
+// var data = context.GetData();
+// var convertedInGB = handler.Process(data.itemsInBytes);
+// var convertedInBytes = handler.Process(data.itemsInGB);
+//
+// Console.WriteLine();
+
+var strings = new List<string>
+{
+    "100KB",
+    "200 KB",
+    "10 MB",
+    "200MB",
+    "1GB",
+    "20 GB"
+};
+
+var visitor = new StringVisitor();
+
+var result = new List<ISize>();
+result.AddRange(strings.Select(x => x.Accept(visitor)));
+
+var amountVisitor = new SizeVisitor(
+    new List<ISizeConverter<ISize>>
+    {
+        new KiloBytesToBytesConverter(),
+        new MegaBytesToBytesConverter(),
+        new GigaBytesToBytesConverter(),
+        new TeraBytesToBytesConverter(),
+        new PetaBytesToBytesConverter(),
+    });
+
+var newResult = new List<ISize>();
+newResult.AddRange(result.Select(x => x.Accept(amountVisitor)));
+
+Console.WriteLine();

Behavioral/DesignPatterns.Visitor/SizeVisitor.cs

@@ -0,0 +1,19 @@
+namespace DesignPatterns.Visitor;
+
+public class SizeVisitor : IVisitor<ISize, ISize>
+{
+    private readonly IEnumerable<ISizeConverter<ISize>> converters;
+
+    public SizeVisitor(IEnumerable<ISizeConverter<ISize>> converters)
+    {
+        this.converters = converters;
+    }
+
+    public ISize Visit(ISize size)
+    {
+        var converter = this.converters.FirstOrDefault(x => x.CanConvert(size));
+        return converter is null
+            ? throw new InvalidOperationException("Could not find a proper converter.")
+            : converter.Convert(size);
+    }
+}

Behavioral/DesignPatterns.Visitor/StringExtensions.cs

@@ -0,0 +1,9 @@
+namespace DesignPatterns.Visitor;
+
+public static class StringExtensions
+{
+    public static ISize Accept(this string value, IVisitor<string, ISize> visitor)
+    {
+        return visitor.Visit(value);
+    }
+}

Behavioral/DesignPatterns.Visitor/StringVisitor.cs

@@ -0,0 +1,36 @@
+using System.Text.RegularExpressions;
+using DesignPatterns.Visitor.Models;
+
+namespace DesignPatterns.Visitor;
+
+public class StringVisitor : IVisitor<string, ISize>
+{
+    public ISize Visit(string size)
+    {
+        if (string.IsNullOrWhiteSpace(size))
+        {
+            throw new ArgumentException("Input size string cannot be null or empty.", nameof(size));
+        }
+
+        var regexPattern = @"^(?<value>\d+(\.\d+)?)\s*(?<unit>[KMGTP]?B)$";
+        var match = Regex.Match(size, regexPattern, RegexOptions.IgnoreCase);
+
+        if (!match.Success)
+        {
+            throw new ArgumentException("Invalid size format.", nameof(size));
+        }
+
+        var value = long.Parse(match.Groups["value"].Value);
+        var unit = match.Groups["unit"].Value.ToUpper();
+
+        return unit switch
+        {
+            "KB" => new SizeInKiloBytes { Value = value },
+            "MB" => new SizeInMegaBytes { Value = value },
+            "GB" => new SizeInGigaBytes { Value = value },
+            "TB" => new SizeInTeraBytes { Value = value },
+            "PB" => new SizeInPetaBytes { Value = value },
+            _ => throw new ArgumentOutOfRangeException(nameof(size), "Unknown size unit.")
+        };
+    }
+}