Re-work the Visitor pattern.

DesignPatterns.Visitor/Context.cs

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

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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;
+    }
+}

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

@@ -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>

DesignPatterns.Visitor/Handler.cs

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

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

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);
+}

DesignPatterns.Visitor/IVisitor.cs

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

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);
+    }
+}

DesignPatterns.Visitor/Models/SizeInBytes.cs

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

DesignPatterns.Visitor/Models/SizeInGigaBytes.cs

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

DesignPatterns.Visitor/Models/SizeInKiloBytes.cs

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

DesignPatterns.Visitor/Models/SizeInMegaBytes.cs

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

DesignPatterns.Visitor/Models/SizeInPetaBytes.cs

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

DesignPatterns.Visitor/Models/SizeInTeraBytes.cs

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

DesignPatterns.Visitor/Program.cs

@@ -1,10 +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);
+// 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();