C# IPAddress.ToString方法代码示例

        protected override void tcpClosed(IPAddress ip, int port)
        {
            for(LinkedListNode<IPEndPoint> it = clientIPEndPoints.First; it != null; it = it.Next)
            {
                if(it.Value.Address.ToString() == ip.ToString())
                {
                    clientIPEndPoints.Remove(it);
                    break;
                }
            }

            for(LinkedListNode<TcpClient> it = tcpClients.First; it != null; it = it.Next)
            {
                IPEndPoint iep = (IPEndPoint)it.Value.Client.RemoteEndPoint;
                if(iep.Address.ToString() == ip.ToString())
                {
                    tcpClients.Remove(it);
                    break;
                }
            }

            for (LinkedListNode<IPAddress> it = clientIPAdresses.First; it != null; it = it.Next)
            {
                if (it.Value.ToString() == ip.ToString())
                {
                    clientIPAdresses.Remove(it);
                    break;
                }
            }

            recyclePort(port);

            label1.Text = clientIPEndPoints.Count().ToString() + " Client(s) Online";
        }

 public static int Main()
 {
     IPAddress
     testadd
     =
     IPAddress.Parse
     ("127.0.0.1");
     Console.WriteLine("address is "
     +
     testadd.Address.ToString
     ("X"));
     if
     (testadd.Address
     !=
     0x0100007f)
     return
     1;
     IPAddress
     hostadd
     =
     new
     IPAddress(0x0100007f);
     Console.WriteLine("address is "
     +
     hostadd.ToString());
     if
     (hostadd.ToString()
     !=
     "127.0.0.1")
     return
     1;
     return
     0;
 }

        public static void Connect(Loop loop, IPAddress ipAddress, int port, Action<Exception, Tcp> callback)
        {
            Ensure.ArgumentNotNull(loop, "loop");
            Ensure.ArgumentNotNull(ipAddress, "ipAddress");
            Ensure.ArgumentNotNull(callback, "callback");

            ConnectRequest cpr = new ConnectRequest();
            Tcp socket = new Tcp(loop);

            cpr.Callback = (status, cpr2) => {
                if (status == 0) {
                    callback(null, socket);
                } else {
                    socket.Close();
                    callback(Ensure.Success(loop), null);
                }
            };

            int r;
            if (ipAddress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork) {
                r = uv_tcp_connect(cpr.Handle, socket.handle, UV.uv_ip4_addr(ipAddress.ToString(), port), CallbackPermaRequest.StaticEnd);
            } else {
                r = uv_tcp_connect6(cpr.Handle, socket.handle, UV.uv_ip6_addr(ipAddress.ToString(), port), CallbackPermaRequest.StaticEnd);
            }
            Ensure.Success(r, loop);
        }

        /// <summary>
        /// Actual command logic
        /// </summary>
        /// <param name="source">The user who triggered the command.</param>
        /// <param name="channel">The channel the command was triggered in.</param>
        /// <param name="args">The arguments to the command.</param>
        /// <returns></returns>
        protected override CommandResponseHandler execute(User source, string channel, string[] args)
        {
            if (args[0].Length != 8)
                return null;

            byte[] ip = new byte[4];
            ip[0] = Convert.ToByte(args[0].Substring(0, 2), 16);
            ip[1] = Convert.ToByte(args[0].Substring(2, 2), 16);
            ip[2] = Convert.ToByte(args[0].Substring(4, 2), 16);
            ip[3] = Convert.ToByte(args[0].Substring(6, 2), 16);

            IPAddress ipAddr = new IPAddress(ip);

            string hostname = "";
            try
            {
                hostname = Dns.GetHostEntry(ipAddr).HostName;
            }
            catch (SocketException)
            {
            }
            if (hostname != string.Empty)
            {
                string[] messageargs = {args[0], ipAddr.ToString(), hostname};
                return new CommandResponseHandler(new Message().get("hexDecodeResult", messageargs));
            }
            else
            {
                string[] messageargs = {args[0], ipAddr.ToString()};
                return
                    new CommandResponseHandler(new Message().get("hexDecodeResultNoResolve",
                                                                                    messageargs));
            }
        }

 public IPBanInfo Get( IPAddress address ) {
     lock( locker ) {
         if( bans.ContainsKey( address.ToString() ) ) {
             return bans[address.ToString()];
         } else {
             return null;
         }
     }
 }

        public void AddServer(IPAddress ip)
        {
            foreach (var m in MenuEntries)
                if (m.Text == ip.ToString())
                    return;

            MenuEntry server = new MenuEntry(ip.ToString());
            server.Selected += ServerMenuEntrySelected;
            MenuEntries.Add(server);
        }

 private void UpdateWithUserIp(string name, IPAddress ip)
 {
   BannedUser b;
   if (GetByIp(ip.ToString(), out b)) if (!b.nickNames.Contains(name)) b.nickNames.Add(name);
   if (GetByName(name, out b)) if (ip != IPAddress.None && !b.ipAddresses.Contains(ip.ToString())) b.ipAddresses.Add(ip.ToString());
   if (b != null) {
     if (b.Expired) Items.Remove(b);
     Save();
   }
 }

 public void Log(String username, IPAddress addr)
 {
     String baseDirecotry = Directory.GetCurrentDirectory();
     AppendPath(ref baseDirecotry, "Logs");
     AppendPath(ref baseDirecotry, "IpLogs");
     String generalLog = Path.Combine(baseDirecotry, "ip.log");
     String userLog = Path.Combine(baseDirecotry, String.Format("{0}.log", username));
     using (StreamWriter sw = new StreamWriter(generalLog, true))
         sw.WriteLine("Account: " + username + " ha loggato con ip " + addr.ToString() + " in Data: " + DateTime.Now);
     using (StreamWriter sw = new StreamWriter(userLog, true))
         sw.WriteLine("Account: " + username + " ha loggato con ip " + addr.ToString() + " in Data: " + DateTime.Now);
 }

        public override void Update(HostConfig HC, IPAddress ipAddress)
        {
            if (HC == null) throw new ArgumentNullException("HC");
            if (ipAddress == null) throw new ArgumentNullException("ipAddress");

            using (RMWebClient WC = new RMWebClient())
            {
                WC.ContentType = "application/xml";
                WC.Headers[HttpRequestHeader.Authorization] = "Basic " + Convert.ToBase64String(Encoding.ASCII.GetBytes(HC.Username + ":" + HC.Password.GetPlainText()));
                WC.Headers["Accept"] = "application/xml";
                WC.UseDefaultCredentials = false;

                try
                {
                    string Url = "https://pointhq.com";
                    Url += "/zones/" + HC.ProviderSpecificSettings[HostConfig.POINT_ZONE_ID];
                    Url += "/records/" + HC.ProviderSpecificSettings[HostConfig.POINT_RECORD_ID];

                    string ResponseText = WC.UploadString(Url, "PUT", "<zone-record><data>" + ipAddress.ToString() + "</data><ttl type=\"integer\">60</ttl></zone-record>").Trim();
                    if (!ResponseText.Contains(ipAddress.ToString()))
                    {
                        HC.Disabled = true;
                        HC.DisabledReason = "Reason not known.";
                        HC.Save();

                        Logging.instance.LogError("Unable to update host \"" + HC.Hostname + "\" (" + HC.Provider.ToString() + "): " + HC.DisabledReason);
                    }
                }
                catch (WebException wex)
                {
                    HC.Disabled = true;
                    switch (((HttpWebResponse)wex.Response).StatusCode)
                    {
                        case HttpStatusCode.Forbidden: HC.DisabledReason = "Current user does not have access to requested resource."; break;
                        case HttpStatusCode.NotFound: HC.DisabledReason = "Record not found."; break;
                        default: HC.DisabledReason = "An unknown response code was received: \"" + ((HttpWebResponse)wex.Response).StatusCode + "\""; break;
                    }
                    HC.Save();

                    Logging.instance.LogError("Unable to update host \"" + HC.Hostname + "\" (" + HC.Provider.ToString() + "): " + HC.DisabledReason);
                }
                catch (Exception ex)
                {
                    HC.Disabled = true;
                    HC.DisabledReason = "Unhandled exception (" + ex.Message + ")";
                    HC.Save();

                    Logging.instance.LogException("Unable to update host \"" + HC.Hostname + "\"", ex);
                }
            }
        }

 private static string TryGetHostName(IPAddress address)
 {
     string hostName = null;
     try
     {
         var hostEntry = Dns.GetHostEntry(address);
         hostName = hostEntry != null ? hostEntry.HostName : address.ToString();
     }
     catch
     {
         //Whatever happens, just return address.ToString();
         hostName = address.ToString();
     }
     return hostName;
 }

 /// <summary>
 /// Adds a potential IP address 
 /// </summary>
 /// <param name="addr"></param>
 public void addPotential(IPAddress addr)
 {
     if (potentialIPBox.InvokeRequired)
     {
         potentialIPBox.Invoke((MethodInvoker)delegate
         {
             addPotential(addr);
         });
     }
     else
     {
         if (!potentialIPBox.Items.Contains(addr.ToString()))
             this.potentialIPBox.Items.Add(addr.ToString());
     }
 }

        public static string GetNetworkAddressAsString(IPAddress address, IPAddress mask)
        {
            string netIP = ""; // Network address as string
            int networkLength = 0;

            if (null != mask)
            {
                for (int i = 0; i < 4; i++)
                {
                    byte ba = address.GetAddressBytes()[i];
                    byte bm = mask.GetAddressBytes()[i];

                    netIP += ba & bm;
                    if (i < 3) netIP += ".";
                    networkLength += 8 - (int)System.Math.Truncate(System.Math.Log(256 - bm, 2));
                }
                netIP += "/" + networkLength;
            }
            else
            {
                netIP = address.ToString() + "/32";
            }

            return netIP;
        }

        public Server(IPAddress ip, int port)
        {
            console = new consoleUI();

            int maxPlayers = 3;

            player = new Client[maxPlayers];
            reservedIDs = new Boolean[maxPlayers];

            for (int i = 0; i < reservedIDs.Length; i++)
            {
                reservedIDs[i] = false;
            }

            try
            {
                tcpListener = new TcpListener(IPAddress.Any, port);
                tcpListener.Start();
            }
            catch (Exception exp)
            {
                console.consoleW("Beim Versuch der Auflösung der Addresse: " + ip.ToString() + " enstand folgender Fehler:\r\n" + exp.Message, "error");
                while (true) ;
            }
        }

        public static bool VerificationIPAddress(IPAddress ip)
        {
            if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
            {
                return VerificationIPAddressV4(ip.ToString());
            }
            else if (ip.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
            {
                if (ip.IsIPv6LinkLocal == true || ip.IsIPv6Multicast == true || ip.IsIPv6SiteLocal == true)
                    return false;
                else
                    return VerificationIPAddressV6(ip.ToString());
            }

            return false;
        }

 public static Uri Replace(Uri url, IPAddress ip)
 {
     var newUriBuilder = new UriBuilder(url);
     newUriBuilder.Host = ip.ToString();
     var newUri = newUriBuilder.Uri;
     return newUri;
 }