C# 如何按指定的数量增加IP地址？

我试图弄清楚如何递增起始ip地址，并按我指定的偏移量递增它。我尝试过这样做，但我做错了，因为我得到的IP遍布各地，甚至不在同一网络范围内

我目前正在做的是获取起始ip和结束ip，获取地址总量，然后将总ip增加一个偏移量，然后尝试实际增加ip

我通过偏移量增加到总ip，这样我就知道要增加多少ip。（每个偏移量我要完成不同的任务。）无论循环将“t”增加到什么，这就是我增加IP的数量。既然我已经给出了详细情况，我的问题似乎只是实际增加IP，在这种情况下有人能帮我吗。谢谢

            string from = txtStart.Text, to = txtEnd.Text;
            uint current = from.ToUInt(), last = to.ToUInt();

            ulong total = last - current;
            int offset = 3; //This is an example number, it actually could be anything.

            while (current <= last)
            {
             for (int t = 0; t < total; t += offset)
                    {
                        uint ut = Convert.ToUInt32(t);
                        current = current + ut;
                        var ip = current.ToIPAddress();
                    }  
              }

---

IPv4地址基本上是32位整数。因此，您只需解析子字符串，例如，

192.168.0.1

，并将每个字节转换为整数：

uint byte1 = Converter.ToUint32("192");

等等

然后你可以像这样“或”或“添加”它们：

uint IP = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;

string from = "192.168.1.1", to = "192.168.1.255";
uint first = from.ToUInt(), last = to.ToUInt();

ulong total = last - first;
uint offset = 3; //This is an example number, it actually could be anything.

for (uint t = 0; (ulong)t < total; t += 1)
{
    uint ut = Convert.ToUInt32(t);
    uint c = first + t + offset;
    var ip = c.ToIPAddress();
} 

输出

192.168.0.1
198.5.74.129
203.98.149.1
208.191.223.129
214.29.42.1
219.122.116.129
224.215.191.1
230.53.9.129
235.146.84.1
240.239.158.129
246.76.233.1
251.170.51.129

---

在你的周期中，你正在做一些疯狂的增量。第一个增量

t

为

0

，因此ip保持不变。第二个增量

t

是

3

，因此

192.168.1.1

变为

192.168.1.4

（并将其保存为当前值）。第三个增量

t

为

6

，因此

192.168.1.4

变为

192.168.1.10

（并保存为当前）

我认为你想要达到的目标是这样的：

uint IP = (byte1 << 24) | (byte2 << 16) | (byte3 << 8) | byte4;

string from = "192.168.1.1", to = "192.168.1.255";
uint first = from.ToUInt(), last = to.ToUInt();

ulong total = last - first;
uint offset = 3; //This is an example number, it actually could be anything.

for (uint t = 0; (ulong)t < total; t += 1)
{
    uint ut = Convert.ToUInt32(t);
    uint c = first + t + offset;
    var ip = c.ToIPAddress();
} 

string from=“192.168.1.1”，to=“192.168.1.255”；
uint first=from.ToUInt（），last=to.ToUInt（）；
ulong总计=最后一个-第一个；
uint偏移=3//这是一个示例数字，它实际上可以是任何东西。
对于（uint t=0；（ulong）t

Ip可以分解如下

整数值=（4thOctat*2^24.3rd*2^16.2nd*2^8.1st*2^0）

e、 g.64.233.187.99

64*2^24+233*2^16+187*2^8+99 =1089059683

我给你写了一个小例子

    //This is regular expression to check the the ip is in correct format 
    private readonly Regex ip = new Regex(@"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$");

    private void Main()
    {
        string IpAddress = "172.22.1.1";

        if (ip.IsMatch(IpAddress))
        {                
            //increment first octat by 5
            string IncrementedIp = IncrementIP(0, 100, IPAddress.Parse(IpAddress));
            if (ip.IsMatch(IncrementedIp))
            {
                Console.WriteLine("Incremented Ip = {0}", IncrementedIp);
            }
            else
            {
                //not valid ip address}
            }
        }else
        {
            //Not Valid Ip Address
        }

    }

    private string IncrementIP(short octat, long Offset,IPAddress adress)
    {
        //octat range from 0-3
        if ( octat<0 ||octat > 3) return adress.ToString();

        long IpLong = AdressToInt(adress.ToString());
        IpLong += (long)(Offset*(Math.Pow(2,octat*8)));
        return longToAddress(IpLong);
    }
    static long AdressToInt(string addr)
    {
        return (long)(uint)IPAddress.NetworkToHostOrder(
             (int)IPAddress.Parse(addr).Address);
    }

    static string longToAddress(long address)
    {
        return IPAddress.Parse(address.ToString()).ToString();
    }

