using System;

using System.Diagnostics;

//https://docs.microsoft.com/en-us/archive/blogs/knom/ip-address-calculations-with-c-subnetmasks-networks

public static class SubnetMask

{

    public static readonly System.Net.IPAddress ClassA = System.Net.IPAddress.Parse("255.0.0.0");

    public static readonly System.Net.IPAddress ClassB = System.Net.IPAddress.Parse("255.255.0.0");

    public static readonly System.Net.IPAddress ClassC = System.Net.IPAddress.Parse("255.255.255.0");

​

    public static System.Net.IPAddress CreateByHostBitLength(int hostpartLength)

    {

        int hostPartLength = hostpartLength;

        int netPartLength = 32 - hostPartLength;

​

        if (netPartLength < 2)

            throw new ArgumentException("Number of hosts is to large for IPv4");

​

        Byte[] binaryMask = new byte[4];

​

        for (int i = 0; i < 4; i++)

        {

            if (i * 8 + 8 <= netPartLength)

                binaryMask[i] = (byte)255;

            else if (i * 8 > netPartLength)

                binaryMask[i] = (byte)0;

            else

            {

                int oneLength = netPartLength - i * 8;

                string binaryDigit =

                    String.Empty.PadLeft(oneLength, '1').PadRight(8, '0');

                binaryMask[i] = Convert.ToByte(binaryDigit, 2);

            }

        }

        return new System.Net.IPAddress(binaryMask);

    }

​

    public static System.Net.IPAddress CreateByNetBitLength(int netpartLength)

    {

        int hostPartLength = 32 - netpartLength;

        return CreateByHostBitLength(hostPartLength);

    }

​

    public static System.Net.IPAddress CreateByHostNumber(int numberOfHosts)

    {

        int maxNumber = numberOfHosts + 1;

​

        string b = Convert.ToString(maxNumber, 2);

​

        return CreateByHostBitLength(b.Length);

    }

}

public static class Extensions

{

    /// <summary>

    /// Fastest way to to find 1st number in a string and convert it into an absolute integer

    /// </summary>

    /// <param name="intStr"></param>

    /// <returns></returns>

    //  https://metadataconsulting.blogspot.com/2020/06/CSharp-Fastest-way-to-find-a-number-or-integer-in-a-string.html

    public static int GetFirstAbsIntFast(this string intStr)

    {

​

        int sum = int.MinValue; //any error val -9999

        char[] n = intStr.ToCharArray(); //fastest way to index a string

        //int idxFirstDigit = -1;

​

        for (int i = 0; i < n.Length; i++)

        {

            if (n[i] >= 48 && n[i] <= 57)  //'0'=48 and '9'=57 get lead number only

            {

                //if (idxFirstDigit == -1) idxFirstDigit = i;

                int z = sum * 10 + (n[i] - 48);

                if (z < 0) //we get into negative, if over int.MaxValue

                    return sum; //we have negative number, it's an error or throw error

                sum = z;

            }

            else //if (idxFirstDigit > -1)

                break;

            //return int.MinValue; //or throw error

        }

​

        //if (intStr.IndexOf('-') == idxFirstDigit - 1) //chek for neg sign

        //    sum *= -1;

​

        return sum;

​

    }

    public static string GetIPv4NetworkMaskByPrefix(this string subnet)

