IP # 4 पते को C # में पूर्णांक में कैसे बदलें?

99

मैं एक ऐसे फंक्शन की तलाश कर रहा हूं जो एक मानक IPv4 एड्रेस को इंटेगर में बदल देगा। बोनस अंक एक फ़ंक्शन के लिए उपलब्ध है जो विपरीत कार्य करेगा।

समाधान C # में होना चाहिए।

c#  integer  ip  ipv4 
— GateKiller
स्रोत
15
चेतावनी : स्वीकृत उत्तर से उत्पन्न पूर्णांक गलत होंगे , क्योंकि आईपी पते नेटवर्क ऑर्डर (बिग-एंडियन) में होते हैं, जबकि intअधिकांश सिस्टम पर छोटे एंडियन होते हैं। इसलिए आपको कनवर्ट करने से पहले बाइट्स को उल्टा करना होगा। सही रूपांतरण के लिए मेरा उत्तर देखें । इसके अलावा, आईपीवी 4 के लिए भी एक intसे भी बड़ा पतों को रोक नहीं सकते 127.255.255.255, जैसे प्रसारण पते, तो एक का उपयोग uint।
— साब अमीनी

जवाबों:

137

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 / अपेक्षित के रूप में काम करता है (कम से कम विंडोज में, IE, फ़ायरफ़ॉक्स और क्रोम के साथ परीक्षण किया गया है, हालांकि 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
उबंटू लिनक्स 10.04 पर ओपेरा 11 में पुष्टि की गई: यह इंट को वापस परिचित वाईकेज़ रूप में परिवर्तित करता है, और यह काम करता है।
— पिस्कोवर ने
6
IPAddress .ddress .Net 4.0 के रूप में अप्रचलित है ।
— एरिक फिलिप्स
यदि आप केवल IPv4 का उपयोग करते हैं, तो @ErikPhilips क्या मायने रखता है?
— रे
यह एक वास्तु निर्णय है। इसके पास पेशेवरों और विपक्ष हैं, और टिप्पणियां उस विशिष्ट मुद्दे पर चर्चा करने के लिए सबसे अच्छा स्थान नहीं हैं।
— एरिक फिलिप्स
1
आप BitConverter.ToUInt32 (IPAddress.Parse (मान) .GetAddressBytes () का उपयोग कर सकते रिवर्स () 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

व्याख्या

आईपी ​​पते नेटवर्क ऑर्डर (बिग-एंडियन) में होते हैं, जबकि intविंडोज पर छोटे-एंडियन होते हैं, इसलिए सही मूल्य प्राप्त करने के लिए, आपको थोड़ा-एंडियन सिस्टम पर कनवर्ट करने से पहले बाइट्स को उल्टा करना होगा।

इसके अलावा, यहां तक ​​कि IPv4, प्रसारण पते की intतुलना में बड़े पते धारण नहीं कर सकते हैं , इसलिए एक का उपयोग करें ।127.255.255.255(255.255.255.255)uint

— साहब अमिनी
स्रोत
यह वास्तव में। मोनो के बारे में अनिश्चितता का उपयोग करते हुए विंडोज पर एक अंतर बनाने के लिए प्रतीत नहीं होता है। देखें dotnetfiddle.net/cBIOj2
— जेसी
2
@ यह तब होता है जब आपके इनपुट के लिए कोई फर्क नहीं पड़ता 1.1.1.1क्योंकि इसकी बाइट ऐरे पलिंडोमिक होती है । गैर-विचित्र लोगों के साथ प्रयास करें जैसे 127.0.0.1या 192.168.1.1।
— साब अमीनी
मैं मुद्दे को देखता हूं। जैसे बार-बार संख्या 1.1.1.1, 2.2.2.2, 123.123.123.123हमेशा समान ही परिणाम। पोस्टरिटी के
— जेसी
यह नोट करने के लिए कि मुझे System.Net.IPAddressयह काम करने के लिए उपयोग करना था । बहुत अच्छा काम करता है!
— Shrout1
1
@ जेसे जो केवल संख्याओं को दोहराने के लिए नहीं होगा, बल्कि सभी पैलिंड्रोमिक आईपी ​​पते के लिए होगा। तो 2.1.1.2ऐसा ही होगा।
— साब अमीनी
40

@ बेरी केली और @Andrew हरे, वास्तव में, मुझे नहीं लगता कि गुणा करना ऐसा करने का सबसे स्पष्ट तरीका है (बिल्कुल सही)।

एक 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

तो आईपी पते 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
मेरा मानना ​​है कि आईपी को विशेष रूप से इस तरह के व्यवहार के लिए अनुमति देने के तरीके का अनुमान लगाया गया था ... बिट शिफ्ट्स अधिकांश माइक्रोप्रोसेसर पर अधिक कुशल होते हैं, जैसे कि स्पल्स और जोड़।
— एप-इनोगो
1
@ एप-इनोगो गुणकों को दो की स्थिर शक्तियों द्वारा सामान्य रूप से बिट शिफ्ट्स में अनुकूलित किया जाता है।
— बैरी केली
बिट स्थानांतरण के बजाय, आप उपयोग कर सकते हैं LayoutKind.Explicitऔर FieldOffsetजिसमें बाइट्स जमा हो जाती है क्रम को उल्टा करने के लिए। बेशक, यह केवल थोड़ा एंडियन वास्तुकला के लिए काम करता है। जीथुब पर उदाहरण ।
— रबरडक
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()शून्य देता है, इसलिए आप ToArray()उस पर (भविष्य के पाठकों के लिए) कॉल नहीं कर सकते । इसके बजाय, उलटे बाइट्स के लिए एक मान असाइन करें, फिर आप ToArray () कह सकते हैं।
— एरिक फिलिप्स
1
रिवर्स () की विस्तार विधि है IEnumerable। उपरोक्त कोड पूरी तरह से ठीक है।
— चींटी
3
यह विधि निश्चित IPs (जैसे 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()));
— Guffa
स्रोत
2
आपको एक यूंट का उपयोग करने की आवश्यकता है, लेकिन यह यहां सबसे सही उत्तर है।
— रबड़डक
1
@ रबरडक: आपको केवल तभी उपयोग करने की आवश्यकता है uintजब आप 32 बिट डेटा को एक अहस्ताक्षरित संख्या के रूप में चाहते हैं, एक intही जानकारी रखने में सक्षम है। यदि आप इसे डेटाबेस में संग्रहीत करना चाहते हैं int, तो यह बेहतर अनुकूल है, आपको bigintइसे अहस्ताक्षरित रूप में संग्रहीत करने में सक्षम होने की आवश्यकता है ।
— गुफ्फा
1
एक यूआईएन एक बेहतर प्रतिनिधित्व आईएमओ है। हस्ताक्षर के लिए इंट को संकेत के लिए थोड़ा सा चाहिए, इसलिए आप सीमा के शीर्ष पर पते खो देते हैं। हां, यह एक ही डेटा को पकड़ सकता है, लेकिन यह एक नकारात्मक संख्या के रूप में आउटपुट होगा, जो कि एड्रेस बार में टाइप करने पर एक वैध आईपी नहीं है।
— रबरडक
@ रबरडैक: आप के रूप में uintआप इसे एड्रेस बार में टाइप नहीं कर सकते हैं, आपको सबसे पहले इसे करने के लिए टेक्स्ट फॉर्म में बदलना होगा। सिर्फ इसलिए कि intपाठ में मोड़ के सरलतम रूप का उपयोग करने से कार्यशील आईपी पते का उत्पादन नहीं होता है, इसका उपयोग नहीं करने के लिए एक अच्छा तर्क नहीं है।
— गुफ्फा नोव
@ रबडक: यह एक नहीं है uint, यह पाठ का प्रतिनिधित्व है uint।
— गुफ्फा
7

वर्णित समाधान के साथ मुझे कुछ समस्याओं का सामना करना पड़ा है, जब आईपी एड्रेस का सामना करना पड़ता है बहुत बड़े मूल्य के साथ। इसका परिणाम यह होगा, कि बाइट [0] * 16777216 चीज़ ओवरफ्लो हो जाएगी और एक नकारात्मक इंट वैल्यू बन जाएगी। यह मेरे लिए तय है, एक साधारण प्रकार का कास्टिंग ऑपरेशन है।

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 पंक्ति को बदलूंगा, मैं बाइट करूँगा [] बाइट्स = ip.MapToIPv4 ()। GetAddressBytes ();
— वाल्टर वेयोवेन
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;
}
— आरिस शिज़ास
स्रोत
क्या आप इसके बारे में अधिक बता सकते हैं?
— डेवलपर
3

