Extending the IPAddress object to allow relative comparisons of two IP addresses

/// <summary>
    /// Extend IP addresses for comparisons
    /// </summary>
    /// Source : http://www.codeproject.com/Articles/26550/Extending-the-IPAddress-object-to-allow-relative-c
    public class ExtendedIPAddress : System.Net.IPAddress
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ExtendedIPAddress"/> class.
        /// </summary>
        /// <param name="address">Valeur du tableau d'octets de l'adresse IP.</param>
        public ExtendedIPAddress(byte[] address)
            : base(address)
        {
            // must override this constructor to enable build //    
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExtendedIPAddress"/> class.
        /// </summary>
        /// <param name="address">The address.</param>
        public ExtendedIPAddress(Int64 address)
            : base(address)
        {
            // must override this constructor to enable build / compatibility with base class constructors
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExtendedIPAddress"/> class.
        /// </summary>
        /// <param name="address">Valeur du tableau d'octets de l'adresse IP.</param>
        /// <param name="scopeid">Valeur de type Long de l'identificateur de portée.</param>
        public ExtendedIPAddress(byte[] address, Int64 scopeid)
            : base(address, scopeid)
        {
            // must override this constructor to enable build / compatibility with base class constructors
        }

        /// <summary>
        /// Determines the relative value of adddress1 to address2.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns>
        /// -1 indicates address1 is less than address2. 1 indicates address1 is greater than address2. 0 indicates both are equal. -2 indicates addresses are incompatible for comparison.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">value;Cannot compare two addresses no in the same Address Family.</exception>
        public int CompareTo(ExtendedIPAddress value)
        {
            if (value == null) throw new ArgumentNullException("value");

            int returnVal = 0;
            if (this.AddressFamily == value.AddressFamily)
            {
                byte[] b1 = this.GetAddressBytes();
                byte[] b2 = value.GetAddressBytes();

                for (int i = 0; i < b1.Length; i++)
                {
                    if (b1[i] < b2[i])
                    {
                        returnVal = -1;
                        break;
                    }
                    else if (b1[i] > b2[i])
                    {
                        returnVal = 1;
                        break;
                    }
                }
            }
            else
            {
                string buffer = String.Format(CultureInfo.InvariantCulture, "The type {0} and the compare type {1} are not compatible ip address families.", this.AddressFamily.ToString(), value.AddressFamily.ToString());
                throw new ArgumentOutOfRangeException("value", buffer);
            }

            return returnVal;
        }

        /// <summary>
        /// Determines whether the specified <see cref="System.Object" />, is equal to this instance.
        /// </summary>
        /// <param name="comparand">The <see cref="System.Object" /> to compare with this instance.</param>
        /// <returns>
        ///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
        /// </returns>
        public override bool Equals(object comparand)
        {
            bool result = false;

            // If parameter is null return false.
            if (comparand == null)
            {
                result = false;
            }
            else
            {
                ExtendedIPAddress second = comparand as ExtendedIPAddress;
                if (second != null)
                {
                    return this == second;
                }
            }
            return result;
        }

        /// <summary>
        /// Returns a hash code for this instance.
        /// </summary>
        /// <returns>
        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
        /// </returns>
        /// <PermissionSet>
        ///   <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" />
        /// </PermissionSet>
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        /// <summary>
        /// Implements the operator ==.
        /// </summary>
        /// <param name="first">The first IP address.</param>
        /// <param name="second">The second IP address.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">rangeStartAddress</exception>
        public static bool operator ==(ExtendedIPAddress first, ExtendedIPAddress second)
        {
            // If both are null, or both are same instance, return true.
            if (System.Object.ReferenceEquals(first, second))
            {
                return true;
            }

            // If one is null, but not both, return false.
            if (((object)first == null) || ((object)second == null))
            {
                return false;
            }

            if (first.AddressFamily != second.AddressFamily)
            {
                //string buffer = String.Format(CultureInfo.InvariantCulture, "The Start Range type {0} and End Range type {1} are not compatible ip address families.", first.AddressFamily.ToString(), second.AddressFamily.ToString());
                return false;
            }

            if (first.CompareTo (second) == 0 ) 
                return true;
            return false;
        }

        /// <summary>
        /// Implements the operator !=.
        /// </summary>
        /// <param name="first">The first IP address.</param>
        /// <param name="second">The second IP address.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">rangeStartAddress</exception>
        public static bool operator !=(ExtendedIPAddress first, ExtendedIPAddress second)
        {
            if (first == second)
                return false;
            return true;
        }

        /// <summary>
        /// Implements the operator <=.
        /// </summary>
        /// <param name="first">The first IP address.</param>
        /// <param name="second">The second IP address.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">rangeStartAddress</exception>
        public static bool operator <=(ExtendedIPAddress first, ExtendedIPAddress second)
        {
            if ((first == null) && (second == null))    return true;
            if (first == null)                          return true;
            if (second == null)                         return false;

            if (first.AddressFamily != second.AddressFamily)
            {
                //string buffer = String.Format(CultureInfo.InvariantCulture, "The Start Range type {0} and End Range type {1} are not compatible ip address families.", first.AddressFamily.ToString(), second.AddressFamily.ToString());
                return false;
            }

            if (first == second)
                return true;
            if (first.CompareTo(second) < 0)
                return true;
            return false;
        }

        /// <summary>
        /// Implements the operator <.
        /// </summary>
        /// <param name="first">The first IP address.</param>
        /// <param name="second">The second IP address.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">rangeStartAddress</exception>
        public static bool operator <(ExtendedIPAddress first, ExtendedIPAddress second)
        {
            if ((first == null) && (second == null))    return false;
            if (first == null)                          return true;
            if (second == null)                         return false;

            if (first.AddressFamily != second.AddressFamily)
            {
                //string buffer = String.Format(CultureInfo.InvariantCulture, "The Start Range type {0} and End Range type {1} are not compatible ip address families.", first.AddressFamily.ToString(), second.AddressFamily.ToString());
                return false;
            }

            if (first == second)
                return false;
            if (first.CompareTo(second) < 0)
                return true;
            return false;
        }

        /// <summary>
        /// Implements the operator >=.
        /// </summary>
        /// <param name="first">The first IP address.</param>
        /// <param name="second">The second IP address.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">rangeStartAddress</exception>
        public static bool operator >=(ExtendedIPAddress first, ExtendedIPAddress second)
        {
            if ((first == null) && (second == null))    return true;
            if (first == null)                          return false;
            if (second == null)                         return true;

            if (first.AddressFamily != second.AddressFamily)
            {
                //string buffer = String.Format(CultureInfo.InvariantCulture, "The Start Range type {0} and End Range type {1} are not compatible ip address families.", first.AddressFamily.ToString(), second.AddressFamily.ToString());
                return false;
            }

            if (first == second)
                return true;
            if (first.CompareTo(second) > 0)
                return true;
            return false;
        }

        /// <summary>
        /// Implements the operator >.
        /// </summary>
        /// <param name="first">The first IP address.</param>
        /// <param name="second">The second IP address.</param>
        /// <returns>
        /// The result of the operator.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">rangeStartAddress</exception>
        public static bool operator >(ExtendedIPAddress first, ExtendedIPAddress second)
        {
            if ((first == null) && (second == null))    return false;
            if (first == null)                          return false;
            if (second == null)                         return true;

            if (first.AddressFamily != second.AddressFamily)
            {
                //string buffer = String.Format(CultureInfo.InvariantCulture, "The Start Range type {0} and End Range type {1} are not compatible ip address families.", first.AddressFamily.ToString(), second.AddressFamily.ToString());
                return false;
            }

            if (first == second)
                return false;
            if (first.CompareTo(second) > 0)
                return true;
            return false;
        }

        /// <summary>
        /// Determines if the current IP Address is in the given range.
        /// </summary>
        /// <param name="rangeStartAddress">The beginning of the range.</param>
        /// <param name="rangeEndAddress">The end of the range.</param>
        /// <returns>
        /// True if the IP Address is within the passed range.
        /// </returns>
        /// <exception cref="System.ArgumentOutOfRangeException">
        /// rangeStartAddress
        /// or
        /// rangeStartAddress
        /// </exception>
        public bool IsInRange(ExtendedIPAddress rangeStartAddress, ExtendedIPAddress rangeEndAddress)
        {
            if (rangeStartAddress == null) throw new ArgumentNullException("rangeStartAddress");
            if (rangeEndAddress == null) throw new ArgumentNullException("rangeEndAddress");

            bool returnVal = false;
            // ensure that all addresses are of the same type otherwise reject //
            if (rangeStartAddress.AddressFamily != rangeEndAddress.AddressFamily)
            {
                throw new ArgumentOutOfRangeException("rangeStartAddress", String.Format(CultureInfo.InvariantCulture, "The Start Range type {0} and End Range type {1} are not compatible ip address families.", rangeStartAddress.AddressFamily.ToString(), rangeEndAddress.AddressFamily.ToString()));
            }

            if (rangeStartAddress.AddressFamily == this.AddressFamily)
            {
                returnVal = (CompareTo(rangeStartAddress) >= 0 && CompareTo(rangeEndAddress) <= 0);   // no need to check for -2 value as this check has already been undertaken to get into this block //
            }
            else
            {
                throw new ArgumentOutOfRangeException("rangeStartAddress", String.Format(CultureInfo.InvariantCulture, "The range type {0} and current value type {1} are not compatible ip address families", rangeStartAddress.AddressFamily.ToString(), this.AddressFamily.ToString()));
            }

            return returnVal;
        }

        /// <summary>
        /// Gets the local addresses.
        /// </summary>
        /// <returns></returns>
        public static ExtendedIPAddress[] GetLocalAddresses()
        {
            string hostName = System.Net.Dns.GetHostName();
            System.Net.IPHostEntry entry = System.Net.Dns.GetHostEntry(hostName);
            List<ExtendedIPAddress> list = new List<ExtendedIPAddress>();
            foreach (System.Net.IPAddress address in entry.AddressList)
            {
                list.Add(new ExtendedIPAddress(address.GetAddressBytes()));
            }
            return list.ToArray();
        }

        /// <summary>
        /// Determines whether [is local address in range] [the specified range start address].
        /// </summary>
        /// <param name="rangeStartAddress">The range start address.</param>
        /// <param name="rangeEndAddress">The range end address.</param>
        /// <returns></returns>
        public static bool IsLocalAddressInRange(ExtendedIPAddress rangeStartAddress, ExtendedIPAddress rangeEndAddress)
        {
            bool returnVal = false;
            foreach (ExtendedIPAddress address in GetLocalAddresses())
            {
                if (address.IsInRange(rangeStartAddress,rangeEndAddress))
                {
                    returnVal = true;
                    break;
                }
            }
            return returnVal;
        }

        /// <summary>
        /// Parses the specified IP string.
        /// </summary>
        /// <param name="ipAddress">The IP address string to parse.</param>
        /// <returns>An extended IP class.</returns>
        new public static ExtendedIPAddress Parse(string ipAddress)
        {
            ExtendedIPAddress result = null;
            IPAddress result2 = IPAddress.Parse(ipAddress);
            if (result2 != null)
            {
                result = new ExtendedIPAddress(result2.GetAddressBytes ());
            }

            return result;
        }
    }

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Nolme.Network4;

namespace UnitTestProjectCmdLineTools4
{
    [TestClass]
    public class Network
    {
        ExtendedIPAddress heserverStart;
        ExtendedIPAddress heserverStart2;
        ExtendedIPAddress heserver;
        ExtendedIPAddress heserverEnd;

        /// <summary>
        /// Initializes the test class.
        /// </summary>
        /// <param name="start">The start IP.</param>
        /// <param name="end">The end IP.</param>
        /// <param name="current">The current IP.</param>
        private void Init (string start, string end, string current)
        {
            heserverStart = ExtendedIPAddress.Parse(start);
            heserverStart2 = ExtendedIPAddress.Parse(start);
            heserver = ExtendedIPAddress.Parse(current);
            heserverEnd = ExtendedIPAddress.Parse(end);
        }

        [TestMethod]
        public void NetworkEqualityComparisonIpv4()
        {
            // arrange
            Init("172.18.0.0", "172.32.255.255", "172.20.21.1");

            // act 
            bool test1 = heserverStart == heserverStart2;
            bool test2 = heserverStart == heserverEnd;
            bool test3 = heserverStart.Equals(heserverStart2);

            // assert
            Assert.AreEqual(test1, true);
            Assert.AreEqual(test2, false);
            Assert.AreEqual(test3, true);
        }

        [TestMethod]
        public void NetworkDifferenceComparisonIpv4()
        {
            // arrange
            Init("172.18.0.0", "172.32.255.255", "172.20.21.1");

            // act 
            bool test1 = heserverStart != heserverEnd;
            bool test2 = heserverStart != heserverStart2;

            // assert
            Assert.AreEqual(test1, true);
            Assert.AreEqual(test2, false);
        }

        [TestMethod]
        public void NetworkComparisonIpv4()
        {
            // arrange
            Init("172.18.0.0", "172.32.255.255", "172.20.21.1");

            // act 
            bool test1 = heserverStart <= heserverStart2;
            bool test2 = heserverStart < heserverEnd;
            bool test3 = heserverEnd >= heserverStart;
            bool test4 = heserverEnd > heserverStart;

            // assert
            Assert.AreEqual(test1, true);
            Assert.AreEqual(test2, true);
            Assert.AreEqual(test3, true);
            Assert.AreEqual(test4, true);
        }

        [TestMethod]
        public void NetworkEqualityComparisonIpv6()
        {
            // arrange
            Init("2001:0db8:0000:85a3:0000:0000:ac1f:8000", "2001:0db8:0000:85a3:0000:0000:ac1f:9001", "2001:0db8:0000:85a3:0000:0000:ac1f:8001");

            // act 
            bool test1 = heserverStart == heserverStart2;
            bool test2 = heserverStart == heserverEnd;
            bool test3 = heserverStart.Equals(heserverStart2);

            // assert
            Assert.AreEqual(test1, true);
            Assert.AreEqual(test2, false);
            Assert.AreEqual(test3, true);
        }

        [TestMethod]
        public void NetworkDifferenceComparisonIpv6()
        {
            // arrange
            Init("2001:0db8:0000:85a3:0000:0000:ac1f:8000", "2001:0db8:0000:85a3:0000:0000:ac1f:9001", "2001:0db8:0000:85a3:0000:0000:ac1f:8001");

            // act 
            bool test1 = heserverStart != heserverEnd;
            bool test2 = heserverStart != heserverStart2;

            // assert
            Assert.AreEqual(test1, true);
            Assert.AreEqual(test2, false);
        }

        [TestMethod]
        public void NetworkComparisonIpv6()
        {
            // arrange
            Init("2001:0db8:0000:85a3:0000:0000:ac1f:8000", "2001:0db8:0000:85a3:0000:0000:ac1f:9001", "2001:0db8:0000:85a3:0000:0000:ac1f:8001");

            // act 
            bool test1 = heserverStart <= heserverStart2;
            bool test2 = heserverStart < heserverEnd;
            bool test3 = heserverEnd >= heserverStart;
            bool test4 = heserverEnd > heserverStart;

            // assert
            Assert.AreEqual(test1, true);
            Assert.AreEqual(test2, true);
            Assert.AreEqual(test3, true);
            Assert.AreEqual(test4, true);
        }
    }
}

public ComparableIPAddress(string addressToParse)
      : base(GetBytes(addressToParse))
    {
      // base class does not have a default() or (string) constructor
    }

    private static byte[] GetBytes(string addressToParse)
    {
      IPAddress address;
      byte[] bytes = null;

      if (IPAddress.TryParse(addressToParse, out address))
      {
        bytes = address.GetAddressBytes();
      }

      return bytes;
    }

public ComparableIPAddress(string addressToParse)
      : base(GetBytes(addressToParse))
    {
      // base class does not have a default() or (string) constructor
    }

    private static byte[] GetBytes(string addressToParse)
    {
      IPAddress address;
      byte[] bytes = null;

      if (IPAddress.TryParse(addressToParse, out address))
      {
        bytes = address.GetAddressBytes();
      }

      return bytes;
    }

static public int CompareIPAddresses(IPAddress first, IPAddress second)
{
    if ((null == first) && (null == second)) return 0;
    if ((null == first) && (null != second)) return -1;
    if ((null != first) && (null == second)) return 1;
    byte[] bytesFirst = first.GetAddressBytes();
    byte[] bytesSecond = second.GetAddressBytes();
    if (bytesFirst.Length < bytesSecond.Length) return -1;
    if (bytesFirst.Length > bytesSecond.Length) return 1;
    for(int i=0; i<bytesFirst.Length; ++i)
        if (bytesFirst[i] != bytesSecond[i])
            return bytesFirst[i] - bytesSecond[i];
    return 0;
}

public int Compare(this IPAddress first, IPAddress second)
{
    // ... same code body as above.
}