    {

        //CIDR IP format accepted  xxx.xxx.xxx.xxx/1-32

        int idxForwardSlash = subnet.IndexOf('/');

        if (string.IsNullOrEmpty(subnet) && idxForwardSlash > -1)

            return string.Empty;

​

        string CIDRIP = subnet.Substring(idxForwardSlash+1);

​

        int numCIDRIP = 0;

        numCIDRIP = CIDRIP.GetFirstAbsIntFast();

        if (numCIDRIP < 1 || numCIDRIP > 32) return string.Empty; // /1-32 range accepted for ip4

​

        int calSubNet = 0;

        calSubNet = numCIDRIP;

​

        switch (calSubNet)

        {

            case 1: return "128.0.0.0"; //2,147,483,646

            case 2: return "192.0.0.0"; //1,073,741,822

            case 3: return "224.0.0.0"; //536,870,910

            case 4: return "240.0.0.0"; //268,435,454

            case 5: return "248.0.0.0"; //134,217,726

            case 6: return "252.0.0.0"; //67,108,862

            case 7: return "254.0.0.0"; //33,554,430

            case 8: return "255.0.0.0";

            case 9: return "255.128.0.0";

            case 10: return "255.192.0.0";

            case 11: return "255.224.0.0";

            case 12: return "255.240.0.0";

            case 13: return "255.248.0.0";

            case 14: return "255.252.0.0";

            case 15: return "255.254.0.0";

            case 16: return "255.255.0.0";

            case 17: return "255.255.128.0";

            case 18: return "255.255.192.0";

            case 19: return "255.255.224.0";

            case 20: return "255.255.240.0";

            case 21: return "255.255.248.0";

            case 22: return "255.255.252.0";

            case 23: return "255.255.254.0";

            case 24: return "255.255.255.0";  //254

            case 25: return "255.255.255.128";

            case 26: return "255.255.255.192";

            case 27: return "255.255.255.224";

            case 28: return "255.255.255.240";

            case 29: return "255.255.255.248";

            case 30: return "255.255.255.252";

            case 31: return "255.255.255.254"; 

            case 32: return "255.255.255.255";

            default: return "";

        }

    }

​

    //https://www.ipaddressguide.com/netmask

    //A CIDR IP address looks like a normal IP address except that it ends with a slash followed by a number, called the IP network prefix.

    //10.0.0.0/24 -> Netmask = 255.255.255.0

    public static string GetIPv4SubnetMask(this string subnet)

    {

        //CIDR IP format accepts -> {xxx.xxx.xxx.xxx}/[1-32]

        int idxForwardSlash = subnet.IndexOf('/');

        if (string.IsNullOrEmpty(subnet) && idxForwardSlash > -1)

            return string.Empty;

​

        string CIDRIP = subnet.Substring(idxForwardSlash+1);

​

        int numCIDRIP = 0;

        numCIDRIP = CIDRIP.GetFirstAbsIntFast();

        if (numCIDRIP < 1 || numCIDRIP > 32) return string.Empty; // /1-32 range accepted for ip4

​

        int calSubNet = 0;

        calSubNet = 32 - numCIDRIP;

​

        // https://weblogs.asp.net/razan/finding-subnet-mask-from-ip4-address-using-c

        long mask = (0xffffffffL << calSubNet & 0xffffffffL);

        mask = System.Net.IPAddress.HostToNetworkOrder((int)mask);

        return new System.Net.IPAddress((UInt32)mask).ToString();

    }

​

        public static string getSubnetAddressFromIPv4NetMask(this string netMask)