मेरा प्रश्न बंद हो गया था, मुझे पता नहीं क्यों। यहाँ स्वीकृत उत्तर वही नहीं है जो मुझे चाहिए।

यह मुझे एक आईपी के लिए सही पूर्णांक मान देता है ।।

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;
    }
}
— Coolcoder
स्रोत
जब तक आप रूपांतरण को दोनों तरह से कर सकते हैं, तब तक मैं यह नहीं देखता कि आउटपुट संख्या को तब तक सही रहना है जब तक यह सुसंगत है।
— गेटकिलर
इस बात पर निर्भर करता है कि आप किस नंबर का उपयोग करना चाहते हैं। आप एक IP खोजने के लिए> = और <= क्वेरी करने के लिए दूसरे रूपांतरण का उपयोग नहीं कर सकते हैं
— कूलकोडर
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();
}
— DanM7
स्रोत
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के माध्यम से fourthIPv4 पता के क्षेत्रों जा रहा है।

— एंड्रयू हरे
स्रोत
1
मुझे लगता है कि अगर आप Math.Pow के बजाय शिफ्ट का उपयोग करते हैं तो यह अधिक स्पष्ट होगा।
— मेहरदाद आफश्री
अगर यह पहली बार है तो यह ओवरफ्लो अपवाद छोड़ देगा। 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;
}
— xadd
स्रोत
1 
    public static Int32 getLongIPAddress(string ipAddress)
    {
        return IPAddress.NetworkToHostOrder(BitConverter.ToInt32(IPAddress.Parse(ipAddress).GetAddressBytes(), 0));
    }

