113

我正在寻找将标准 IPv4 地址转换为整数的函数。可用于相反的功能的奖励积分。

解决方案应该在 C# 中。

4

22 回答 22

153

32 位无符号整数是IPv4 地址。同时，该IPAddress.Address属性虽然已被弃用，但它是一个 Int64，它返回 IPv4 地址的无符号 32 位值（问题是，它按网络字节顺序排列，因此您需要交换它）。

例如，我的本地 google.com 位于64.233.187.99. 这相当于：

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

确实，http://1089059683/按预期工作（至少在 Windows 中，用 IE、Firefox 和 Chrome 测试；但在 iPhone 上不起作用）。

这是一个显示两种转换的测试程序，包括网络/主机字节交换：

using System;
using System.Net;

class App
{
    static long ToInt(string addr)
    {
        // careful of sign extension: convert to uint first;
        // unsigned NetworkToHostOrder ought to be provided.
        return (long) (uint) IPAddress.NetworkToHostOrder(
             (int) IPAddress.Parse(addr).Address);
    }

    static string ToAddr(long address)
    {
        return IPAddress.Parse(address.ToString()).ToString();
        // This also works:
        // return new IPAddress((uint) IPAddress.HostToNetworkOrder(
        //    (int) address)).ToString();
    }

    static void Main()
    {
        Console.WriteLine(ToInt("64.233.187.99"));
        Console.WriteLine(ToAddr(1089059683));
    }
}
于 2009-01-20T15:30:52.627 回答
49

这是一对从 IPv4 转换为正确整数并返回的方法：

public static uint ConvertFromIpAddressToInteger(string ipAddress)
{
    var address = IPAddress.Parse(ipAddress);
    byte[] bytes = address.GetAddressBytes();

    // flip big-endian(network order) to little-endian
    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(bytes);
    }

    return BitConverter.ToUInt32(bytes, 0);
}

public static string ConvertFromIntegerToIpAddress(uint ipAddress)
{
    byte[] bytes = BitConverter.GetBytes(ipAddress);

    // flip little-endian to big-endian(network order)
    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(bytes);
    }

    return new IPAddress(bytes).ToString();
}

例子

ConvertFromIpAddressToInteger("255.255.255.254"); // 4294967294
ConvertFromIntegerToIpAddress(4294967294); // 255.255.255.254

解释

IP 地址按网络顺序（大端），而ints 在 Windows 上是小端，因此要获得正确的值，您必须在小端系统上转换之前反转字节。

此外，即使对于IPv4， anint也不能保存大于127.255.255.255的地址，例如广播地址(255.255.255.255)，所以使用 a uint。

于 2012-11-12T19:49:21.440 回答
42

@Barry Kelly 和@Andrew Hare，实际上，我认为乘法并不是最明确的方法（完全正确）。

一个 Int32 “格式化”的 IP 地址可以看成如下结构

[StructLayout(LayoutKind.Sequential, Pack = 1)] 
struct IPv4Address
{
   public Byte A;
   public Byte B;
   public Byte C;
   public Byte D;
} 
// to actually cast it from or to an int32 I think you 
// need to reverse the fields due to little endian

所以要转换 IP 地址 64.233.187.99 你可以这样做：

(64  = 0x40) << 24 == 0x40000000
(233 = 0xE9) << 16 == 0x00E90000
(187 = 0xBB) << 8  == 0x0000BB00
(99  = 0x63)       == 0x00000063
                      ---------- =|
                      0x40E9BB63

所以你可以使用 + 将它们相加，或者你可以二进制或它们一起。导致 0x40E9BB63 即 1089059683。（在我看来，以十六进制查看更容易查看字节）

所以你可以把函数写成：

int ipToInt(int first, int second, 
    int third, int fourth)
{
    return (first << 24) | (second << 16) | (third << 8) | (fourth);
}
于 2009-01-21T08:41:30.843 回答
12

试试这个：

private int IpToInt32(string ipAddress)
{
   return BitConverter.ToInt32(IPAddress.Parse(ipAddress).GetAddressBytes().Reverse().ToArray(), 0);
}

private string Int32ToIp(int ipAddress)
{
   return new IPAddress(BitConverter.GetBytes(ipAddress).Reverse().ToArray()).ToString();
}
于 2009-05-28T14:55:53.927 回答
8

当面对具有非常大值的 IP 地址时，我在所描述的解决方案中遇到了一些问题。结果是，byte[0] * 16777216 的东西会溢出并变成负 int 值。为我解决的问题是简单的类型转换操作。

public static long ConvertIPToLong(string ipAddress)
{
    System.Net.IPAddress ip;

    if (System.Net.IPAddress.TryParse(ipAddress, out ip))
    {
        byte[] bytes = ip.GetAddressBytes();

        return
            16777216L * bytes[0] +
            65536 * bytes[1] +
            256 * bytes[2] +
            bytes[3]
            ;
    }
    else
        return 0;
}
于 2010-11-08T20:13:47.047 回答
8

