split range operators of IPv4 and IPv6

jsakamoto · Aug 18, 2020 · 4f75699 · 4f75699
1 parent 12107bb
commit 4f75699
Show file tree

Hide file tree

Showing 6 changed files with 586 additions and 21 deletions.
diff --git a/IPAddressRange/IPAddressRange.cs b/IPAddressRange/IPAddressRange.cs
@@ -5,6 +5,7 @@
 using System.Net;
 using System.Text.RegularExpressions;
 using System.ComponentModel;
+using NetTools.Internals;
 
 #if NET45
 using System.Runtime.Serialization;
@@ -78,6 +79,8 @@ public class IPAddressRange : IEnumerable<IPAddress>, IReadOnlyDictionary<string
 
         public IPAddress End { get; set; }
 
+        private IRangeOperator Operator { get; set; }
+
         /// <summary>
         /// Creates an empty range object, equivalent to "0.0.0.0/0".
         /// </summary>
@@ -93,6 +96,7 @@ public IPAddressRange(IPAddress singleAddress)
                 throw new ArgumentNullException(nameof(singleAddress));
 
             Begin = End = singleAddress;
+            Operator = RangeOperatorFactory.Create(this);
         }
 
         /// <summary>
@@ -116,6 +120,8 @@ public IPAddressRange(IPAddress begin, IPAddress end)
             if (Begin.AddressFamily != End.AddressFamily) throw new ArgumentException("Elements must be of the same address family", nameof(end));
 
             if (!Bits.GtECore(endBytes, beginBytes)) throw new ArgumentException("Begin must be smaller than the End", nameof(begin));
+
+            Operator = RangeOperatorFactory.Create(this);
         }
 
         /// <summary>
@@ -145,6 +151,7 @@ public IPAddressRange(string ipRangeString)
             var parsed = Parse(ipRangeString);
             Begin = parsed.Begin;
             End = parsed.End;
+            Operator = RangeOperatorFactory.Create(this);
         }
 
 #if NET45
@@ -159,6 +166,7 @@ protected IPAddressRange(SerializationInfo info, StreamingContext context)
 
             this.Begin = deserialize("Begin");
             this.End = deserialize("End");
+            Operator = RangeOperatorFactory.Create(this);
         }
 
         public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
@@ -177,14 +185,7 @@ public bool Contains(IPAddress ipaddress)
 
             if (ipaddress.AddressFamily != this.Begin.AddressFamily) return false;
 
-            var offset = 0;
-            if (Begin.IsIPv4MappedToIPv6 && ipaddress.IsIPv4MappedToIPv6)
-            {
-                offset = 12; //ipv4 has prefix of 10 zero bytes and two 255 bytes. 
-            }
-
-            var adrBytes = ipaddress.GetAddressBytes();
-            return Bits.LtECore(this.Begin.GetAddressBytes(), adrBytes, offset) && Bits.GtECore(this.End.GetAddressBytes(), adrBytes, offset);
+            return Operator.Contains(ipaddress);
         }
 
         public bool Contains(IPAddressRange range)
@@ -194,15 +195,7 @@ public bool Contains(IPAddressRange range)
 
             if (this.Begin.AddressFamily != range.Begin.AddressFamily) return false;
 
-            var offset = 0;
-            if (Begin.IsIPv4MappedToIPv6 && range.Begin.IsIPv4MappedToIPv6)
-            {
-                offset = 12; //ipv4 has prefix of 10 zero bytes and two 255 bytes. 
-            }
-
-            return
-                Bits.LtECore(this.Begin.GetAddressBytes(), range.Begin.GetAddressBytes(), offset) &&
-                Bits.GtECore(this.End.GetAddressBytes(), range.End.GetAddressBytes(), offset);
+            return Operator.Contains(range);
         }
 
         public static IPAddressRange Parse(string ipRangeString)
@@ -324,10 +317,7 @@ public static int SubnetMaskLength(IPAddress subnetMask)
 
         public IEnumerator<IPAddress> GetEnumerator()
         {
-            var first = Begin.GetAddressBytes();
-            var last = End.GetAddressBytes();
-            for (var ip = first; Bits.LtECore(ip, last); ip = Bits.Increment(ip))
-                yield return new IPAddress(ip);
+            return Operator.GetEnumerator();
         }
 
         IEnumerator IEnumerable.GetEnumerator()