उपरोक्त उदाहरण मेरे जाने का तरीका होगा .. केवल एक चीज जो आपको करनी होगी वह प्रदर्शन उद्देश्यों के लिए UInt32 में परिवर्तित हो सकती है, या स्ट्रिंग प्रयोजनों के लिए इसे स्ट्रिंग रूप में लंबे पते के रूप में उपयोग करना शामिल है।

IPAddress.Parse (स्ट्रिंग) फ़ंक्शन का उपयोग करते समय कौन सी आवश्यक है। आह।

— जेरार्ड ओनील
स्रोत
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, लैम्ब्डा और जेनरिक पर कुछ एक्सटेंशन का उपयोग कर रहा हूं, इसलिए जब यह एक ही परिणाम उत्पन्न करता है तो यह कुछ नई भाषा सुविधाओं का उपयोग करता है और आप इसे कोड की तीन पंक्तियों में कर सकते हैं।

यदि आप रुचि रखते हैं, तो मेरे ब्लॉग पर मेरा स्पष्टीकरण है।

चीयर्स, -जेसी

0

मुझे लगता है कि यह गलत है: "65536" ==> 0.0.255.255 "होना चाहिए:" 65535 "==> 0.0.255.255" या "65536" ==> 0.1.0.0 "

0

@ डैडी लैडमैन शिफ्ट के साथ आपका समाधान स्पष्ट नहीं है, लेकिन केवल कम या समान 99 के साथ शुरू होने वाले आईपी के लिए, पहले ऑक्टेक्ट को लंबे समय तक डाला जाना चाहिए।

वैसे भी लंबे प्रकार के साथ वापस परिवर्तित करना काफी मुश्किल है क्योंकि 64 बिट (आईपी के लिए 32 नहीं) को स्टोर करें और शून्य के साथ 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

मान लें कि आपके पास स्ट्रिंग प्रारूप में एक आईपी पता है (उदाहरण। 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

— xagyg
स्रोत
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);
— shzy2012
स्रोत
GetAddressBytes विधि उल्टे क्रम में बाइट्स वापस कर सकती है, यह निर्भर करता है कि मशीन एंडियन या एंडियन-नेस है इसलिए कुछ मशीनों के लिए सही कथन हो सकता है: long m_Address = (पता [0] << 24] पता [1] << 16 | पता [2] << 8 | पता [3]) और 0x0FFFFFFFFFF
— मिगुएल स्लेव
0

मैंने देखा कि System.Net.IPAddress में एड्रेस प्रॉपर्टी (System.Int64) और कंस्ट्रक्टर है, जो Int64 डेटा टाइप भी स्वीकार करते हैं। तो आप इसका उपयोग IP पते को / से संख्यात्मक (हालांकि Int32, लेकिन Int64) प्रारूप में परिवर्तित करने के लिए कर सकते हैं।

— Ondřej
स्रोत
-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

— abelenky
स्रोत
यह वास्तव में एक जवाब नहीं है। शीर्ष उत्तरों में से एक पर टिप्पणी के रूप में इसे क्यों नहीं रखा गया?
— DanM7
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.