由于没有人发布使用BitConverter并实际检查字节顺序的代码，这里是：

byte[] ip = address.Split('.').Select(s => Byte.Parse(s)).ToArray();
if (BitConverter.IsLittleEndian) {
  Array.Reverse(ip);
}
int num = BitConverter.ToInt32(ip, 0);

然后回来：

byte[] ip = BitConverter.GetBytes(num);
if (BitConverter.IsLittleEndian) {
  Array.Reverse(ip);
}
string address = String.Join(".", ip.Select(n => n.ToString()));
于 2013-11-01T13:52:45.490 回答
4

戴维兰德曼函数的反转

string IntToIp(int d)
{
  int v1 = d & 0xff;
  int v2 = (d >> 8) & 0xff;
  int v3 = (d >> 16) & 0xff;
  int v4 = (d >> 24);
  return v4 + "." + v3 + "." + v2 + "." + v1;
}
于 2013-12-21T18:46:48.020 回答
3

我的问题被关闭了，我不知道为什么。这里接受的答案与我需要的不同。

这为我提供了 IP 的正确整数值..

public double IPAddressToNumber(string IPaddress)
{
    int i;
    string [] arrDec;
    double num = 0;
    if (IPaddress == "")
    {
        return 0;
    }
    else
    {
        arrDec = IPaddress.Split('.');
        for(i = arrDec.Length - 1; i >= 0 ; i = i -1)
            {
                num += ((int.Parse(arrDec[i])%256) * Math.Pow(256 ,(3 - i )));
            }
        return num;
    }
}
于 2009-01-22T09:18:08.307 回答
3

使用正确的小端格式的 UInt32，这里有两个简单的转换函数：

public uint GetIpAsUInt32(string ipString)
{
    IPAddress address = IPAddress.Parse(ipString);

    byte[] ipBytes = address.GetAddressBytes();

    Array.Reverse(ipBytes);

    return BitConverter.ToUInt32(ipBytes, 0);
}

public string GetIpAsString(uint ipVal)
{
    byte[] ipBytes = BitConverter.GetBytes(ipVal);

    Array.Reverse(ipBytes);

    return new IPAddress(ipBytes).ToString();
}
于 2013-01-17T21:01:03.983 回答
3

将上述几个答案组装成一个扩展方法，该方法处理机器的字节序并处理映射到 IPv6 的 IPv4 地址。

public static class IPAddressExtensions
{
    /// <summary>
    /// Converts IPv4 and IPv4 mapped to IPv6 addresses to an unsigned integer.
    /// </summary>
    /// <param name="address">The address to conver</param>
    /// <returns>An unsigned integer that represents an IPv4 address.</returns>
    public static uint ToUint(this IPAddress address)
    {
        if (address.AddressFamily == AddressFamily.InterNetwork || address.IsIPv4MappedToIPv6)
        {
            var bytes = address.GetAddressBytes();
            if (BitConverter.IsLittleEndian)
                Array.Reverse(bytes);

            return BitConverter.ToUInt32(bytes, 0);
        }
        throw new ArgumentOutOfRangeException("address", "Address must be IPv4 or IPv4 mapped to IPv6");
    }
}

单元测试：

[TestClass]
public class IPAddressExtensionsTests
{
    [TestMethod]
    public void SimpleIp1()
    {
        var ip = IPAddress.Parse("0.0.0.15");
        uint expected = GetExpected(0, 0, 0, 15);
        Assert.AreEqual(expected, ip.ToUint());
    }
    [TestMethod]
    public void SimpleIp2()
    {
        var ip = IPAddress.Parse("0.0.1.15");
        uint expected = GetExpected(0, 0, 1, 15);
        Assert.AreEqual(expected, ip.ToUint());
    }
    [TestMethod]
    public void SimpleIpSix1()
    {
        var ip = IPAddress.Parse("0.0.0.15").MapToIPv6();
        uint expected = GetExpected(0, 0, 0, 15);
        Assert.AreEqual(expected, ip.ToUint());
    }
    [TestMethod]
    public void SimpleIpSix2()
    {
        var ip = IPAddress.Parse("0.0.1.15").MapToIPv6();
        uint expected = GetExpected(0, 0, 1, 15);
        Assert.AreEqual(expected, ip.ToUint());
    }
    [TestMethod]
    public void HighBits()
    {
        var ip = IPAddress.Parse("200.12.1.15").MapToIPv6();
        uint expected = GetExpected(200, 12, 1, 15);
        Assert.AreEqual(expected, ip.ToUint());
    }
    uint GetExpected(uint a, uint b, uint c, uint d)
    {
        return
            (a * 256u * 256u * 256u) +
            (b * 256u * 256u) +
            (c * 256u) +
            (d);
    }
}
于 2015-05-31T18:34:08.070 回答
2 
    public static Int32 getLongIPAddress(string ipAddress)
    {
        return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(IPAddress.Parse(ipAddress).GetAddressBytes(), 0));
    }