//这是检查ip格式是否正确的正则表达式
私有只读正则表达式ip=新正则表达式（“（？：25[0-5][0-9][2[0-4][0-9][01]？[0-9][0-9]？）\）{3}（：25[0-5][2[0-4][0-9][01]？[0-9][0-9]）$”；
私有void Main（）
{
字符串IpAddress=“172.22.1.1”；
if（ip.IsMatch（ip地址））
{                
//将第一个八分之一增加5
字符串IncrementedIp=IncrementIP（01000，IPAddress.Parse（IPAddress））；
如果（ip.IsMatch（增量EDIP））
{
WriteLine（“递增的Ip={0}”，递增的EDIP）；
}
其他的
{
//无效的ip地址}
}
}否则
{
//无效的Ip地址
}
}
专用字符串递增IP（短八进制、长偏移量、IP地址）
{
//八进制范围为0-3
if（octat 3）返回地址ToString（）；
long IpLong=地址（adress.ToString（））；
IpLong+=（long）（偏移量*（数学功率（2，八进制*8））；
返回长装载（IpLong）；
}
静态长地址（字符串地址）
{
返回（长）（uint）IPAddress.NetworkToHostOrder(
（int）IPAddress.Parse（addr.Address）；
}
静态字符串longToAddress（长地址）
{
返回IPAddress.Parse（address.ToString（））.ToString（）；
}

以下是一个用于处理IP地址的类，它包括增加IP地址和构建IP范围的功能

public sealed class IPAddressTools
{
    public static UInt32 ConvertIPv4AddressToUInt32(IPAddress address)
    {
        if (address == null) throw new ArgumentNullException("address", "The value of address is a null reference.");
        if (address.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork) throw new ArgumentException("The specified address's family is invalid.", "address");

        Byte[] addressBytes = address.GetAddressBytes();
        UInt32 addressInteger = (((UInt32)addressBytes[0]) << 24) + (((UInt32)addressBytes[1]) << 16) + (((UInt32)addressBytes[2]) << 8) + ((UInt32)addressBytes[3]);
        return addressInteger;
    }
    public static IPAddress ConvertUInt32ToIPv4Address(UInt32 addressInteger)
    {
        if (addressInteger < 0 || addressInteger > 4294967295) throw new ArgumentOutOfRangeException("addressInteger", "The value of addressInteger must be between 0 and 4294967295.");

        Byte[] addressBytes = new Byte[4];
        addressBytes[0] = (Byte)((addressInteger >> 24) & 0xFF);
        addressBytes[1] = (Byte)((addressInteger >> 16) & 0xFF);
        addressBytes[2] = (Byte)((addressInteger >> 8) & 0xFF);
        addressBytes[3] = (Byte)(addressInteger & 0xFF);
        return new IPAddress(addressBytes);
    }
    public static IPAddress IncrementIPAddress(IPAddress address, int offset)
    {
        return ModIPAddress(address, 1);
    }
    public static IPAddress ModIPAddress(IPAddress address, int offset)
    {
        if (address == null) throw new ArgumentNullException("address", "The value of address is a null reference.");
        if (address.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork) throw new ArgumentException("The specified address's family is invalid.");

        UInt32 addressInteger = ConvertIPv4AddressToUInt32(address);
        addressInteger += offset;
        return ConvertUInt32ToIPv4Address(addressInteger);
    }
    public static IPAddress[] GetIpRange(IPAddress address, IPAddress mask)
    {
        if (address == null) throw new ArgumentNullException("address", "The value of address is a null reference.");
        if (mask == null) throw new ArgumentNullException("mask", "The value of mask is a null reference.");
        if (address.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork) throw new ArgumentException("The specified address's family is invalid.");
        if (mask.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork) throw new ArgumentException("The specified mask's family is invalid.");

        byte[] addressBytes = address.GetAddressBytes();
        byte[] maskBytes = mask.GetAddressBytes();
        byte[] startIpBytes = new byte[addressBytes.Length];
        byte[] endIpBytes = new byte[addressBytes.Length];

        for (int i = 0; i < addressBytes.Length; i++)
        {
            startIpBytes[i] = (byte)(addressBytes[i] & maskBytes[i]);
            endIpBytes[i] = (byte)(addressBytes[i] | ~maskBytes[i]);
        }

        IPAddress startIp = new IPAddress(startIpBytes);
        IPAddress endIp = new IPAddress(endIpBytes);

        List<IPAddress> addresses = new List<IPAddress>();

        for (IPAddress currentIp = startIp; ConvertIPv4AddressToUInt32(currentIp) <= ConvertIPv4AddressToUInt32(endIp); currentIp = IncrementIPAddress(currentIp))
        {
            addresses.Add(currentIp);
        }

        return addresses.ToArray();
    }
}

---

他们的答案是正确的。。。用于添加到您的实现中

再次检查：

如果My.Computer.Network.Ping（CheckIPFirst）=False则

'====如果IP地址未被占用，则获取=========

CheckIPFirst+=1

GETIpAddress（计数器）=CheckIPFirst

否则

'=======检查另一个IP地址=============

CheckIPFirst+=1

再次去检查

如果结束

---

通过这种方式，您将不会遇到IP地址冲突或相同的IP地址。

稍微评估一下：您只需将值的数字表示形式从一个基数更改为另一个基数，在本例中，另一个基数为10个基数，这是您的代码、头部和计算机语言常用的基数。在10Base中，您可以轻松地执行算术运算。完成此操作后，可以再次将生成的数字更改回另一个基数，例如原始基数

[TestFixture]
public class GetNextIpAddressTest
{
    [Test]
    public void ShouldGetNextIp()
    {
        Assert.AreEqual("0.0.0.1", GetNextIpAddress("0.0.0.0", 1));
        Assert.AreEqual("0.0.1.0", GetNextIpAddress("0.0.0.255", 1));
        Assert.AreEqual("0.0.0.11", GetNextIpAddress("0.0.0.1", 10));
        Assert.AreEqual("123.14.1.101", GetNextIpAddress("123.14.1.100", 1));
        Assert.AreEqual("0.0.0.0", GetNextIpAddress("255.255.255.255", 1));
    }

    private static string GetNextIpAddress(string ipAddress, uint increment)
    {
        byte[] addressBytes = IPAddress.Parse(ipAddress).GetAddressBytes().Reverse().ToArray();
        uint ipAsUint = BitConverter.ToUInt32(addressBytes, 0);
        var nextAddress = BitConverter.GetBytes(ipAsUint + increment);
        return String.Join(".", nextAddress.Reverse());
    }
}

对于IP地址，基数为256。如前所述，IP地址只是一个由32位组成的数值

• 钻头为双基钻头（工具集：0,1）
• 您的计算以10为基数（0,1,2,3,4,5,6,7,8,9）
• Hexa是16碱基（（0,1,2,3,4,5,6,7,8,9，A，B，C，D，E，F）
• 一个IP地址是256个基数中的（4个）（0,1,2,3,4,5,6,7,8,9，[我们这里应该有另外246个唯一的符号]）。由于我们没有256个唯一的数字符号（无论如何都太多了），为了方便起见，我们使用10个基数来描述它们，例如253（但253应该是符号表中的第254个符号，就像ASCII表中的一样）

有一百万种情况下，您需要更改基数或更改数字空间。例如，增加日期。您可以更改为可管理的日期（自20世纪开始）空格（实际更改并不太简单，但最好的结果是10个基数的表示），执行计算（例如，增加7天），然后更改回YMD空间

---

IP地址255.255.255.255也可以用10基整数值4294967295来描述。

我不得不说这是一个相当奇怪的问题。所以你要做的是“递增”一个IP地址？就像你说的那样，

0.0.0->192.162.0.1->192.168.0.2->255.255.255

而你的问题是递增者

[TestFixture]
public class GetNextIpAddressTest
{
    [Test]
    public void ShouldGetNextIp()
    {
        Assert.AreEqual("0.0.0.1", GetNextIpAddress("0.0.0.0", 1));
        Assert.AreEqual("0.0.1.0", GetNextIpAddress("0.0.0.255", 1));
        Assert.AreEqual("0.0.0.11", GetNextIpAddress("0.0.0.1", 10));
        Assert.AreEqual("123.14.1.101", GetNextIpAddress("123.14.1.100", 1));
        Assert.AreEqual("0.0.0.0", GetNextIpAddress("255.255.255.255", 1));
    }

    private static string GetNextIpAddress(string ipAddress, uint increment)
    {
        byte[] addressBytes = IPAddress.Parse(ipAddress).GetAddressBytes().Reverse().ToArray();
        uint ipAsUint = BitConverter.ToUInt32(addressBytes, 0);
        var nextAddress = BitConverter.GetBytes(ipAsUint + increment);
        return String.Join(".", nextAddress.Reverse());
    }
}