/* Here we simply tell the program what must happen when the button is clicked. * Obviously in the following case, what happens is that when the button is clicked * we invoke a method called "Dns.BeginResolve" which actually finished the real task started * by the AsyncCallback delegate, which is to * find the IP address of the website */ void ButtonResolveOnClick(object obj, EventArgs ea) { results.Items.Clear(); string addr = address.Text; Object state = new Object(); Dns.BeginResolve(addr, OnResolved, state); }
public void AsyncResolve() { IAsyncResult async = Dns.BeginResolve(site1Dot, null, null); IPHostEntry entry = Dns.EndResolve(async); SubTestValidIPHostEntry(entry); CheckIPv4Address(entry, IPAddress.Parse(site1Dot)); }
// Determine the Internet Protocol (IP) addresses for // this host asynchronously. public void DoGetHostEntryAsync(string hostname, DnsLookupCallback callback) { GetHostEntryFinished.Reset(); ResolveState ioContext = new ResolveState(hostname, callback); Dns.BeginResolve(ioContext.host, new AsyncCallback(GetHostEntryCallback), ioContext); }
private void btnResolve_Click(object sender, EventArgs e) { results.Items.Clear(); // xóa list view string addr = address.Text; // lấy chuỗi địa chỉ được nhập vào Object state = new Object(); // object trạng thái Dns.BeginResolve(addr, OnResolved, state); // bắt đầu gửi yêu cầu không đồng bộ DNS đến địa chỉ được nhập vào }
public static IPEndPoint GetIPEndPoint(string __ip, int __port) { // init vars IPEndPoint ret = null; IPHostEntry ipEntry; // The IP Address Array. Holds an array of resolved Host Names. IPAddress ipAddr; if (__ip.ToLower().CompareTo("localhost") == 0 || __ip.ToLower().CompareTo("0.0.0.0") == 0) { __ip = IPHost(); } // Value of alpha characters char[] alpha = "aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ-".ToCharArray(); // If alpha characters exist we know we are doing a forward lookup if (__ip.IndexOfAny(alpha) == -1) { ipEntry = Dns.GetHostByName(__ip); if (ipEntry.AddressList.Length > 0) { ipAddr = ipEntry.AddressList[0]; if (__port < 0) { __port = 0; } ret = new IPEndPoint(ipAddr, __port); } } else { if (__ip.ToLower() == "any") { ret = new IPEndPoint(IPAddress.Any, __port); } else { IAsyncResult __iar = Dns.BeginResolve(__ip, null, null); __iar.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(10), false); if (__iar.IsCompleted) { ipEntry = Dns.EndResolve(__iar); if (ipEntry != null) { ipAddr = ipEntry.AddressList[0]; if (__port < 0) { __port = 0; } ret = new IPEndPoint(ipAddr, __port); } } } } return(ret); }
/// <summary> /// Begins an asynchronous request to resolve a DNS host name or IP address in dotted-quad notation to an IPAddress instance. /// </summary> /// <param name="host">The host to resolve.</param> /// <param name="callback">The method to call when the hostname has been resolved.</param> /// <returns>An IAsyncResult instance that references the asynchronous request.</returns> /// <exception cref="SocketException">There was an error while trying to resolve the host.</exception> internal AsyncProxyResult BeginDns(string host, HandShakeComplete callback) { try { Dns.BeginResolve(host, new AsyncCallback(OnResolved), this); return(new AsyncProxyResult()); } catch { throw new SocketException(); } }
public void DnsObsoleteBeginResolve_Loopback_MatchesResolve() { IAsyncResult asyncObject = Dns.BeginResolve(IPAddress.Loopback.ToString(), null, null); IPHostEntry results = Dns.EndResolve(asyncObject); IPHostEntry entry = Dns.Resolve(IPAddress.Loopback.ToString()); Assert.Equal(entry.HostName, results.HostName); Assert.Equal(entry.AddressList, results.AddressList); }
public ServerSync(ServerProfile server, AccountProfile account, ShardProfile shard) { this.m_Server = server; this.m_Account = account; this.m_Shard = shard; this.m_Buffer = new byte[0x800]; this.m_CryptoProvider = new LoginCrypto((uint)Network.ClientIP); Dns.BeginResolve(server.Address, new AsyncCallback(this.OnResolve), null); }
public void DnsObsoleteBeginResolve_BadIPv4String_ReturnsOnlyGivenIP() { IAsyncResult asyncObject = Dns.BeginResolve("0.0.1.1", null, null); IPHostEntry entry = Dns.EndResolve(asyncObject); Assert.Equal("0.0.1.1", entry.HostName); Assert.Equal(1, entry.AddressList.Length); Assert.Equal(IPAddress.Parse("0.0.1.1"), entry.AddressList[0]); }
private void callbackOnNewPC(PC pc) { object[] objArray = new object[1] { (object)pc }; ArpForm arpForm = this; arpForm.Invoke((Delegate) new delegateOnNewPC(arpForm.AddPc), objArray); Dns.BeginResolve(pc.ip.ToString(), new AsyncCallback(this.EndResolvCallBack), pc); }
public void AsyncResolve() { IAsyncResult async = Dns.BeginResolve(site1Dot, null, null); IPHostEntry entry = Dns.EndResolve(async); SubTestValidIPHostEntry(entry); var ip = GetIPv4Address(entry); Assert.AreEqual(site1Dot, ip.ToString()); }
public static void Main() { AsyncCallback OnResolved; OnResolved = new AsyncCallback(Resolved); string addr = "www.java2s.com"; Object state = new Object(); Dns.BeginResolve(addr, OnResolved, state); }
public void AsyncResolve() { IAsyncResult r; r = Dns.BeginResolve(site1Name, new AsyncCallback(ResolveCallback), null); IAsyncResult async = Dns.BeginResolve(site1Dot, null, null); IPHostEntry entry = Dns.EndResolve(async); SubTestValidIPHostEntry(entry); Assert.AreEqual(site1Dot, entry.AddressList [0].ToString()); }
/// <summary> /// Begins an asynchronous request to resolve a DNS host name or IP address in dotted-quad notation to an IPAddress instance. /// </summary> /// <param name = "host">The host to resolve.</param> /// <param name = "callback">The method to call when the hostname has been resolved.</param> /// <returns>An IAsyncResult instance that references the asynchronous request.</returns> /// <exception cref = "SocketException">There was an error while trying to resolve the host.</exception> internal IAsyncProxyResult BeginDns(string host, Action <Exception> callback) { try { Dns.BeginResolve(host, OnResolved, this); return(new IAsyncProxyResult()); } catch { throw new SocketException(); } }
public void BeginResolve_HostName_Null() { try { Dns.BeginResolve((string)null, new AsyncCallback(ResolveCallback), null); Assert.Fail("#1"); } catch (ArgumentNullException ex) { Assert.AreEqual(typeof(ArgumentNullException), ex.GetType(), "#2"); Assert.IsNull(ex.InnerException, "#3"); Assert.IsNotNull(ex.Message, "#4"); Assert.AreEqual("hostName", ex.ParamName, "#5"); } }
public void fBeginResolve(string HostName) { try { allDone = new System.Threading.ManualResetEvent(false); // 建立 State 物件 RequestState State = new RequestState(); // 開始ansyc 解析 DNS // 定義Callback 方法為 ResponseCallback IAsyncResult Result = Dns.BeginResolve(HostName, new AsyncCallback(ResponseCallback), State); int i = 0; while (State.host == null) { Console.WriteLine(i.ToString()); ++i; } // Wait until asynchronous call completes. //allDone.WaitOne(); string IPAddr = ""; string DNS = ""; // 永久為空 string hostName = State.host.HostName; string result = ""; foreach (var item in State.host.AddressList) { IPAddr += item.ToString() + "\n\r"; } foreach (var item in State.host.Aliases) { DNS += item.ToString() + "\n\r"; } result = "我的IP位置: " + IPAddr + "\n\r" + "我的網域名稱(DNS): \n\r" + DNS + "\n\r" + "我的電腦名稱: " + HostName; MessageBox.Show(result); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
public void AsyncResolve() { message = "AsyncResolve"; reset.Reset(); IAsyncResult r = Dns.BeginResolve(site, new AsyncCallback(ResolveCallback), null); Assert.IsNotNull(r, "IAsyncResult"); // note for some reason r.AsyncWaitHandle.Wait won't work as expected // if (!r.AsyncWaitHandle.WaitOne (timeout, true)) if (!reset.WaitOne(timeout, true)) { Assert.Ignore("Timeout"); } Assert.IsNull(message, message); }
private void Write() { while (true) { listBox1.Items.Clear(); string f, l; f = maskedTextBox1.Text.Replace(" ", ""); l = maskedTextBox2.Text.Replace(" ", ""); IPAddress ipf = IPAddress.Parse(f); IPAddress ipl = IPAddress.Parse(l); List <IPAddress> ips = new List <IPAddress>(); //Show IP IPHostEntry IPHost = Dns.GetHostByName(Dns.GetHostName()); listBox1.Items.Add("My IP address is " + IPHost.AddressList[0].ToString()); //Ping using ping class ips.Add(ipf); IPAddress iph = ipf; while (true) { iph = increament(iph); if (iph.Address == ipl.Address) { break; } // iph.Address = iph.Address + 0x1 <<1; ips.Add(iph); } ips.Add(ipl); foreach (IPAddress ip in ips) { Ping pi = new Ping(); PingReply pr = pi.Send(ip); Dns.BeginResolve(ip.ToString(), new AsyncCallback(bringname), ip.ToString() + " " + pr.Status.ToString()); } Thread.Sleep(500); } }
private void BeginResolve() { if (State != ClientState.Disconnected) { try { _currentAsyncResult = Dns.BeginResolve(_server, null, null); InvokeAfterWait(new MethodInvoker(EndResolve), _currentAsyncResult.AsyncWaitHandle); } catch (Exception e) { if (!HandleException(e)) { throw new AsyncTcpClientException(this, e); } OnResolveFailed(); return; } } }
public void AsyncResolveCallback() { var evt = new ManualResetEvent(false); Exception ex = null; Dns.BeginResolve(site1Name, new AsyncCallback((IAsyncResult ar) => { try { IPHostEntry h = Dns.EndResolve(ar); SubTestValidIPHostEntry(h); } catch (Exception e) { ex = e; } finally { evt.Set(); } }), null); Assert.IsTrue(evt.WaitOne(TimeSpan.FromSeconds(60)), "Wait"); Assert.IsNull(ex, "Exception"); }
public static void Main() { allDone = new ManualResetEvent(false); // Create an instance of the RequestState class. RequestState myRequestState = new RequestState(); // Begin an asynchronous request for information like host name, IP addresses, or // aliases for specified the specified URI. IAsyncResult asyncResult = Dns.BeginResolve("www.contoso.com", new AsyncCallback(RespCallback), myRequestState); // Wait until asynchronous call completes. allDone.WaitOne(); Console.WriteLine("Host name : " + myRequestState.host.HostName); Console.WriteLine("\nIP address list : "); for (int index = 0; index < myRequestState.host.AddressList.Length; index++) { Console.WriteLine(myRequestState.host.AddressList[index]); } Console.WriteLine("\nAliases : "); for (int index = 0; index < myRequestState.host.Aliases.Length; index++) { Console.WriteLine(myRequestState.host.Aliases[index]); } }
public void PermitOnly_BeginResolve() { Dns.BeginResolve(null, null, null); }
public static bool Connect() { m_ServerHost = NewConfig.ServerHost; m_ServerPort = NewConfig.ServerPort; try { Debug.Try("Parsing IP ( \"{0}\" )", m_ServerHost); m_ServerIP = IPAddress.Parse(m_ServerHost); m_ServerIPEP = new IPEndPoint(m_ServerIP, m_ServerPort); Debug.EndTry("( {0} )", m_ServerIPEP); } catch { Debug.FailTry(); try { Debug.Try("Resolving"); IAsyncResult asyncResult = Dns.BeginResolve(m_ServerHost, null, null); do { Engine.DrawNow(); }while (!asyncResult.AsyncWaitHandle.WaitOne(10, false)); IPHostEntry entry = Dns.EndResolve(asyncResult); if (entry.AddressList.Length == 0) { Debug.FailTry("( AddressList is empty )"); return(false); } m_ServerIP = entry.AddressList[0]; m_ServerIPEP = new IPEndPoint(m_ServerIP, m_ServerPort); Debug.EndTry("( {0} )", m_ServerIPEP); } catch (Exception exception) { Debug.FailTry(); Debug.Error(exception); return(false); } } Flush(); Engine.ValidateHandlers(); m_Server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); Debug.Try("Connecting to login server '{0}'", m_ServerIPEP); try { IAsyncResult result2 = m_Server.BeginConnect(m_ServerIPEP, null, null); do { Engine.DrawNow(); }while (!result2.AsyncWaitHandle.WaitOne(10, false)); m_Server.EndConnect(result2); } catch (Exception exception2) { Debug.FailTry(); Debug.Error(exception2); return(false); } Debug.EndTry(); return(true); }
/// <summary> /// This method is called by the Main static method to perform the /// DNS resolutions requested by the user demonstrating the callback /// options specified. /// </summary> /// <param name="host">An IP address or host name to resolve</param> /// <param name="methodToUse">The callback option to demonstrate</param> private void DoResolve(string host, CallbackOption methodToUse) { resultsDisplayed = false; IPHostEntry hostInformation = null; Resolver resolver = new Resolver(); switch (methodToUse) { case CallbackOption.UseInterface: { Console.WriteLine("Resolving..."); // By passing an interface that this object supports, the called // method can notify this object of the results try { resolver.Resolve(host, (IResolveCallback)this); } catch (System.Net.Sockets.SocketException) { Console.WriteLine("Bad host name (SocketException)"); resultsDisplayed = true; } break; } case CallbackOption.UseSynchronousDelegate: { Console.WriteLine("Resolving..."); // By passing a delegate wrapping the HostResolved method, the // called object can notify this object of the result in a synchronous // or asynchronous manner, depending on how it is constructed. ResolveCallbackDelegate cb = new ResolveCallbackDelegate(HostResolved); resolver.Resolve(host, cb); break; } case CallbackOption.UseAsynchronousDelegateWithWait: { Console.Write("Resolving"); // By wrapping a synchronous long-running method (DNS resolution) // with a delegate, this object can call that method // asynchronously and show progress (in this case) or do other // work while it executes. In this scenario, it waits on the // result using the WaitHandle provided by IAsyncResult. ResolveDelegate synchMethod = new ResolveDelegate(resolver.Resolve); // The BeginInvoke method is supplied by the C# compiler... // The IntelliSense engine does not display this at design time. IAsyncResult ar = synchMethod.BeginInvoke(host, null, null); // Write another period for each 100ms interval of wait time. while (!ar.AsyncWaitHandle.WaitOne(100, false)) { Console.Write("."); } Console.WriteLine(); // If any exceptions are raised by the called method, they won't // be thrown until the results are obtained. try { // The EndInvoke method is supplied by the C# compiler... // The IntelliSense engine does not display this at design time. hostInformation = synchMethod.EndInvoke(ar); DisplayResults(hostInformation); } catch (System.Net.Sockets.SocketException) { Console.WriteLine("Bad host name (SocketException)"); resultsDisplayed = true; } break; } case CallbackOption.UseAsynchronousDelegateWithCallback: { Console.WriteLine("Resolving..."); ResolveDelegate synchMethod = new ResolveDelegate(resolver.Resolve); AsyncCallback cb = new AsyncCallback(this.AsyncCustomCallbackMethod); // Begin the method's execution...when finished, the callback will be // called. IAsyncResult ar = synchMethod.BeginInvoke(host, cb, null); break; } case CallbackOption.UseFrameworkSuppliedSynchronousMethod: { Console.WriteLine("Resolving..."); // This calls the synchronous version of a framework-defined class // that also explicitly supports asynchronous invocation. try { hostInformation = Dns.Resolve(host); DisplayResults(hostInformation); } catch (System.Net.Sockets.SocketException) { Console.WriteLine("Bad host name (SocketException)"); resultsDisplayed = true; } break; } case CallbackOption.UseFrameworkSuppliedAsynchronousMethodWithWait: { Console.Write("Resolving"); IAsyncResult ar = Dns.BeginResolve(host, null, null); // Write another period for each 100ms interval of wait time. while (!ar.AsyncWaitHandle.WaitOne(100, false)) { Console.Write("."); } Console.WriteLine(); // If any exceptions are raised by the called method, they won't // be thrown until the results are obtained. try { hostInformation = Dns.EndResolve(ar); DisplayResults(hostInformation); } catch (System.Net.Sockets.SocketException) { Console.WriteLine("Bad host name (SocketException)"); resultsDisplayed = true; } break; } case CallbackOption.UseFrameworkSuppliedAsynchronousMethodWithCallback: { Console.WriteLine("Resolving..."); AsyncCallback cb = new AsyncCallback(this.AsyncFrameworkCallbackMethod); // Begin the call...when it is finished, the callback method will be // called. IAsyncResult ar = Dns.BeginResolve(host, cb, null); break; } default: Console.WriteLine("Not Implemented Yet"); break; } // If this method ends now, there is no guarantee that the host information // will be displayed before the next prompt to the user for more hosts to // resolve is shown. In order to force the wait, put the thread to sleep // for 100ms intervals until the output has been displayed. while (!resultsDisplayed) { // For the synchronous options, this will never get executed // because the results will have been displayed before execution // reaches this point. System.Threading.Thread.Sleep(100); } }
public void DnsObsoleteBeginResolve_BadName_Throws() { IAsyncResult asyncObject = Dns.BeginResolve("BadName", null, null); Assert.ThrowsAny <SocketException>(() => Dns.EndResolve(asyncObject)); }
public void Deny_BeginResolve() { Dns.BeginResolve(null, null, null); }