Public Sub DoGetHostAddresses(hostName As [String])

    Dim ips As IPAddress()

    ips = Dns.GetHostAddresses(hostname)

    Console.WriteLine("GetHostAddresses(" + hostname + ") returns: ")

    Dim index As Integer
    For index = 0 To ips.Length - 1
         Console.WriteLine(ips(index))
    Next index
End Sub    

public static void DoGetHostAddresses(string hostname)
{
    IPAddress[] ips;

    ips = Dns.GetHostAddresses(hostname);

    Console.WriteLine("GetHostAddresses({0}) returns:", hostname);

    foreach (IPAddress ip in ips)
    {
        Console.WriteLine("    {0}", ip);
    }
}

   // Determine the Internet Protocol(IP) addresses for a host.
public:
   static void DoGetHostAddress(String^ hostname)
   {
      array<IPAddress^>^ ips;
      ips = Dns::GetHostAddresses(hostname);

      Console::WriteLine("GetHostAddresses({0}) returns:", hostname);
      for each ( IPAddress^ ip in ips )
      {
         Console::Write( "{0} ", ip );
      }
      Console::WriteLine( "" );
   }

// Signals when the resolve has finished.
static ManualResetEvent* resolveFinished = 
    new ManualResetEvent(false);

// define the state object for the callback. 
// use hostName to correlate calls with the proper result.
__gc class ResolveState
{
public:
    String* hostName;
    IPAddress * resolvedIPs[];

    ResolveState(String* host)
    {
        hostName = host;
    }

    __property void set_IPs(IPAddress* IPs[])
        {resolvedIPs = IPs;}
    __property IPAddress* get_IPs()[]{return resolvedIPs;}

    __property void set_host(String* host) {hostName = host;}
    __property String* get_host() {return hostName;}
};

// Record the IPs in the state object for later use.
static void ResolveCallback(IAsyncResult* ar)
{
    ResolveState* ioContext = 
        __try_cast<ResolveState*>(ar->AsyncState);

    ioContext->IPs = Dns::EndResolveToAddresses(ar);
    resolveFinished->Set();
}       

// Determine the Internet Protocol(IP) addresses for this 
// host asynchronously.
static void DoAsyncResolveToAddresses(String* hostName)
{
    resolveFinished->Reset();
    ResolveState* ioContext= new ResolveState(hostName);

    Dns::BeginResolveToAddresses(ioContext->host, 
        new AsyncCallback(0, ResolveCallback), ioContext);
    // Wait here until the resolve completes 
    // (the callback calls .Set())
    resolveFinished->WaitOne();

    Console::Write(
        "Asynchronous Resolve of {0} finished, IPs ", 
        ioContext->host);

    IEnumerator* ips = ioContext->IPs->GetEnumerator();
    while (ips->MoveNext())
    {
        Console::Write("{0} ", ips->Current);
    }
    Console::WriteLine("");

}