上面的例子就是我要走的路。你唯一需要做的就是转换为 UInt32 用于显示目的或字符串目的，包括将其用作字符串形式的长地址。

这是使用 IPAddress.Parse(String) 函数时需要的。叹。

于 2014-04-16T22:01:30.230 回答
1

如果您对该功能感兴趣，那么这里的答案不仅仅是它是如何完成的：

int ipToInt(int first, int second, 
    int third, int fourth)
{
    return Convert.ToInt32((first * Math.Pow(256, 3))
        + (second * Math.Pow(256, 2)) + (third * 256) + fourth);
}

其中firstthroughfourth是 IPv4 地址的段。

于 2009-01-20T15:36:38.107 回答
1 
public bool TryParseIPv4Address(string value, out uint result)
{
    IPAddress ipAddress;

    if (!IPAddress.TryParse(value, out ipAddress) ||
        (ipAddress.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork))
    {
        result = 0;
        return false;
    }

    result = BitConverter.ToUInt32(ipAddress.GetAddressBytes().Reverse().ToArray(), 0);
    return true;
}
于 2013-05-29T20:58:47.377 回答
1

将 IP 编号的所有部分乘以 256 的幂（256x256x256、256x256、256 和 1。例如：

IPv4 地址：127.0.0.1 32 位数：= (127x256^3) + (0x256^2) + (0x256^1) + 1 = 2130706433

于 2020-12-23T02:56:52.573 回答
0

这是我今天制定的解决方案（应该先用谷歌搜索！）：

    private static string IpToDecimal2(string ipAddress)
    {
        // need a shift counter
        int shift = 3;

        // loop through the octets and compute the decimal version
        var octets = ipAddress.Split('.').Select(p => long.Parse(p));
        return octets.Aggregate(0L, (total, octet) => (total + (octet << (shift-- * 8)))).ToString();
    }

我正在使用 LINQ、lambda 和一些泛型扩展，所以虽然它产生相同的结果，但它使用了一些新的语言特性，你可以用三行代码来完成。

如果你有兴趣，我在我的博客上有解释。

干杯，-jc

于 2009-05-05T21:59:31.827 回答
0

@Davy Ladman，您的 shift 解决方案是正确的，但仅适用于以小于或等于 99 的数字开头的 ip，事实上，第一个八位字节必须转换为 long。

无论如何，用 long 类型转换回来是相当困难的，因为存储 64 位（不是 32 用于 Ip）并用零填充 4 个字节

static uint ToInt(string addr)
{
   return BitConverter.ToUInt32(IPAddress.Parse(addr).GetAddressBytes(), 0);
}

static string ToAddr(uint address)
{
    return new IPAddress(address).ToString();
}

享受！

马西莫

于 2011-03-16T16:50:38.410 回答
0

我认为这是错误的："65536" ==> 0.0.255.255" 应该是："65535" ==> 0.0.255.255" 或 "65536" ==> 0.1.0.0"

于 2009-06-05T23:18:09.980 回答
0

假设您有一个字符串格式的 IP 地址（例如 254.254.254.254）

string[] vals = inVal.Split('.');
uint output = 0;
for (byte i = 0; i < vals.Length; i++) output += (uint)(byte.Parse(vals[i]) << 8 * (vals.GetUpperBound(0) - i));
于 2014-06-06T01:16:28.857 回答
0 
var ipAddress = "10.101.5.56";

var longAddress = long.Parse(string.Join("", ipAddress.Split('.').Select(x => x.PadLeft(3, '0'))));

Console.WriteLine(longAddress);

输出：10101005056

于 2015-08-26T00:22:42.387 回答
0 
var address = IPAddress.Parse("10.0.11.174").GetAddressBytes();
long m_Address = ((address[3] << 24 | address[2] << 16 | address[1] << 8 | address[0]) & 0x0FFFFFFFF);
于 2016-03-16T04:01:28.253 回答
0

我注意到 System.Net.IPAddress 具有 Address 属性（System.Int64）和构造函数，它们也接受 Int64 数据类型。因此，您可以使用它来将 IP 地址转换为数字（虽然不是 Int32，而是 Int64）格式。

于 2019-02-15T09:08:09.927 回答
-1

看看 .Net 的 IPAddress.Parse 中一些疯狂的解析示例：（MSDN）

“65536” ==> 0.0.255.255
“20.2” ==> 20.0.0.2
“20.65535” ==> 20.0.255.255
“128.1.2” ==> 128.1.0.2

于 2009-01-22T08:32:05.497 回答