Как преобразовать IPv4-адрес в целое число на C #?


100

Я ищу функцию, которая преобразует стандартный адрес IPv4 в целое число. Бонусные баллы доступны за функцию, которая будет делать обратное.

Решение должно быть на C #.


15
ВНИМАНИЕ : целые числа, полученные в результате принятого ответа, будут неправильными , потому что IP-адреса находятся в сетевом порядке (с прямым порядком байтов), а intв большинстве систем с прямым порядком байтов. Поэтому перед преобразованием вы должны перевернуть байты. Смотрите мой ответ для правильных преобразований. Кроме того, даже для IPv4 не intможет содержать адреса больше, чем 127.255.255.255, например, широковещательный адрес, поэтому используйте расширение uint.
Саеб Амини,

Ответы:


138

32-битные целые числа без знака - это адреса IPv4. Между тем, это IPAddress.Addressсвойство, хотя и не рекомендуется, представляет собой Int64, которое возвращает беззнаковое 32-битное значение IPv4-адреса (загвоздка в том, что он находится в сетевом порядке байтов, поэтому вам нужно поменять его местами).

Например, мой локальный 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));
    }
}

2
Подтверждено в Opera 11 в Ubuntu Linux 10.04: он преобразует int обратно в знакомую форму wxyz, и он работает.
Писквор покинул здание

6
IPAddress.Address устарел с .Net 4.0.
Эрик Филипс

@ErikPhilips Имеет ли это значение, если вы используете только IPv4?
Ray

Это архитектурное решение. У него есть свои плюсы и минусы, и комментарии - не лучшее место для обсуждения этой конкретной проблемы.
Эрик Филипс

1
вы можете использовать BitConverter.ToUInt32 (IPAddress.Parse (value) .GetAddressBytes (). Reverse (). ToArray (), чтобы исправить IPAddress.Address устарел
Mhmd

43

Вот пара методов преобразования 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, не intможет содержать адреса больше, чем 127.255.255.255, например, широковещательный адрес (255.255.255.255), поэтому используйте uint.


На самом деле, похоже, что это не имеет значения для Windows, использующей .NET - не уверен в Mono. См. Dotnetfiddle.net/cBIOj2
Джесси

2
@Jesse это не имеет значения для вашего ввода, 1.1.1.1потому что его байтовый массив является палиндромным. Попробуйте использовать непалиндромные, например 127.0.0.1или 192.168.1.1.
Саеб Амини

Я вижу проблему. Повторные числа , такие как 1.1.1.1, 2.2.2.2, 123.123.123.123всегда дают тот же результат. Для потомков см. Обновленную скрипку: dotnetfiddle.net/aR6fhc
Джесси,

Хотел бы отметить, что мне пришлось использовать, System.Net.IPAddressчтобы это работало. Прекрасно работает!
Shrout1 06

1
@Jesse, это не только для повторяющихся чисел, но и для всех палиндромных IP-адресов. Так 2.1.1.2было бы тоже самое.
Саеб Амини

40

@Barry Kelly и @Andrew Hare, на самом деле, я не думаю, что умножение - самый очевидный способ сделать это (хотя и правильно).

"Форматированный" IP-адрес Int32 можно рассматривать как следующую структуру

[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

чтобы вы могли сложить их, используя +, или вы могли бы binairy или их вместе. Результатом является 0x40E9BB63, который равен 1089059683. (На мой взгляд, глядя в шестнадцатеричном формате, намного легче увидеть байты)

Итак, вы можете написать функцию как:

int ipToInt(int first, int second, 
    int third, int fourth)
{
    return (first << 24) | (second << 16) | (third << 8) | (fourth);
}

1
Я считаю, что ip были определены таким образом, чтобы специально разрешить такое поведение ... битовые сдвиги намного эффективнее на большинстве микропроцессоров, чем muls и add.
Ape-inago,

1
Умножение @Ape-inago на постоянную степень двойки обычно оптимизируется в битовые сдвиги, fwiw.
Барри Келли

Вместо сдвига битов вы можете использовать LayoutKind.Explicitи FieldOffsetдля изменения порядка, в котором хранятся байты. Конечно, это работает только для архитектуры с прямым порядком байтов. Пример на гитхабе .
RubberDuck

2
Следует отметить, что intэто подписано, поэтому, если вы сдвинете 192 на 24 бита, вы получите отрицательное целое число, поэтому этот код нарушается для старшего октета, имеющего высокий бит на первом месте.
Mateusz

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();
}

Reverse()возвращает void, поэтому вы не можете ToArray()его использовать (для будущих читателей). Вместо этого присвойте значение обратным байтам, затем вы можете вызвать ToArray ().
Эрик Филипс

1
Reverse () - это метод расширения IEnumerable. Код выше в порядке.
Ant

3
Этот метод дает отрицательные числа для определенных IP-адресов (например, 140.117.0.0)
lightxx

7

Поскольку никто не опубликовал код, который использует 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()));

