The Java URL class contains overloaded constructors that support the specification of individual elements of a URL. The .NET Uri class is constructed using strings that are parsed into individual elements and can take arguments representing a base URL and the resource name to target.

This example demonstrates how to create instances of the Uri class:

Uri x_uri1 = new Uri("http://www.microsoft.com/ms.htm");
Uri x_base = new Uri("http://www.microsoft.com");
Uri x_uri2 = new Uri(x_base, "ms.htm");

The Uri class also provides constructors that allow the programmer to specify whether escape characters should be substituted in the URL. Here’s an example of creating a new URI using a string that is already escaped:

Uri x_uri = new Uri("http://www.microsoft.com/
Hello%20World.htm", true);

Setting the second argument to true indicates that the string should not be escaped, preventing the Uri string from being escaped twice, which would cause the percentage symbol to be mapped out of the string.

Table 14-2 contrasts the java.net.URI and java.net.URL classes against the .NET System.Uri class.

The following example shows the Java URLConnection class used to download the Microsoft home page writing the content to the console:

URLConnection x_connection
    = new URL("http://www.microsoft.com").openConnection();

BufferedReader x_reader = new BufferedReader(
    new InputStreamReader(x_connection.getInputStream()));
String x_str;
while ((x_str = x_reader.readLine()) != null) {
    System.out.println(x_str);
}
x_reader.close();

Here’s a C# implementation using the .NET WebClient class:

WebClient x_client = new WebClient();

StreamReader x_reader =
     new StreamReader(x_client.OpenRead("http://www.microsoft.com"));
string x_str;
while ((x_str = x_reader.ReadLine()) != null) {
    Console.WriteLine(x_str);
}
x_reader.Close();

The two approaches are similar, hiding the complexities of the underlying network protocols and providing the programmer with a stream containing the results of the download request. The key difference with WebClient is that the target URI is passed as an argument to the OpenRead method, not the constructor as with URLConnection, allowing WebClient instances to be reused across multiple URIs.

The WebClient class also provides two convenience methods for downloading data into byte arrays and directly into local files. To download data into a byte array, use the DownloadData method, as in the following example:

WebClient x_client = new WebClient();
byte[] x_data = x_client.DownloadData("http://www.microsoft.com");

To download data and store it directly in a local file, use the DownloadFile method. The following example downloads the Microsoft home page and stores it in homepage.html:

WebClient x_client = new WebClient();
x_client.DownloadFile("http://www.microsoft.com", "homepage.html");

Sending data to a server with the WebClient is similar to receiving data. Four methods can be used; they are listed in Table 14-3.

Each of these four methods is overloaded to accept an HTTP method argument. The default method is POST, but any method can be used. Note that the value of the HTTP method isn’t validated against values allowed by the HTTP specification.

The WebClient class has various properties that can be used to configure the request and get information about the response.

WebClient x_client = new WebClient();
x_client.BaseAddress = "http://www.microsoft.com";
byte[] x_data = x_client.DownloadData("ms.htm");

WebRequest is an abstract class that encapsulates functionality common to all Internet requests. Implementation classes that represent a specific protocol are not required to deal with all of the features, so many of the properties in the class can throw a System.NotSupportedException to indicate that the feature has no meaning for the protocol that will be used to handle the request.

The default proxy for all WebRequest instances is configured using the System.Net.GlobalProxySelection class. The WebRequest.Proxy property enables the proxy to be set on a per-request basis, overriding the global default. The following example demonstrates the setting of a default proxy:

Uri x_uri = new Uri("http://myproxy:8080");
GlobalProxySelection.Select = new WebProxy(x_uri);

The System.Net.CredentialCache class stores credentials used to access Internet resources, typically applied to HTTP requests. A single cache of credentials supports authentication information for multiple Internet resources but is intended for supporting a single user. Here is an example of defining credentials:

CredentialCache x_cache = new CredentialCache();
x_cache.Add(new Uri("http://www.microsoft.com"), "Basic",
    new NetworkCredential("adam", "adams_password"));
x_cache.Add(new Uri("http://www.java.sun.com"), "Digest",
    new NetworkCredential("adam", "adams_other_password"));

The code fragment defines two different credentials, both of which are associated with the user adam. Although account names may differ from system to system, the CredentialCache class is not intended to track different users. Credentials are associated with a request using the Credentials property, and the PreAuthenticate property controls whether the credentials are always set with a request or only in response to an authorization challenge. The WebRequest class and the concrete implementations are responsible for determining the best credential to use from the cache.

Instances of WebResponse cannot be instantiated directly but are obtained when the WebRequest.GetResponse method is called. Calling GetResponse causes the WebRequest instance to send the request to the server; nothing is sent across the network until GetResponse is invoked.

As with WebRequest, WebResponse provides an abstract view of a server response and does not expose protocol-specific functionality. For protocol-specific functionality, cast the WebResponse instance to an HttpWebResponse or a FileWebResponse. Table 14-5 lists the properties available in the WebResponse class.

Two sets of protocol implementation classes are available in the .NET Framework. The HttpWebRequest and HttpWebResponse classes are responsible for the http and https URI schemes, while FileWebRequest and FileWebResponse are responsible for the file scheme.

These protocol-specific classes aren’t available for direct instantiation. The static Create and instance GetResponse methods in the WebRequest class always return one of the abstract base classes. If the programmer requires more specific access, the types returned from these methods can be cast to the appropriate protocol-handler class.

HttpWebRequest x_req =
    (HttpWebRequest)WebRequest.Create("http://www.microsoft.com");
HttpWebResponse x_response = (HttpWebResponse)x_req.GetResponse();
StreamReader x_reader =
    new StreamReader(x_response.GetResponseStream());
String x_str;
while ((x_str = x_reader.ReadLine()) != null) {
    Console.WriteLine(x_str);
}
x_reader.Close();

The ServicePointManager class manages a collection of ServicePoint instances. This class is responsible for creating new ServicePoint instances as required and applying default values. Changes to the defaults are not applied to previously created ServicePoint instances.

Table 14-7 lists the features defined in the ServicePointManager class.

Instances of ServicePoint aren’t created until the GetResponse method is called in the HttpWebRequest class or until the FindServicePoint method is used for a server that has not previously been contacted.

The first method of configuring the settings for a host is to ensure that the service point is created before any requests are made. Here’s an example:

Uri x_uri = new Uri("http://www.microsoft.com");
ServicePoint x_sp = ServicePointManager.FindServicePoint(x_uri);
x_sp.ConnectionLimit = 10;

WebRequest x_req = WebRequest.Create(x_uri);
WebResponse x_resp = x_req.GetResponse();

In this code fragment, we call the FindServicePoint method before we make any requests to the HTTP server and change the limit for concurrent connections. Since no calls have yet been made to the URI, a new instance will be created. When we call the GetResponse method in the WebRequest class, the ServicePoint we have configured will be located and used.

The second approach involves making an initial connection and configuring the ServicePoint that is automatically created when the GetResponse method is called. Here’s an example:

Uri x_uri = new Uri("http://www.microsoft.com");
WebRequest x_req = WebRequest.Create(x_uri);
WebResponse x_resp = x_req.GetResponse();

ServicePoint x_sp = ((HttpWebRequest)x_req).ServicePoint;
x_sp.ConnectionLimit = 10;

For the first request, the ServicePointManager default values will be applied. Subsequent requests will be subject to the configured values.

ServicePoint instances will be released for garbage collection if a connection isn’t made to the server within the time limit. Subsequent connections will result in a new ServicePoint being created with the defaults from ServicePointManager. We recommend changing the default values where possible to avoid incorrect settings being accidentally applied.

Table 14-8 lists the methods and properties defined in the ServicePoint class.

The Java support for DNS is contained in the InetAddress class, and all methods to resolve host information return an instance of InetAddress. The .NET Framework includes the System.Net.Dns class, which is responsible for resolving names and addresses; the methods of the Dns class return the System.Net.IPHostEntry type, which represents a DNS record. Table 14-9 summarizes the IPHostEntry class.

The use of the IPHostEntry class to represent all of the DNS entry details available for a host provides a clean class structure. The Java InetAddress class provides methods that will return either one IP address or all addresses, while the .NET Dns class requires less complexity to achieve the same goals. The IPHostEntry type always contains all of the DNS information available.

Here is an example of resolving the name www.microsoft.com. The methods of the System.Net.Dns class are listed later in this section.

IPHostEntry x_entry = Dns.GetHostByName("www.microsoft.com");
Console.WriteLine("Host name: " + x_entry.HostName);
foreach (string x_str in x_entry.Aliases) {
    Console.WriteLine("Alias: " + x_str);
}
foreach (IPAddress x_addr in x_entry.AddressList) {
    Console.WriteLine("IP Address: " + x_addr.ToString());
}

The result of this fragment is shown here. Note that the results may change because a large number of servers host the Microsoft site.

Host name: www.microsoft.akadns.net
Alias: www.microsoft.com
IP Address: 207.46.230.219
IP Address: 207.46.197.100
IP Address: 207.46.197.102
IP Address: 207.46.230.218
IP Address: 207.46.197.113
IP Address: 207.46.230.220

We like this approach. We feel that the model of always getting all of the available information is cleaner and simpler, and the .NET classes expose more details from DNS than Java.

Table 14-10 shows the mapping between DNS support in the Java InetAddress and .NET Dns classes.

The main purpose of java.net.InetAddress is to represent an instance of an Internet Protocol address, and the additions for DNS resolution are a bolt-on feature. The .NET Framework relies on the System.Net.IPAddress class to do the same thing. Table 14-11 shows the mapping between these two classes.

The final class in this discussion is System.Net.IPEndPoint. This class represents a combination of a host address and port that can be used to contact a service on a remote computer. This class is used extensively with the lower-level networking classes discussed in Programming with Native Sockets later in this chapter. Instances of IPEndPoint are created using an IPAddress to represent the host and an integer to represent the port number, as follows:

IPAddress x_addr = IPAddress.Parse("207.46.230.219");
IPEndPoint x_endpoint = new IPEndPoint(x_addr, 80);

The example demonstrates how to parse a String into an instance of an IP address and then create the IPEndPoint. The address we used is from the list registered for www.microsoft.com, so this IPEndPoint represents the default port for HTTP on the Microsoft Web server. The same result can be achieved directly by using the results of a DNS lookup, as shown here:

IPHostEntry x_hostentry = Dns.GetHostByName("www.microsoft.com");
IPAddress x_addr = x_hostentry.AddressList[0];
IPEndPoint x_endpoint = new IPEndPoint(x_addr, 80);