        {

            //CIDR IP format accepted  xxx.xxx.xxx.xxx/1-32

            int idxForwardSlash = netMask.IndexOf('/');

            if (string.IsNullOrEmpty(netMask) && idxForwardSlash > -1)

                return string.Empty;

​

            string CIDRIP = netMask.Substring(idxForwardSlash + 1);

​

            int numCIDRIP = 0;

            numCIDRIP = CIDRIP.GetFirstAbsIntFast();

            if (numCIDRIP < 1 || numCIDRIP > 32) return string.Empty; // /1-32 range accepted for ip4

​

            //long bit = 1;

            //bit <<= pow; //now this bitwise shift works

            int calSubNet = 0;

            calSubNet = 32 - numCIDRIP;

​

            string subNetMask = string.Empty;

​

            double result = 0;

​

            if (calSubNet >= 0 && calSubNet <= 8)

            {

                for (int ipower = 0; ipower < calSubNet; ipower++)

                {

                    long bit = 1;

                    bit <<= ipower; //now this bitwise shift works

                    result += bit; 

                    //result += Math.Pow(2, ipower);

                }

                double finalSubnet = 255 - result;

                subNetMask = "255.255.255." + Convert.ToString(finalSubnet);

            }

            else if (calSubNet > 8 && calSubNet <= 16)

            {

                int secOctet = 16 - calSubNet;

​

                secOctet = 8 - secOctet;

​

                for (int ipower = 0; ipower < secOctet; ipower++)

                {

                    long bit = 1;

                    bit <<= ipower; //now this bitwise shift works

                    result += bit;

                    //result += Math.Pow(2, ipower);

                }

                double finalSubnet = 255 - result;

                subNetMask = "255.255." + Convert.ToString(finalSubnet) + ".0";

            }

            else if (calSubNet > 16 && calSubNet <= 24)

            {

                int thirdOctet = 24 - calSubNet;

​

                thirdOctet = 8 - thirdOctet;

​

                for (int ipower = 0; ipower < thirdOctet; ipower++)

                {

                    long bit = 1;

                    bit <<= ipower; //now this bitwise shift works

                    result += bit;

                    //result += Math.Pow(2, ipower);

                }

                double finalSubnet = 255 - result;

                subNetMask = "255." + Convert.ToString(finalSubnet) + ".0.0";

            }

            else if (calSubNet > 24 && calSubNet <= 32)

            {

                int fourthOctet = 32 - calSubNet;

​

                fourthOctet = 8 - fourthOctet;

​

                for (int ipower = 0; ipower < fourthOctet; ipower++)

                {

                    long bit = 1;

                    bit <<= ipower; //now this bitwise shift works

                    result += bit;

                    //result += Math.Pow(2, ipower);

                }

                double finalSubnet = 255 - result;

                subNetMask = Convert.ToString(finalSubnet) + ".0.0.0";

            }

​

            return subNetMask;

        }

​

    public static System.Net.IPAddress CreateBySubNetBitLength(this string netMask)

    {

        //CIDR IP format accepted  xxx.xxx.xxx.xxx/1-32

        int idxForwardSlash = netMask.IndexOf('/');

        if (string.IsNullOrEmpty(netMask) && idxForwardSlash > -1)

            return System.Net.IPAddress.None;

​

        string CIDRIP = netMask.Substring(idxForwardSlash + 1);

​

        int numCIDRIP = 0;

        numCIDRIP = CIDRIP.GetFirstAbsIntFast();

        if (numCIDRIP < 1 || numCIDRIP > 32) return System.Net.IPAddress.None; // /1-32 range accepted for ip4

​

        int calSubNet = 32 - numCIDRIP;

​

        return SubnetMask.CreateByNetBitLength(calSubNet);

​

    }

​

​

}

public class Program

{

    public static void Main()

    { 

            //https://www.calculator.net/ip-subnet-calculator.html dup this functionality partially

            string subnetprefix = "/25"; 

            Stopwatch sw = new Stopwatch(); 

            sw.Start(); 

            Console.WriteLine("Using getSubnetAddressFromIPNetMask");

            Console.WriteLine(subnetprefix.getSubnetAddressFromIPv4NetMask());

            sw.Stop();

            Console.WriteLine(sw.ElapsedTicks.ToString("#,0") + " ticks");

            sw.Reset();

            sw.Start(); 

            Console.WriteLine("Using compact GetSubnetMask");

            Console.WriteLine(subnetprefix.GetIPv4SubnetMask());

            sw.Stop();

            Console.WriteLine(sw.ElapsedTicks.ToString("#,0") + " ticks");

            sw.Reset();

            sw.Start(); 

            Console.WriteLine("Using compact getNetworkMaskByPrefix");

            Console.WriteLine(subnetprefix.GetIPv4NetworkMaskByPrefix());

            sw.Stop();

            Console.WriteLine(sw.ElapsedTicks.ToString("#,0") + " ticks");

            //https://docs.microsoft.com/en-us/archive/blogs/knom/ip-address-calculations-with-c-subnetmasks-networks

            Console.WriteLine("Using Microsoft's recommended imp - CreateBySubNetBitLength");

            Console.WriteLine(subnetprefix.GetIPv4NetworkMaskByPrefix());

            sw.Stop();

            Console.WriteLine(sw.ElapsedTicks.ToString("#,0") + " ticks");

    }

}