Refactor for dotnet 8

Author: fabyr

WireguardAllowedIPs.Tests/AllowedIPsTest.cs

@@ -34,10 +34,10 @@ public void Address_SummaryRange_Test1()
         IPv4Network from = new("4.21.11.19", 32);
         IPv4Network to = new("10.0.11.0", 32);
 
-        string[] expected = new[] 
-        {
+        string[] expected =
+        [
             "4.21.11.19/32", "4.21.11.20/30", "4.21.11.24/29", "4.21.11.32/27", "4.21.11.64/26", "4.21.11.128/25", "4.21.12.0/22", "4.21.16.0/20", "4.21.32.0/19", "4.21.64.0/18", "4.21.128.0/17", "4.22.0.0/15", "4.24.0.0/13", "4.32.0.0/11", "4.64.0.0/10", "4.128.0.0/9", "5.0.0.0/8", "6.0.0.0/7", "8.0.0.0/7", "10.0.0.0/21", "10.0.8.0/23", "10.0.10.0/24", "10.0.11.0/32"
-        };
+        ];
 
         string[] output = from.SummarizeAddressRangeWith(to).Select(x => x.ToString()).ToArray();
 
@@ -50,10 +50,10 @@ public void Address_SummaryRange_Test2()
         IPv4Network from = new("192.168.0.0", 32);
         IPv4Network to = new("255.254.224.1", 32);
 
-        string[] expected = new[] 
-        {
+        string[] expected =
+        [
             "192.168.0.0/13", "192.176.0.0/12", "192.192.0.0/10", "193.0.0.0/8", "194.0.0.0/7", "196.0.0.0/6", "200.0.0.0/5", "208.0.0.0/4", "224.0.0.0/4", "240.0.0.0/5", "248.0.0.0/6", "252.0.0.0/7", "254.0.0.0/8", "255.0.0.0/9", "255.128.0.0/10", "255.192.0.0/11", "255.224.0.0/12", "255.240.0.0/13", "255.248.0.0/14", "255.252.0.0/15", "255.254.0.0/17", "255.254.128.0/18", "255.254.192.0/19", "255.254.224.0/31"
-        };
+        ];
 
         string[] output = from.SummarizeAddressRangeWith(to).Select(x => x.ToString()).ToArray();
 

WireguardAllowedIPs.Tests/IPv4Test.cs

@@ -1,3 +1,4 @@
+#pragma warning disable CA1861 // Avoid constant arrays as arguments
 using System.Globalization;
 
 namespace WireguardAllowedIPs.Tests;
@@ -61,12 +62,12 @@ public void Address_SummaryRange_Test1()
         IPv6Network from = new("c4f1:dea:f260:b2d5::", 128);
         IPv6Network to = new("efa5:8fe1::", 128);
 
-        IPv6Network[] expected = new[] 
+        IPv6Network[] expected = new[]
         {
             "c4f1:dea:f260:b2d5::/64", "c4f1:dea:f260:b2d6::/63", "c4f1:dea:f260:b2d8::/61", "c4f1:dea:f260:b2e0::/59", "c4f1:dea:f260:b300::/56", "c4f1:dea:f260:b400::/54", "c4f1:dea:f260:b800::/53", "c4f1:dea:f260:c000::/50", "c4f1:dea:f261::/48", "c4f1:dea:f262::/47", "c4f1:dea:f264::/46", "c4f1:dea:f268::/45", "c4f1:dea:f270::/44", "c4f1:dea:f280::/41", "c4f1:dea:f300::/40", "c4f1:dea:f400::/38", "c4f1:dea:f800::/37", "c4f1:deb::/32", "c4f1:dec::/30", "c4f1:df0::/28", "c4f1:e00::/23", "c4f1:1000::/20", "c4f1:2000::/19", "c4f1:4000::/18", "c4f1:8000::/17", "c4f2::/15", "c4f4::/14", "c4f8::/13", "c500::/8", "c600::/7", "c800::/5", "d000::/4", "e000::/5", "e800::/6", "ec00::/7", "ee00::/8", "ef00::/9", "ef80::/11", "efa0::/14", "efa4::/16", "efa5::/17", "efa5:8000::/21", "efa5:8800::/22", "efa5:8c00::/23", "efa5:8e00::/24", "efa5:8f00::/25", "efa5:8f80::/26", "efa5:8fc0::/27", "efa5:8fe0::/32", "efa5:8fe1::/128"
         }.Select(x => (IPv6Network)IPNetwork.Parse(x)).ToArray();
 