diff --git a/IPAddressRange/Internals/IPv4RangeOperator.cs b/IPAddressRange/Internals/IPv4RangeOperator.cs
@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Net;
+
+namespace NetTools.Internals
+{
+    internal class IPv4RangeOperator : IRangeOperator
+    {
+        private IPAddressRange Range { get; }
+
+        public IPv4RangeOperator(IPAddressRange range)
+        {
+            this.Range = range;
+        }
+
+        public bool Contains(IPAddress ipaddress)
+        {
+            var offset = 0;
+            if (Range.Begin.IsIPv4MappedToIPv6 && ipaddress.IsIPv4MappedToIPv6)
+            {
+                offset = 12; //ipv4 has prefix of 10 zero bytes and two 255 bytes. 
+            }
+
+            var adrBytes = ipaddress.GetAddressBytes();
+            return Bits.LtECore(this.Range.Begin.GetAddressBytes(), adrBytes, offset) && Bits.GtECore(this.Range.End.GetAddressBytes(), adrBytes, offset);
+        }
+
+        public bool Contains(IPAddressRange range)
+        {
+            var offset = 0;
+            if (Range.Begin.IsIPv4MappedToIPv6 && range.Begin.IsIPv4MappedToIPv6)
+            {
+                offset = 12; //ipv4 has prefix of 10 zero bytes and two 255 bytes. 
+            }
+
+            return
+                Bits.LtECore(Range.Begin.GetAddressBytes(), range.Begin.GetAddressBytes(), offset) &&
+                Bits.GtECore(Range.End.GetAddressBytes(), range.End.GetAddressBytes(), offset);
+        }
+
+        public IEnumerator<IPAddress> GetEnumerator()
+        {
+            var first = Range.Begin.GetAddressBytes();
+            var last = Range.End.GetAddressBytes();
+            for (var ip = first; Bits.LtECore(ip, last); ip = Bits.Increment(ip))
+                yield return new IPAddress(ip);
+        }
+    }
+}
diff --git a/IPAddressRange/Internals/IPv6RangeOperator.cs b/IPAddressRange/Internals/IPv6RangeOperator.cs
@@ -0,0 +1,48 @@
+using System.Collections.Generic;
+using System.Net;
+
+namespace NetTools.Internals
+{
+    internal class IPv6RangeOperator : IRangeOperator
+    {
+        private IPAddressRange Range { get; }
+
+        public IPv6RangeOperator(IPAddressRange range)
+        {
+            this.Range = range;
+        }
+
+        public bool Contains(IPAddress ipaddress)
+        {
+            var offset = 0;
+            if (Range.Begin.IsIPv4MappedToIPv6 && ipaddress.IsIPv4MappedToIPv6)
+            {
+                offset = 12; //ipv4 has prefix of 10 zero bytes and two 255 bytes. 
+            }
+
+            var adrBytes = ipaddress.GetAddressBytes();
+            return Bits.LtECore(this.Range.Begin.GetAddressBytes(), adrBytes, offset) && Bits.GtECore(this.Range.End.GetAddressBytes(), adrBytes, offset);
+        }
+
+        public bool Contains(IPAddressRange range)
+        {
+            var offset = 0;
+            if (Range.Begin.IsIPv4MappedToIPv6 && range.Begin.IsIPv4MappedToIPv6)
+            {
+                offset = 12; //ipv4 has prefix of 10 zero bytes and two 255 bytes. 
+            }
+
+            return
+                Bits.LtECore(Range.Begin.GetAddressBytes(), range.Begin.GetAddressBytes(), offset) &&
+                Bits.GtECore(Range.End.GetAddressBytes(), range.End.GetAddressBytes(), offset);
+        }
+
+        public IEnumerator<IPAddress> GetEnumerator()
+        {
+            var first = Range.Begin.GetAddressBytes();
+            var last = Range.End.GetAddressBytes();
+            for (var ip = first; Bits.LtECore(ip, last); ip = Bits.Increment(ip))
+                yield return new IPAddress(ip);
+        }
+    }
+}
diff --git a/IPAddressRange/Internals/IRangeOperator.cs b/IPAddressRange/Internals/IRangeOperator.cs
@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using System.Net;
+
+namespace NetTools.Internals
+{
+    internal interface IRangeOperator
+    {
+        bool Contains(IPAddress ipaddress);
+        bool Contains(IPAddressRange range);
+        IEnumerator<IPAddress> GetEnumerator();
+    }
+}
diff --git a/IPAddressRange/Internals/RangeOperatorFactory.cs b/IPAddressRange/Internals/RangeOperatorFactory.cs
@@ -0,0 +1,14 @@
+using System.Net.Sockets;
+
+namespace NetTools.Internals
+{
+    internal static class RangeOperatorFactory
+    {
+        public static IRangeOperator Create(IPAddressRange range)
+        {
+            return range.Begin.AddressFamily == AddressFamily.InterNetwork ?
+                new IPv4RangeOperator(range) :
+                new IPv6RangeOperator(range) as IRangeOperator;
+        }
+    }
+}