2
Вам нужно использовать uint, но это наиболее правильный ответ.
RubberDuck

1
@RubberDuck: вам нужно использовать, только uintесли вы хотите, чтобы 32 бита данных были беззнаковым числом, intон может хранить ту же информацию. Если вы хотите сохранить его в базе данных, что intлучше подходит, вам понадобится, bigintчтобы иметь возможность хранить его в неподписанной форме.
Guffa

1
Uint - лучшее представление IMO. Для подписанного int требуется немного для знака, поэтому вы теряете адреса в самом верху диапазона. Да, он может содержать те же данные, но будет выводиться как отрицательное число, которое не является действительным IP-адресом, если вы введете его в адресную строку.
RubberDuck

@RubberDuck: в форме, которую uintвы также не можете ввести в адресной строке, вам сначала нужно преобразовать ее в текстовую форму, чтобы сделать это. Тот факт, что использование простейшей формы преобразования intв текст не приводит к созданию рабочего IP-адреса, не является хорошим аргументом в пользу его отказа .
Guffa

@RubberDuck: Это не файл uint, это текстовое представление uint.
Guffa

7

Я столкнулся с некоторыми проблемами с описанными решениями, когда сталкивался с IP-адресами с очень большим значением. Результатом будет то, что байт [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;
}

мне кажется лучшим решением, однако я бы изменил 1 строку, я бы сделал byte [] bytes = ip.MapToIPv4 (). GetAddressBytes ();
Walter Vehoeven

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;
}

не могли бы вы объяснить это подробнее?
Developerium

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;
    }
}

Пока вы можете выполнять преобразование в обоих направлениях, я не понимаю, почему выходной номер должен быть правильным, если он согласован.
GateKiller

Зависит от того, для чего вы хотите использовать номер. Вы не можете использовать другое преобразование для выполнения запросов> = и <= для поиска IP ..
Coolcoder,

2

Имея 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();
}

2

Собрал несколько из приведенных выше ответов в метод расширения, который обрабатывает порядок байтов машины и обрабатывает адреса IPv4, которые были сопоставлены с IPv6.

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);
    }
}

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);
}

с firstпомощью fourthтого , что сегменты адреса IPv4.


1
Думаю, было бы более понятно, если бы вы использовали shift вместо Math.Pow.
Mehrdad Afshari

Это вызовет исключение переполнения, если first> 127. Ответ Дэви Лэндмана - лучший способ сделать это.
mhenry1384

int32 подписан, поэтому он вернет отрицательное значение> 127 для первого октета
Mateusz

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;
}

1
    public static Int32 getLongIPAddress(string ipAddress)
    {
        return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(IPAddress.Parse(ipAddress).GetAddressBytes(), 0));
    }

Приведенный выше пример - это то, что я использую ... Единственное, что вам, возможно, придется сделать, это преобразовать в UInt32 для целей отображения или строковых целей, включая использование его как длинного адреса в строковой форме.

Это то, что нужно при использовании функции IPAddress.Parse (String). Вздох.


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, лямбда и некоторые расширения для универсальных шаблонов, поэтому, хотя он дает тот же результат, он использует некоторые из новых языковых функций, и вы можете сделать это в трех строках кода.

У меня есть объяснение в моем блоге, если вам интересно.

ура, -jc


0

Я считаю, что это неправильно: "65536" ==> 0.0.255.255 "Должно быть:" 65535 "==> 0.0.255.255" или "65536" ==> 0.1.0.0 "


0

@Davy Ladman ваше решение со сдвигом является коррентным, но только для ip, начиная с номера меньше или равного 99, фактически первый октект должен быть увеличен до 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();
}

Наслаждайтесь!

Массимо


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));

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


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);

метод GetAddressBytes может возвращать байты в обратном порядке, в зависимости от того, является ли машина прямым или прямым порядком байтов, поэтому для некоторых компьютеров может быть правильным выражение: long m_Address = (address [0] << 24 | address [1] << 16 | адрес [2] << 8 | адрес [3]) & 0x0FFFFFFFF
MiguelSlv

0

Я заметил, что System.Net.IPAddress имеет свойство Address (System.Int64) и конструктор, которые также принимают тип данных Int64. Таким образом, вы можете использовать это для преобразования IP-адреса в / из числового (хотя и не Int32, а Int64) формата.


-1

Взгляните на некоторые безумные примеры синтаксического анализа в IPAddress.Parse .Net: ( 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


На самом деле это не ответ. Почему бы не написать это как комментарий к одному из самых популярных ответов?
DanM7
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.