-        IPv6Network[] output = Array.ConvertAll(from.SummarizeAddressRangeWith(to),x => (IPv6Network)x);
+        IPv6Network[] output = Array.ConvertAll(from.SummarizeAddressRangeWith(to), x => (IPv6Network)x);
 
         Assert.True(new HashSet<IPv6Network>(expected).SetEquals(output), $"Missing Values: {string.Join(",", expected.Where(x => !output.Contains(x)))}; {string.Join(",", output.Where(x => !expected.Contains(x)))}");
     }
@@ -77,13 +78,14 @@ public void Address_SummaryRange_Test2()
         IPv6Network from = new("10eb:a194:e96f:af7:b562:5d0b:f8de:8bfd", 128);
         IPv6Network to = new("fe80::ea:f260:b2d5", 128);
 
-        IPv6Network[] expected = new[] 
+        IPv6Network[] expected = new[]
         {
             "10eb:a194:e96f:af7:b562:5d0b:f8de:8bfd/128", "10eb:a194:e96f:af7:b562:5d0b:f8de:8bfe/127", "10eb:a194:e96f:af7:b562:5d0b:f8de:8c00/118", "10eb:a194:e96f:af7:b562:5d0b:f8de:9000/116", "10eb:a194:e96f:af7:b562:5d0b:f8de:a000/115", "10eb:a194:e96f:af7:b562:5d0b:f8de:c000/114", "10eb:a194:e96f:af7:b562:5d0b:f8df:0/112", "10eb:a194:e96f:af7:b562:5d0b:f8e0:0/107", "10eb:a194:e96f:af7:b562:5d0b:f900:0/104", "10eb:a194:e96f:af7:b562:5d0b:fa00:0/103", "10eb:a194:e96f:af7:b562:5d0b:fc00:0/102", "10eb:a194:e96f:af7:b562:5d0c::/94", "10eb:a194:e96f:af7:b562:5d10::/92", "10eb:a194:e96f:af7:b562:5d20::/91", "10eb:a194:e96f:af7:b562:5d40::/90", "10eb:a194:e96f:af7:b562:5d80::/89", "10eb:a194:e96f:af7:b562:5e00::/87", "10eb:a194:e96f:af7:b562:6000::/83", "10eb:a194:e96f:af7:b562:8000::/81", "10eb:a194:e96f:af7:b563::/80", "10eb:a194:e96f:af7:b564::/78", "10eb:a194:e96f:af7:b568::/77", "10eb:a194:e96f:af7:b570::/76", "10eb:a194:e96f:af7:b580::/73", "10eb:a194:e96f:af7:b600::/71", "10eb:a194:e96f:af7:b800::/69", "10eb:a194:e96f:af7:c000::/66", "10eb:a194:e96f:af8::/61", "10eb:a194:e96f:b00::/56", "10eb:a194:e96f:c00::/54", "10eb:a194:e96f:1000::/52", "10eb:a194:e96f:2000::/51", "10eb:a194:e96f:4000::/50", "10eb:a194:e96f:8000::/49", "10eb:a194:e970::/44", "10eb:a194:e980::/41", "10eb:a194:ea00::/39", "10eb:a194:ec00::/38", "10eb:a194:f000::/36", "10eb:a195::/32", "10eb:a196::/31", "10eb:a198::/29", "10eb:a1a0::/27", "10eb:a1c0::/26", "10eb:a200::/23", "10eb:a400::/22", "10eb:a800::/21", "10eb:b000::/20", "10eb:c000::/18", "10ec::/14", "10f0::/12", "1100::/8", "1200::/7", "1400::/6", "1800::/5", "2000::/3", "4000::/2", "8000::/2", "c000::/3", "e000::/4", "f000::/5", "f800::/6", "fc00::/7", "fe00::/9", "fe80::/89", "fe80::80:0:0/90", "fe80::c0:0:0/91", "fe80::e0:0:0/93", "fe80::e8:0:0/95", "fe80::ea:0:0/97", "fe80::ea:8000:0/98", "fe80::ea:c000:0/99", "fe80::ea:e000:0/100", "fe80::ea:f000:0/103", "fe80::ea:f200:0/106", "fe80::ea:f240:0/107", "fe80::ea:f260:0/113", "fe80::ea:f260:8000/115", "fe80::ea:f260:a000/116", "fe80::ea:f260:b000/119", "fe80::ea:f260:b200/121", "fe80::ea:f260:b280/122", "fe80::ea:f260:b2c0/124", "fe80::ea:f260:b2d0/126", "fe80::ea:f260:b2d4/127"
         }.Select(x => (IPv6Network)IPNetwork.Parse(x)).ToArray();
 
-        IPv6Network[] output = Array.ConvertAll(from.SummarizeAddressRangeWith(to),x => (IPv6Network)x);
+        IPv6Network[] output = Array.ConvertAll(from.SummarizeAddressRangeWith(to), x => (IPv6Network)x);
 
         Assert.True(new HashSet<IPv6Network>(expected).SetEquals(output), $"Missing Values: {string.Join(",", expected.Where(x => !output.Contains(x)))}; {string.Join(",", output.Where(x => !expected.Contains(x)))}");
     }
-}
+}
+#pragma warning restore CA1861 // Avoid constant arrays as arguments

WireguardAllowedIPs.Tests/IPv6Test.cs

@@ -1,2 +1,2 @@
 global using Xunit;
-global using WireguardAllowedIPs.Core;
+global using WireguardAllowedIPs.Core;

WireguardAllowedIPs.Tests/Usings.cs

@@ -28,31 +28,30 @@ private static IPNetwork[] CleanAllowedIPs(IPNetwork[] values, IPNetwork[] allow
 
         // Add the networks which did not conflict with any disallowed ips
         result.AddRange(allowed.Where(x => !disallowed.Any(y => y.Overlaps(x))));
-        
+
         // Remove duplicates and return
         return result.Distinct().ToArray();
     }
 
     public static IPv4Network[] CalculateAllowedIPv4s(IPv4Network[] allowed, IPv4Network[] disallowed)
     {
-        if(disallowed.Length == 0)
+        if (disallowed.Length == 0)
             return allowed;
-        List<IPv4Network> result = new();
+        List<IPv4Network> result = [];
 
         // Remove duplicates
         disallowed = disallowed.Distinct().ToArray();
-        
+
         // Remove disallowed ranges which are already contained within another disallowed range
         // Then sort by ascending address value
-        IPv4Network[] sortedDisallowed = disallowed.Where(x => !disallowed.Any(y => !x.Equals(y) && y.Contains(x)))
-                                         .OrderBy(x => x.GetLowAddressValue()).ToArray();
+        IPv4Network[] sortedDisallowed = [.. disallowed.Where(x => !disallowed.Any(y => !x.Equals(y) && y.Contains(x))).OrderBy(x => x.GetLowAddressValue())];
 
         IPv4Network last = new(0, 32);
-        
+
         // Treat the entire address space as a continous numeric range (which it is)
         // and find the sections which are not inside a disallowed range.
         // This can be done sequentially because we sorted the disallowed ranges by ascending address value
-        foreach(IPv4Network dis in sortedDisallowed)
+        foreach (IPv4Network dis in sortedDisallowed)
         {
             uint low = dis.GetLowAddressValue();
             uint high = dis.GetHighAddressValue();
@@ -62,9 +61,9 @@ public static IPv4Network[] CalculateAllowedIPv4s(IPv4Network[] allowed, IPv4Net
 
         // Finally the last section extends to the maximum address value (all 1s)
         result.AddRange(Array.ConvertAll(last.SummarizeAddressRangeWith(new IPv4Network(uint.MaxValue, 32)), x => (IPv4Network)x));
-        
+
         return Array.ConvertAll(CleanAllowedIPs(
-            Array.ConvertAll(result.ToArray(), x => (IPNetwork)x), 
+            Array.ConvertAll(result.ToArray(), x => (IPNetwork)x),
             Array.ConvertAll(allowed, x => (IPNetwork)x),
             Array.ConvertAll(disallowed, x => (IPNetwork)x)
         ), x => (IPv4Network)x);
@@ -75,18 +74,17 @@ public static IPv6Network[] CalculateAllowedIPv6s(IPv6Network[] allowed, IPv6Net
         // This is exactly the same as the IPv4 version
         // Maybe this could be condensed into a single method with some clever generics/methods in each class?
 
-        if(disallowed.Length == 0)
+        if (disallowed.Length == 0)
             return allowed;
-        List<IPv6Network> result = new();
-        
+        List<IPv6Network> result = [];
+
         disallowed = disallowed.Distinct().ToArray();
-        
-        IPv6Network[] sortedDisallowed = disallowed.Where(x => !disallowed.Any(y => !x.Equals(y) && y.Contains(x)))
-                                         .OrderBy(x => x.GetLowAddressValue()).ToArray();
+
+        IPv6Network[] sortedDisallowed = [.. disallowed.Where(x => !disallowed.Any(y => !x.Equals(y) && y.Contains(x))).OrderBy(x => x.GetLowAddressValue())];
 
         IPv6Network last = new(UInt128.Zero, 128);
-        
-        foreach(IPv6Network dis in sortedDisallowed)
+
+        foreach (IPv6Network dis in sortedDisallowed)
         {
             UInt128 low = dis.GetLowAddressValue();
             UInt128 high = dis.GetHighAddressValue();
@@ -95,15 +93,15 @@ public static IPv6Network[] CalculateAllowedIPv6s(IPv6Network[] allowed, IPv6Net
         }
 
         result.AddRange(Array.ConvertAll(last.SummarizeAddressRangeWith(new IPv6Network(UInt128.MaxValue, 128)), x => (IPv6Network)x));
-        
+
         return Array.ConvertAll(CleanAllowedIPs(
-            Array.ConvertAll(result.ToArray(), x => (IPNetwork)x), 
+            Array.ConvertAll(result.ToArray(), x => (IPNetwork)x),
             Array.ConvertAll(allowed, x => (IPNetwork)x),
             Array.ConvertAll(disallowed, x => (IPNetwork)x)
         ), x => (IPv6Network)x);
     }
 
     public static IPNetwork[] CalculateAllowedIPs(string[] allowed, string[] disallowed)
-        => CalculateAllowedIPs(allowed.Select(IPNetwork.Parse).ToArray(), 
+        => CalculateAllowedIPs(allowed.Select(IPNetwork.Parse).ToArray(),
                                disallowed.Select(IPNetwork.Parse).ToArray());
 }

WireguardAllowedIPs/Core/Calculator.cs

@@ -3,17 +3,12 @@ namespace WireguardAllowedIPs.Core;
 /// <summary>
 /// Baseclass for IPv4Network and IPv6Network
 /// </summary>
-public abstract class IPNetwork
+public abstract class IPNetwork(int cidr)
 {
-    public int Cidr { get; set; }
+    public int Cidr { get; set; } = cidr;
     public abstract string AddressRepresentation { get; }
     public byte[]? AddressBytes { get; protected set; }
 
-    public IPNetwork(int cidr)
-    {
-        Cidr = cidr;
-    }
-
     /// <summary>
     /// Tests if the current instance fully contains another network. <br/>
     /// (If all addresses in the other network fall within this network.) <br/>
@@ -31,7 +26,7 @@ public IPNetwork(int cidr)
     /// <param name="other">The other network to compare with.</param>
     /// <returns>True, if they overlap. False otherwise.</returns>
     public abstract bool Overlaps(IPNetwork other);
-    
+
     /// <summary>
     /// Finds all address ranges (networks) between the address of the current instance and <paramref name="b"/> <br/>
     /// Note: Both addresses must be pure addresses and not networks. <br/>
@@ -62,11 +57,11 @@ public override string ToString()
     public static IPNetwork Parse(string value)
     {
         string[] parts = value.Split('/');
-        if(parts.Length != 2)
+        if (parts.Length != 2)
             throw new FormatException("Invalid address.");
-        if(!int.TryParse(parts[1], out int cidr))
+        if (!int.TryParse(parts[1], out int cidr))
             throw new FormatException("Invalid CIDR.");
-        if(parts[0].Contains(':')) // IPv6
+        if (parts[0].Contains(':')) // IPv6
             return new IPv6Network(parts[0], cidr);
         return new IPv4Network(parts[0], cidr);
     }

WireguardAllowedIPs/Core/IPNetwork.cs

@@ -13,19 +13,19 @@ public class IPv4Network : IPNetwork
 
     public IPv4Network(byte[] bytes, int cidr) : base(cidr)
     {
-        if(bytes.Length != 4)
+        if (bytes.Length != 4)
             throw new ArgumentException("An IPv4 address always consists of 32 bits (4 bytes)");
-        if(cidr < 0 || cidr > 32)
-            throw new ArgumentOutOfRangeException("cidr", "CIDR must be between 0 and 32 (both inclusive)");
+        if (cidr < 0 || cidr > 32)
+            throw new ArgumentOutOfRangeException(nameof(cidr), "CIDR must be between 0 and 32 (both inclusive)");
         AddressBytes = bytes;
     }
 
-    public IPv4Network(uint value, int cidr) : this(new byte[] { 
+    public IPv4Network(uint value, int cidr) : this([
         (byte)(value >> 24),
         (byte)((value >> 16) & 0xFF),
         (byte)((value >> 8) & 0xFF),
         (byte)(value & 0xFF),
-    }, cidr)
+    ], cidr)
     { }
 
     public IPv4Network(string addressString, int cidr) : this(ParseAddressString(addressString), cidr)
@@ -40,7 +40,7 @@ public IPv4Network(string addressString, int cidr) : this(ParseAddressString(add
 
     public override bool Contains(IPNetwork other)
     {
-        if(other is IPv4Network ip)
+        if (other is IPv4Network ip)
         {
             return ip.GetLowAddressValue() >= GetLowAddressValue()
                    && ip.GetHighAddressValue() <= GetHighAddressValue();
@@ -50,9 +50,9 @@ public override bool Contains(IPNetwork other)
 
     public override bool Overlaps(IPNetwork other)
     {
-        if(other is IPv4Network ip)
+        if (other is IPv4Network ip)
         {
-            return uint.Max(ip.GetLowAddressValue(), GetLowAddressValue()) <= 
+            return uint.Max(ip.GetLowAddressValue(), GetLowAddressValue()) <=
                    uint.Min(ip.GetHighAddressValue(), GetHighAddressValue());
         }
         throw DifferentTypeException();
@@ -62,55 +62,56 @@ public override bool Overlaps(IPNetwork other)
     // https://github.com/python/cpython/blob/8ac20e5404127d68624339c0b318abe2d14fe514/Lib/ipaddress.py#L200
     public override IPNetwork[] SummarizeAddressRangeWith(IPNetwork b)
     {
-        if(b is IPv4Network ip)
+        if (b is IPv4Network ip)
         {
-            if(Cidr != 32 || ip.Cidr != 32)
+            if (Cidr != 32 || ip.Cidr != 32)
                 throw new ArgumentException("Can only construct an address range between two /32 addresses");
             uint first = AddressValue;
             uint last = ip.AddressValue;
-            if(last < first)
+            if (last < first)
                 (first, last) = (last, first);
-            List<IPv4Network> list = new();
-            while(first <= last)
+            List<IPv4Network> list = [];
+            while (first <= last)
             {
                 int nbits = Math.Min(Util.CountRighthandZeroBits32(first), Util.BitLength32(last - first + 1) - 1);
                 list.Add(new IPv4Network(first, 32 - nbits));
                 try
                 {
-                    checked 
+                    checked
                     {
                         first += 1u << nbits;
                     }
-                } catch(OverflowException)
+                }
+                catch (OverflowException)
                 {
                     break;
                 }
             }
-            return list.ToArray();
+            return [.. list];
         }
         throw DifferentTypeException();
     }
-    
+
     public static byte[] ParseAddressString(string addressString)
     {
         string[] parts = addressString.Split('.');
-        if(parts.Length != 4)
+        if (parts.Length != 4)
             throw new FormatException("IPv4 Address must consist of 4 octets.");
-        if(parts.Any(x => !byte.TryParse(x, out _)))
+        if (parts.Any(x => !byte.TryParse(x, out _)))
             throw new FormatException("Invalid IPv4 octet values.");
-        
+
         return parts.Select(x => byte.Parse(x)).ToArray();
     }
 
     public override bool Equals(object? obj)
     {
-        if(obj is IPv4Network ip)
+        if (obj is IPv4Network ip)
             return ip.AddressValue == AddressValue && ip.Cidr == Cidr;
         return false;
     }
 
     public override int GetHashCode()
-    { 
+    {
         return HashCode.Combine(AddressValue, Cidr);
     }
 }