The following example uses the members of the NetworkInterface class to display information about all the network interfaces on the local machine:

using System;
using System.Net.NetworkInformation;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_01
    {
        static void Main()
        {
            // Only proceed if there is a network available.
            if (NetworkInterface.GetIsNetworkAvailable())
            {
                // Get the set of all NetworkInterface objects for the local
                // machine.
                NetworkInterface[] interfaces =
                    NetworkInterface.GetAllNetworkInterfaces();

// Iterate through the interfaces and display information.
                foreach (NetworkInterface ni in interfaces)
                {
                    // Report basic interface information.
                    Console.WriteLine("Interface Name: {0}", ni.Name);
                    Console.WriteLine("    Description: {0}", ni.Description);
                    Console.WriteLine("    ID: {0}", ni.Id);
                    Console.WriteLine("    Type: {0}", ni.NetworkInterfaceType);
                    Console.WriteLine("    Speed: {0}", ni.Speed);
                    Console.WriteLine("    Status: {0}", ni.OperationalStatus);

                    // Report physical address.
                    Console.WriteLine("    Physical Address: {0}",
                        ni.GetPhysicalAddress().ToString());

                    // Report network statistics for the interface.
                    Console.WriteLine("    Bytes Sent: {0}",
                        ni.GetIPv4Statistics().BytesSent);
                    Console.WriteLine("    Bytes Received: {0}",
                        ni.GetIPv4Statistics().BytesReceived);

                    // Report IP configuration.
                    Console.WriteLine("    IP Addresses:");
                    foreach (UnicastIPAddressInformation addr
                        in ni.GetIPProperties().UnicastAddresses)
                    {
                        Console.WriteLine("        - {0} (lease expires {1})",
                            addr.Address,
                            DateTime.Now +
                            new TimeSpan(0, 0, (int)addr.DhcpLeaseLifetime));
                    }

                    Console.WriteLine(Environment.NewLine);
                }
            }
            else
            {
                Console.WriteLine("No network available.");
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to use handlers that catch NetworkAddressChanged and NetworkAvailabilityChanged events and then display status information to the console. To observe how the code handles changing network conditions, unplug your network cable while the example is running, wait a few seconds, and then plug the cable back in.

using System;
using System.Net.NetworkInformation;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_02
    {
        // Declare a method to handle NetworkAvailabilityChanged events.
        private static void NetworkAvailabilityChanged(
            object sender, NetworkAvailabilityEventArgs e)
        {
            // Report whether the network is now available or unavailable.
            if (e.IsAvailable)
            {
                Console.WriteLine("Network Available");
            }
            else
            {
                Console.WriteLine("Network Unavailable");
            }
        }

        // Declare a method to handle NetworkAdressChanged events.
        private static void NetworkAddressChanged(object sender, EventArgs e)
        {
            Console.WriteLine("Current IP Addresses:");

            // Iterate through the interfaces and display information.
            foreach (NetworkInterface ni in
                NetworkInterface.GetAllNetworkInterfaces())
            {
                foreach (UnicastIPAddressInformation addr
                    in ni.GetIPProperties().UnicastAddresses)
                {
                    Console.WriteLine("    - {0} (lease expires {1})",
                        addr.Address, DateTime.Now +
                        new TimeSpan(0, 0, (int)addr.DhcpLeaseLifetime));
                }
            }
        }

        static void Main(string[] args)
        {
            // Add the handlers to the NetworkChange events.
            NetworkChange.NetworkAvailabilityChanged +=
                NetworkAvailabilityChanged;
            NetworkChange.NetworkAddressChanged +=
                NetworkAddressChanged;

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Press Enter to stop waiting for network events");
            Console.ReadLine();
        }
    }
}

The following example downloads a specified resource from a URI as a string and, since it is an HTML page, parses it for any fully qualified URLs that refer to GIF files. It then downloads each of these files to the local hard drive.

using System;
using System.IO;
using System.Net;
using System.Text.RegularExpressions;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_03
    {

private static void Main()
        {
            // Specify the URI of the resource to parse.
            string srcUriString = "http://www.apress.com";
            Uri srcUri = new Uri(srcUriString);

            // Create a WebClient to perform the download.
            WebClient client = new WebClient();

            Console.WriteLine("Downloading {0}", srcUri);

            // Perform the download getting the resource as a string.
            string str = client.DownloadString(srcUri);

            // Use a regular expression to extract all HTML <img>
            // elements and extract the path to any that reference
            // files with a gif, jpg, or jpeg extension.
            MatchCollection matches = Regex.Matches(str,
                "<img.*?src\s*=\s*["'](?<url>.*?\.(gif|jpg|jpeg)).*?>",
                RegexOptions.Singleline | RegexOptions.IgnoreCase);

            // Try to download each referenced image file.
            foreach(Match match in matches)
            {
                var urlGrp = match.Groups["url"];

                if (urlGrp != null && urlGrp.Success)
                {
                    Uri imgUri = null;

                    // Determine the source URI.
                    if (urlGrp.Value.StartsWith("http"))
                    {
                        // Absolute
                        imgUri = new Uri(urlGrp.Value);
                    }
                    else if (urlGrp.Value.StartsWith("/"))
                    {
                        // Relative
                        imgUri = new Uri(srcUri, urlGrp.Value);
                    }
                    else
                    {
                        // Skip it.
                        Console.WriteLine("Skipping image {0}", urlGrp.Value);
                    }

if (imgUri != null)
                    {
                        // Determine the local file name to use.
                        string fileName =
                            urlGrp.Value.Substring(urlGrp.Value.LastIndexOf('/')+1);

                        try
                        {
                            // Download and store the file.
                            Console.WriteLine("Downloading {0} to {1}",
                                imgUri.AbsoluteUri, fileName);

                            client.DownloadFile(imgUri, fileName);
                        }
                        catch
                        {
                            Console.WriteLine("Failed to download {0}",
                                imgUri.AbsoluteUri);
                        }
                    }
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example retrieves and displays a graphic and the HTML content of a web page. Figure 10-1 shows the output.

using System;
using System.Net;
using System.IO;
using System.Drawing;
using System.Windows.Forms;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public partial class Recipe10_04 : Form
    {
        public Recipe10_04()
        {
            InitializeComponent();
        }

        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);

            string picUri = "http://www.apress.com/img/img05/Hex_RGB4.jpg";
            string htmlUri = "http://www.apress.com";

            // Create the requests.
            WebRequest requestPic = WebRequest.Create(picUri);
            WebRequest requestHtml = WebRequest.Create(htmlUri);

            // Get the responses.
            // This takes the most significant amount of time, particularly
            // if the file is large, because the whole response is retrieved.
            WebResponse responsePic = requestPic.GetResponse();
            WebResponse responseHtml = requestHtml.GetResponse();

            // Read the image from the response stream.
            pictureBox1.Image = Image.FromStream(responsePic.GetResponseStream());

// Read the text from the response stream.
            using (StreamReader r =
                new StreamReader(responseHtml.GetResponseStream()))
            {
                textBox1.Text = r.ReadToEnd();
            }
        }

        [STAThread]
        public static void Main(string[] args)
        {
            Application.Run(new Recipe10_04());
        }
    }
}

Figure 10.1. Downloading content from the Web using a stream

The following example demonstrates how to use the HttpListener class to process HTTP requests. The example starts listening for five requests concurrently using the asynchronous BeginGetContext method and handles the response to each request by calling the RequestHandler method. Each time a request is handled, a new call is made to BeginGetContext so that you always have the capacity to handle up to five requests.

To open a connection to the example from your browser, enter the URL http://localhost:19080/VisualCSharpRecipes/ or http://localhost:20000/Recipe10-05/, and you will see the response from the appropriate request handler.

using System;
using System.IO;
using System.Net;
using System.Text;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_05
    {
        // Configure the maximum number of request that can be
        // handled concurrently.
        private static int maxRequestHandlers = 5;

        // An integer used to assign each HTTP request handler a unique
        // identifier.
        private static int requestHandlerID = 0;

        // The HttpListener is the class that provides all the capabilities
        // to receive and process HTTP requests.
        private static HttpListener listener;

// A method to asynchronously process individual requests and send
        // responses.
        private static void RequestHandler(IAsyncResult result)
        {
            Console.WriteLine("{0}: Activated.", result.AsyncState);

            try
            {
                // Obtain the HttpListenerContext for the new request.
                HttpListenerContext context = listener.EndGetContext(result);

                Console.WriteLine("{0}: Processing HTTP Request from {1} ({2}).",
                    result.AsyncState,
                    context.Request.UserHostName,
                    context.Request.RemoteEndPoint);

                // Build the response using a StreamWriter feeding the
                // Response.OutputStream.
                StreamWriter sw =
                   new StreamWriter(context.Response.OutputStream, Encoding.UTF8);

                sw.WriteLine("<html>");
                sw.WriteLine("<head>");
                sw.WriteLine("<title>Visual C# Recipes</title>");
                sw.WriteLine("</head>");
                sw.WriteLine("<body>");
                sw.WriteLine("Recipe 10-5: " + result.AsyncState);
                sw.WriteLine("</body>");
                sw.WriteLine("</html>");
                sw.Flush();

                // Configure the Response.
                context.Response.ContentType = "text/html";
                context.Response.ContentEncoding = Encoding.UTF8;

                // Close the Response to send it to the client.
                context.Response.Close();

                Console.WriteLine("{0}: Sent HTTP response.", result.AsyncState);
            }
            catch (ObjectDisposedException)
            {
                Console.WriteLine("{0}: HttpListener disposed--shutting down.",
                    result.AsyncState);
            }
            finally
            {

// Start another handler if unless the HttpListener is closing.
                if (listener.IsListening)
                {
                    Console.WriteLine("{0}: Creating new request handler.",
                        result.AsyncState);

                    listener.BeginGetContext(RequestHandler, "RequestHandler_" +
                        Interlocked.Increment(ref requestHandlerID));
                }
            }
        }

        public static void Main(string[] args)
        {
            // Quit gracefully if this feature is not supported.
            if (!HttpListener.IsSupported)
            {
                Console.WriteLine(
                    "You must be running this example on Windows XP SP2, ",
                    "Windows Server 2003, or higher to create ",
                    "an HttpListener.");
                return;
            }

            // Create the HttpListener.
            using (listener = new HttpListener())
            {
                // Configure the URI prefixes that will map to the HttpListener.
                listener.Prefixes.Add(
                    "http://localhost:19080/VisualCSharpRecipes/");
                listener.Prefixes.Add(
                    "http://localhost:20000/Recipe10-05/");

                // Start the HttpListener before listening for incoming requests.
                Console.WriteLine("Starting HTTP Server");
                listener.Start();
                Console.WriteLine("HTTP Server started");
                Console.WriteLine(Environment.NewLine);

                // Create a number of asynchronous request handlers up to
                // the configurable maximum. Give each a unique identifier.
                for (int count = 0; count < maxRequestHandlers; count++)
                {
                    listener.BeginGetContext(RequestHandler, "RequestHandler_" +
                        Interlocked.Increment(ref requestHandlerID));
                }

                // Wait for the user to stop the HttpListener.
                Console.WriteLine("Press Enter to stop the HTTP Server");
                Console.ReadLine();

// Stop accepting new requests.
                listener.Stop();

                // Terminate the HttpListener without processing current requests.
                listener.Abort();
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example demonstrates all four of the basic approaches described previously. Note that you need to add a reference to the System.Security.dll assembly.

using System;
using System.Net;
using System.Security.Cryptography.X509Certificates;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_06
    {
        public static void Main()
        {
            // Create a WebRequest that authenticates the user with a
            // username and password combination over basic authentication.
            WebRequest requestA = WebRequest.Create("http://www.somesite.com");
            requestA.Credentials = new NetworkCredential("userName", "password");
            requestA.PreAuthenticate = true;

            // Create a WebRequest that authenticates the current user
            // with Windows integrated authentication.
            WebRequest requestB = WebRequest.Create("http://www.somesite.com");
            requestB.Credentials = CredentialCache.DefaultCredentials;
            requestB.PreAuthenticate = true;

// Create a WebRequest that authenticates the user with a client
            // certificate loaded from a file.
            HttpWebRequest requestC =
                (HttpWebRequest)WebRequest.Create("http://www.somesite.com");
            X509Certificate cert1 =
                X509Certificate.CreateFromCertFile(@"....TestCertificate.cer");
            requestC.ClientCertificates.Add(cert1);

            // Create a WebRequest that authenticates the user with a client
            // certificate loaded from a certificate store. Try to find a
            // certificate with a specific subject, but if it is not found,
            // present the user with a dialog so they can select the certificate
            // to use from their personal store.
            HttpWebRequest requestD =
                (HttpWebRequest)WebRequest.Create("http://www.somesite.com");
            X509Store store = new X509Store();
            X509Certificate2Collection certs =
                store.Certificates.Find(X509FindType.FindBySubjectName,
                "Allen Jones", false);

            if (certs.Count == 1)
            {
                requestD.ClientCertificates.Add(certs[0]);
            }
            else
            {
                certs = X509Certificate2UI.SelectFromCollection(
                    store.Certificates,
                    "Select Certificate",
                    "Select the certificate to use for authentication.",
                    X509SelectionFlag.SingleSelection);

                if (certs.Count != 0)
                {
                    requestD.ClientCertificates.Add(certs[0]);
                }
            }

            // Now issue the request and process the responses...
        }
    }
}

The following example demonstrates how to use the SmtpClient class to send an e-mail message with multiple attachments to a set of recipients whose e-mail addresses are specified as command-line arguments:

using System;
using System.Net;
using System.Net.Mail;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_07
    {
        public static void Main(string[] args)
        {
            // Create and configure the SmtpClient that will send the mail.
            // Specify the host name of the SMTP server and the port used
            // to send mail.
            SmtpClient client = new SmtpClient("mail.somecompany.com", 25);

            // Configure the SmtpClient with the credentials used to connect
            // to the SMTP server.
            client.Credentials =
                new NetworkCredential("[email protected]", "password");

            // Create the MailMessage to represent the e-mail being sent.
            using (MailMessage msg = new MailMessage())
            {
                // Configure the e-mail sender and subject.
                msg.From = new MailAddress("[email protected]");
                msg.Subject = "Greetings from Visual C# Recipes";

                // Configure the e-mail body.
                msg.Body = "This is a message from Recipe 10-07 of" +
                    " Visual C# Recipes. Attached is the source file " +
                    " and the binary for the recipe.";

                // Attach the files to the e-mail message and set their MIME type.
                msg.Attachments.Add(
                    new Attachment(@"....Recipe10-07.cs","text/plain"));
                msg.Attachments.Add(
                    new Attachment(@".Recipe10-07.exe",
                    "application/octet-stream"));

                // Iterate through the set of recipients specified on the
                // command line. Add all addresses with the correct structure as
                //  recipients.
                foreach (string str in args)
                {

// Create a MailAddress from each value on the command line
                    // and add it to the set of recipients.
                    try
                    {
                        msg.To.Add(new MailAddress(str));
                    }
                    catch (FormatException ex)
                    {
                        // Proceed to the next specified recipient.
                        Console.WriteLine("{0}: Error -- {1}", str, ex.Message);
                        continue;
                    }
                }

                // Send the message.
                client.Send(msg);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

The following example retrieves the IP addresses of all computers whose fully qualified domain names are specified as command-line arguments:

using System;
using System.Net;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_08
    {
        public static void Main(string[] args)
        {
            foreach (string comp in args)
            {
                try
                {
                    // Retrieve the DNS entry for the specified computer.
                    IPAddress[] addresses = Dns.GetHostEntry(comp).AddressList;

                    // The DNS entry may contain more than one IP address. Iterate
                    // through them and display each one along with the type of
                    // address (AddressFamily).
                    foreach (IPAddress address in addresses)
                    {

Console.WriteLine("{0} = {1} ({2})",
                            comp, address, address.AddressFamily);
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine("{0} = Error ({1})", comp, ex.Message);
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

Running the example with the following command line:

recipe10-08 www.apress.com www.microsoft.com localhost somejunk

will produce output similar to the following. Notice that multiple IP addresses can be returned for some host names.

www.apress.com = 65.19.150.100 (InterNetwork)

www.microsoft.com = 207.46.198.30 (InterNetwork)

www.microsoft.com = 207.46.20.30 (InterNetwork)

www.microsoft.com = 207.46.20.60 (InterNetwork)

www.microsoft.com = 207.46.18.30 (InterNetwork)

www.microsoft.com = 207.46.19.30 (InterNetwork)

www.microsoft.com = 207.46.19.60 (InterNetwork)

www.microsoft.com = 207.46.199.30 (InterNetwork)

www.microsoft.com = 207.46.198.60 (InterNetwork)

localhost = 127.0.0.1 (InterNetwork)

somejunk = Error (No such host is known)

The following example pings the computers whose domain names or IP addresses are specified as command-line arguments:

using System;
using System.Net.NetworkInformation;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_09
    {
        public static void Main(string[] args)
        {
            // Create an instance of the Ping class.
            using (Ping ping = new Ping())
            {
                Console.WriteLine("Pinging:");

                foreach (string comp in args)
                {
                    try
                    {
                        Console.Write("    {0}...", comp);

                        // Ping the specified computer with a timeout of 100 ms.
                        PingReply reply = ping.Send(comp, 100);

if (reply.Status == IPStatus.Success)
                        {
                          Console.WriteLine("Success - IP Address:{0} Time:{1}ms",
                              reply.Address, reply.RoundtripTime);
                        }
                        else
                        {
                            Console.WriteLine(reply.Status);
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Error ({0})",
                            ex.InnerException.Message);
                    }
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

Running the example with the following command line:

recipe10-09 www.apress.com www.google.com localhost somejunk

will produce output similar to the following:

Pinging:

www.apress.com...TimedOut

www.google.com...Success - IP Address:216.239.59.104 Time:42ms

localhost...Success - IP Address:127.0.0.1 Time:0ms

somejunk...Error (No such host is known)

In this example, the defined protocol is basic. You would add more constants depending on the type of application. For example, in a file transfer application, you might include a client message for requesting a file. The server might then respond with an acknowledgment and return file details such as the file size. These constants should be compiled into a separate class library assembly, which must be referenced by both the client and server. Here is the code for the shared protocol:

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public class Recipe10_10Shared
    {
        public const string AcknowledgeOK = "OK";
        public const string AcknowledgeCancel = "Cancel";
        public const string Disconnect = "Bye";
        public const string RequestConnect = "Hello";
    }
}

The following code is a template for a basic TCP server. It listens on a fixed port, accepts the first incoming connection, and then waits for the client to request a disconnect. At this point, the server could call the TcpListener.AcceptTcpClient method again to wait for the next client, but instead it simply shuts down.

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public class Recipe10_10Server
    {
        public static void Main()
        {
            // Create a new listener on port 8000.
            TcpListener listener =
                new TcpListener(IPAddress.Parse("127.0.0.1"), 8000);

            Console.WriteLine("About to initialize port.");
            listener.Start();
            Console.WriteLine("Listening for a connection...");

            try
            {
                // Wait for a connection request, and return a TcpClient
                // initialized for communication.
                using (TcpClient client = listener.AcceptTcpClient())
                {
                    Console.WriteLine("Connection accepted.");

// Retrieve the network stream.
                    NetworkStream stream = client.GetStream();

                    // Create a BinaryWriter for writing to the stream.
                    using (BinaryWriter w = new BinaryWriter(stream))
                    {
                        // Create a BinaryReader for reading from the stream.
                        using (BinaryReader r = new BinaryReader(stream))
                        {
                            if (r.ReadString() ==
                                Recipe10_10Shared.RequestConnect)
                            {
                                w.Write(Recipe10_10Shared.AcknowledgeOK);
                                Console.WriteLine("Connection completed.");

                                while (r.ReadString() !=
                                    Recipe10_10Shared.Disconnect) { }

                                Console.WriteLine(Environment.NewLine);
                                Console.WriteLine("Disconnect request received.");
                            }
                            else
                            {
                                Console.WriteLine("Can't complete connection.");
                            }
                        }
                    }
                }

                Console.WriteLine("Connection closed.");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
            finally
            {
                // Close the underlying socket (stop listening for new requests).
                listener.Stop();
                Console.WriteLine("Listener stopped.");
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
       }
    }
}

The following code is a template for a basic TCP client. It contacts the server at the specified IP address and port. In this example, the loopback address (127.0.0.1) is used, which always points to the local computer. Keep in mind that a TCP connection requires two ports: one at the server end and one at the client end. However, only the server port to connect to needs to be specified. The outgoing client port can be chosen dynamically at runtime from the available ports, which is what the TcpClient class will do by default.

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public class Recipe10_10Client
    {
        public static void Main()
        {
            TcpClient client = new TcpClient();

            try
            {
                Console.WriteLine("Attempting to connect to the server ",
                    "on port 8000.");
                client.Connect(IPAddress.Parse("127.0.0.1"), 8000);
                Console.WriteLine("Connection established.");

                // Retrieve the network stream.
                NetworkStream stream = client.GetStream();

                // Create a BinaryWriter for writing to the stream.
                using (BinaryWriter w = new BinaryWriter(stream))
                {
                    // Create a BinaryReader for reading from the stream.
                    using (BinaryReader r = new BinaryReader(stream))
                    {
                        // Start a dialog.
                        w.Write(Recipe10_10Shared.RequestConnect);

                        if (r.ReadString() == Recipe10_10Shared.AcknowledgeOK)
                        {
                            Console.WriteLine("Connected.");
                            Console.WriteLine("Press Enter to disconnect.");
                            Console.ReadLine();
                            Console.WriteLine("Disconnecting...");
                            w.Write(Recipe10_10Shared.Disconnect);
                        }

else
                        {
                            Console.WriteLine("Connection not completed.");
                        }
                    }
                }
            }
            catch (Exception err)
            {
                Console.WriteLine(err.ToString());
            }
            finally
            {
                // Close the connection socket.
                client.Close();
                Console.WriteLine("Port closed.");
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }
    }
}

Here's a sample connection transcript on the server side:

About to initialize port.
Listening for a connection...
Connection accepted.
Connection completed.

Disconnect request received.
Connection closed.
Listener stopped.

And here's a sample connection transcript on the client side:

Attempting to connect to the server on port 8000.
Connection established.
Connected.
Press Enter to disconnect.

Disconnecting...
Port closed.

The following example demonstrates various techniques for handling network connections and communications asynchronously. The server (Recipe10-11Server) starts a thread-pool thread listening for new connections using the TcpListener.BeginAcceptTcpClient method and specifying a callback method to handle the new connections. Every time a client connects to the server, the callback method obtains the new TcpClient object and passes it to a new threaded ClientHandler object to handle client communications.

The ClientHandler object waits for the client to request data and then sends a large amount of data (read from a file) to the client. This data is sent asynchronously, which means ClientHandler could continue to perform other tasks. In this example, it simply monitors the network stream for messages sent from the client. The client reads only a third of the data before sending a disconnect message to the server, which terminates the remainder of the file transfer and drops the client connection.

Here is the code for the shared protocol:

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public class Recipe10_11Shared
    {
        public const string AcknowledgeOK = "OK";
        public const string AcknowledgeCancel = "Cancel";
        public const string Disconnect = "Bye";
        public const string RequestConnect = "Hello";
        public const string RequestData = "Data";
    }
}

Here is the server code:

using System;
using System.IO;
using System.Net;
using System.Threading;
using System.Net.Sockets;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public class Recipe10_11Server
    {
        // A flag used to indicate whether the server is shutting down.
        private static bool terminate;
        public static bool Terminate { get { return terminate; } }

        // A variable to track the identity of each client connection.
        private static int ClientNumber = 0;

        // A single TcpListener will accept all incoming client connections.
        private static TcpListener listener;

        public static void Main()
        {

// Create a 100KB test file for use in the example. This file will be
            // sent to clients that connect.
            using (FileStream fs = new FileStream("test.bin", FileMode.Create))
            {
                fs.SetLength(100000);
            }

            try
            {
                // Create a TcpListener that will accept incoming client
                // connections on port 8000 of the local machine.
                listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 8000);

                Console.WriteLine("Starting TcpListener...");

                // Start the TcpListener accepting connections.
                terminate = false;
                listener.Start();

                // Begin asynchronously listening for client connections. When a
                // new connection is established, call the ConnectionHandler
                // method to process the new connection.
                listener.BeginAcceptTcpClient(ConnectionHandler, null);

                // Keep the server active until the user presses Enter.
                Console.WriteLine("Server awaiting connections. " +
                    "Press Enter to stop server.");
                Console.ReadLine();
            }
            finally
            {
                // Shut down the TcpListener. This will cause any outstanding
                // asynchronous requests to stop and throw an exception in
                // the ConnectionHandler when EndAcceptTcpClient is called.
                // More robust termination synchronization may be desired here,
                // but for the purpose of this example ClientHandler threads are
                // all background threads and will terminate automatically when
                // the main thread terminates. This is suitable for our needs.
                Console.WriteLine("Server stopping...");
                terminate = true;
                if (listener != null) listener.Stop();
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Server stopped. Press Enter");
            Console.ReadLine();
        }

        // A method to handle the callback when a connection is established
        // from a client. This is a simple way to implement a dispatcher

// but lacks the control and scalability required when implementing
        // full-blown asynchronous server applications.
        private static void ConnectionHandler(IAsyncResult result)
        {
            TcpClient client = null;

            // Always end the asynchronous operation to avoid leaks.
            try
            {
                // Get the TcpClient that represents the new client connection.
                client = listener.EndAcceptTcpClient(result);
            }
            catch (ObjectDisposedException)
            {
                // Server is shutting down and the outstanding asynchronous
                // request calls the completion method with this exception.
                // The exception is thrown when EndAcceptTcpClient is called.
                // Do nothing and return.
                return;
            }

            Console.WriteLine("Dispatcher: New connection accepted.");

            // Begin asynchronously listening for the next client
            // connection.
            listener.BeginAcceptTcpClient(ConnectionHandler, null);

            if (client != null)
            {
                // Determine the identifier for the new client connection.
                Interlocked.Increment(ref ClientNumber);
                string clientName = "Client " + ClientNumber.ToString();

                Console.WriteLine("Dispatcher: Creating client handler ({0})."
                    , clientName);

                // Create a new ClientHandler to handle this connection.
                new ClientHandler(client, clientName);
            }
        }
    }

    // A class that encapsulates the logic to handle a client connection.
    public class ClientHandler
    {
        // The TcpClient that represents the connection to the client.
        private TcpClient client;

        // An ID that uniquely identifies this ClientHandler.
        private string ID;

// The amount of data that will be written in one block (2KB).
        private int bufferSize = 2048;

        // The buffer that holds the data to write.
        private byte[] buffer;

        // Used to read data from the local file.
        private FileStream fileStream;

        // A signal to stop sending data to the client.
        private bool stopDataTransfer;

        internal ClientHandler(TcpClient client, string ID)
        {
            this.buffer = new byte[bufferSize];
            this.client = client;
            this.ID = ID;

            // Create a new background thread to handle the client connection
            // so that we do not consume a thread-pool thread for a long time
            // and also so that it will be terminated when the main thread ends.
            Thread thread = new Thread(ProcessConnection);
            thread.IsBackground = true;
            thread.Start();
        }

        private void ProcessConnection()
        {
            using (client)
            {
                // Create a BinaryReader to receive messages from the client. At
                // the end of the using block, it will close both the BinaryReader
                // and the underlying NetworkStream.
                using (BinaryReader reader = new BinaryReader(client.GetStream()))
                {
                    if (reader.ReadString() == Recipe10_11Shared.RequestConnect)
                    {
                        // Create a BinaryWriter to send messages to the client.
                        // At the end of the using block, it will close both the
                        // BinaryWriter and the underlying NetworkStream.
                        using (BinaryWriter writer =
                            new BinaryWriter(client.GetStream()))
                        {
                            writer.Write(Recipe10_11Shared.AcknowledgeOK);
                            Console.WriteLine(ID + ": Connection established.");

                            string message = "";

while (message != Recipe10_11Shared.Disconnect)
                            {
                                try
                                {
                                    // Read the message from the client.
                                    message = reader.ReadString();
                                }
                                catch
                                {
                                    // For the purpose of the example, any
                                    // exception should be taken as a
                                    // client disconnect.
                                    message = Recipe10_11Shared.Disconnect;
                                }

                                if (message == Recipe10_11Shared.RequestData)
                                {
                                    Console.WriteLine(ID + ": Requested data. ",
                                        "Sending...");

                                    // The filename could be supplied by the
                                    // client, but in this example a test file
                                    // is hard-coded.
                                    fileStream = new FileStream("test.bin",
                                        FileMode.Open, FileAccess.Read);

                                    // Send the file size--this is how the client
                                    // knows how much to read.
                                    writer.Write(fileStream.Length.ToString());

                                    // Start an asynchronous send operation.
                                    stopDataTransfer = false;
                                    StreamData(null);
                                }
                                else if (message == Recipe10_11Shared.Disconnect)
                                {
                                    Console.WriteLine(ID +
                                        ": Client disconnecting...");
                                    stopDataTransfer = true;
                                }
                                else
                                {
                                    Console.WriteLine(ID + ": Unknown command.");
                                }
                            }
                        }
                    }

else
                    {
                        Console.WriteLine(ID +
                            ": Could not establish connection.");
                    }
                }
            }

            Console.WriteLine(ID + ": Client connection closed.");
        }

        private void StreamData(IAsyncResult asyncResult)
        {
            // Always complete outstanding asynchronous operations to avoid leaks.
            if (asyncResult != null)
            {
                try
                {
                    client.GetStream().EndWrite(asyncResult);
                }
                catch
                {
                    // For the purpose of the example, any exception obtaining
                    // or writing to the network should just terminate the
                    // download.
                    fileStream.Close();
                    return;
                }
            }

            if (!stopDataTransfer && !Recipe10_11Server.Terminate)
            {
                // Read the next block from the file.
                int bytesRead = fileStream.Read(buffer, 0, buffer.Length);

                // If no bytes are read, the stream is at the end of the file.
                if (bytesRead > 0)
                {
                    Console.WriteLine(ID + ": Streaming next block.");

                    // Write the next block to the network stream.
                    client.GetStream().BeginWrite(buffer, 0, buffer.Length,
                        StreamData, null);
                }
                else
                {
                    // End the operation.
                    Console.WriteLine(ID + ": File streaming complete.");
                    fileStream.Close();
                }
            }

else
            {
                // Client disconnected.
                Console.WriteLine(ID + ": Client disconnected.");
                fileStream.Close();
            }
        }
    }
}

And here is the client code:

using System;
using System.Net;
using System.Net.Sockets;
using System.IO;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public class Recipe10_11Client
    {
        private static void Main()
        {
            using (TcpClient client = new TcpClient())
            {
                Console.WriteLine("Attempting to connect to the server ",
                    "on port 8000.");

                // Connect to the server.
                client.Connect(IPAddress.Parse("127.0.0.1"), 8000);

                // Retrieve the network stream from the TcpClient.
                using (NetworkStream networkStream = client.GetStream())
                {
                    // Create a BinaryWriter for writing to the stream.
                    using (BinaryWriter writer = new BinaryWriter(networkStream))
                    {
                        // Start a dialog.
                        writer.Write(Recipe10_11Shared.RequestConnect);

                        // Create a BinaryReader for reading from the stream.
                        using (BinaryReader reader =
                            new BinaryReader(networkStream))
                        {
                            if (reader.ReadString() ==
                                Recipe10_11Shared.AcknowledgeOK)
                            {
                                Console.WriteLine("Connection established." +
                                    "Press Enter to download data.");

                                Console.ReadLine();

// Send message requesting data to server.
                                writer.Write(Recipe10_11Shared.RequestData);

                                // The server should respond with the size of
                                // the data it will send. Assume it does.
                                int fileSize = int.Parse(reader.ReadString());

                                // Only get part of the data, then carry out a
                                // premature disconnect.
                                for (int i = 0; i < fileSize / 3; i++)
                                {
                                    Console.Write(networkStream.ReadByte());
                                }

                                Console.WriteLine(Environment.NewLine);
                                Console.WriteLine("Press Enter to disconnect.");
                                Console.ReadLine();
                                Console.WriteLine("Disconnecting...");
                                writer.Write(Recipe10_11Shared.Disconnect);
                            }
                            else
                            {
                                Console.WriteLine("Connection not established.");
                            }
                        }
                    }
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Connection closed. Press Enter");
            Console.ReadLine();
        }
    }
}

The application shown in the following code uses two threads: one to receive messages and one to send them. The application stops when the user presses the Enter key without any text to send. Notice that UDP applications cannot use the NetworkStream abstraction that TCP applications can. Instead, they must convert all data to a stream of bytes using an encoding class, as described in recipe 2-2.

using System;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_12
    {
        private static int localPort;

        private static void Main()
        {
            // Define endpoint where messages are sent.
            Console.Write("Connect to IP: ");
            string IP = Console.ReadLine();
            Console.Write("Connect to port: ");
            int port = Int32.Parse(Console.ReadLine());

            IPEndPoint remoteEndPoint =
                new IPEndPoint(IPAddress.Parse(IP), port);

            // Define local endpoint (where messages are received).
            Console.Write("Local port for listening: ");
            localPort = Int32.Parse(Console.ReadLine());

            // Create a new thread for receiving incoming messages.
            Thread receiveThread = new Thread(ReceiveData);
            receiveThread.IsBackground = true;
            receiveThread.Start();

UdpClient client = new UdpClient();

            Console.WriteLine("Type message and press Enter to send:");

            try
            {
                string text;

                do
                {
                    text = Console.ReadLine();

                    // Send the text to the remote client.
                    if (text.Length != 0)
                    {
                        // Encode the data to binary using UTF8 encoding.
                        byte[] data = Encoding.UTF8.GetBytes(text);

                        // Send the text to the remote client.
                        client.Send(data, data.Length, remoteEndPoint);
                    }
                } while (text.Length != 0);
            }
            catch (Exception err)
            {
                Console.WriteLine(err.ToString());
            }
            finally
            {
                client.Close();
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter");
            Console.ReadLine();
        }

        private static void ReceiveData()
        {
            UdpClient client = new UdpClient(localPort);

            while (true)
            {
                try
                {
                    // Receive bytes.
                    IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
                    byte[] data = client.Receive(ref anyIP);

// Convert bytes to text using UTF8 encoding.
                    string text = Encoding.UTF8.GetString(data);

                    // Display the retrieved text.
                    Console.WriteLine(">> " + text);
                }
                catch (Exception err)
                {
                    Console.WriteLine(err.ToString());
                }
            }
        }
    }
}

To test this application, load two instances at the same time. On computer A, specify the IP address for computer B. On computer B, specify the address for computer A. You can then send text messages back and forth at will. You can test this application with clients on the local computer using the loopback alias 127.0.0.1, provided you use different listening ports. For example, imagine a situation with two UDP clients, client A and client B. Here's a sample transcript for client A:

Connect to IP: 127.0.0.1
Connect to port: 8001
Local port for listening: 8080

Hi there!

And here's the corresponding transcript for client B (with the received message):

Connect to IP: 127.0.0.1
Connect to port: 8080
Local port for listening: 8001

>> Hi there!

The following example demonstrates the creation of a simple SOAP-based web service that allows you to create, update, find, and delete employee records. The example is self-hosted, but could be moved to IIS or WAS without changes to the service code. The IEmployeeService interface defines the service contract.

using System;
using System.ServiceModel;

namespace Apress.VisualCSharpRecipes.Chapter10
{

[ServiceContract(Namespace = "Apress.VisualCSharpRecipes.Chapter10")]
    public interface IEmployeeService
    {
        [OperationContract]
        Employee CreateEmployee(Employee newEmployee);

        [OperationContract]
        bool DeleteEmployee(int employeeId);

        [OperationContract(Name="GetEmployeeById")]
        Employee GetEmployee(int employeeId);

        [OperationContract(Name = "GetEmployeeByName")]
        Employee GetEmployee(string employeeName);

        [OperationContract]
        Employee UpdateEmployee(Employee updatedEmployee);
    }
}

Here is the class that declares the Employee data contract representing the data that is passed between the client and the service:

using System;
using System.Runtime.Serialization;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    [DataContract]
    public class Employee
    {
        [DataMember]
        public DateTime DateOfBirth { get; set; }

        [DataMember]
        public int Id { get; set; }

        [DataMember]
        public string Name { get; set; }
    }
}

The EmployeeService class implements the IEmployeeService interface and provides the actual logic of the web service.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Apress.VisualCSharpRecipes.Chapter10
{

public class EmployeeService : IEmployeeService
    {
        private Dictionary<int, Employee> employees;

        public EmployeeService()
        {
            employees = new Dictionary<int, Employee>();
        }

        // Create an Employee based on the contents of a provided
        // Employee object. Return the new Employee object.
        public Employee CreateEmployee(Employee newEmployee)
        {
            // NOTE: Should validate new employee data.
            newEmployee.Id = employees.Count + 1;

            lock (employees)
            {
                employees[newEmployee.Id] = newEmployee;
            }

            return newEmployee;
        }

        // Delete an employee by the specified Id and return true
        // or false depending on if an Employee was deleted.
        public bool DeleteEmployee(int employeeId)
        {
            lock(employees)
            {
                return employees.Remove(employeeId);
            }
        }

        // Get an employee by the specified Id and return null if
        // the employee does not exist.
        public Employee GetEmployee(int employeeId)
        {
            Employee employee = null;

            lock (employees)
            {
                employees.TryGetValue(employeeId, out employee);
            }

            return employee;
        }

// Get an employee by the specified Name and return null if
        // the employee does not exist.
        public Employee GetEmployee(string employeeName)
        {
            Employee employee = null;

            lock (employees)
            {
                employee = employees.Values.FirstOrDefault
                    (e => e.Name.ToLower() == employeeName.ToLower());
            }

            return employee;
        }

        // Update an employee based on the contents of a provided
        // Employee object. Return the updated Employee object.
        public Employee UpdateEmployee(Employee updatedEmployee)
        {
            Employee employee = GetEmployee(updatedEmployee.Id);

            // NOTE: Should validate new employee data.
            if (employee != null)
            {
                lock (employees)
                {
                    employees[employee.Id] = updatedEmployee;
                }
            }

            return updatedEmployee;
        }
    }
}

The following code shows the simple service host created to run the service:

using System;
using System.ServiceModel;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    public static class Recipe10_13Service
    {
        static void Main(string[] args)
        {
            ServiceHost host = new ServiceHost(typeof(EmployeeService));
            host.Open();

// Wait to continue.
            Console.WriteLine("Service host running. Press Enter to terminate.");
            Console.ReadLine();
        }
    }
}

The following shows the configuration information used by the service host:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <behaviors>
      <serviceBehaviors>
        <behavior name="EmployeeServiceBehavior" >
          <serviceMetadata httpGetEnabled="true" />
        </behavior>
      </serviceBehaviors>
    </behaviors>
    <services>
      <service name="Apress.VisualCSharpRecipes.Chapter10.EmployeeService"
               behaviorConfiguration="EmployeeServiceBehavior">
        <endpoint address="http://localhost:8000/EmployeeService"
                  binding="wsHttpBinding"
                  contract="Apress.VisualCSharpRecipes.Chapter10.IEmployeeService" />
        <endpoint address="http://localhost:8000/EmployeeService/mex"
                  binding="mexHttpBinding"
                  contract="IMetadataExchange" />
        <host>
          <baseAddresses>
            <add baseAddress="http://localhost:8000/" />
          </baseAddresses>
        </host>
      </service>
    </services>
  </system.serviceModel>
</configuration>

Finally, the following simple client code demonstrates how to interact with the service via a proxy:

using System;
using Apress.VisualCSharpRecipes.Chapter10.Services;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_13Client
    {
        private static string FormatEmployee(Employee emp)
        {

return String.Format("ID:{0}, NAME:{1}, DOB:{2}",
                emp.Id, emp.Name, emp.DateOfBirth);
        }

        static void Main(string[] args)
        {
            // Create a service proxy.
            using (EmployeeServiceClient employeeService
                = new EmployeeServiceClient())
            {
                // Create a new Employee.
                Employee emp = new Employee()
                {
                    DateOfBirth = DateTime.Now,
                    Name = "Allen Jones"
                };

                // Call the EmployeeService to create a new Employee record.
                emp = employeeService.CreateEmployee(emp);

                Console.WriteLine("Created employee record - {0}",
                    FormatEmployee(emp));

                // Update the existing Employee.
                emp.DateOfBirth = new DateTime(1950, 10, 13);
                emp = employeeService.UpdateEmployee(emp);

                Console.WriteLine("Updated employee record - {0}",
                    FormatEmployee(emp));

                // Wait to continue.
                Console.WriteLine(Environment.NewLine);
                Console.WriteLine("Main method complete. Press Enter");
                Console.ReadLine();
            }
        }
    }
}

The following code demonstrates the use of a dynamic service proxy to communicate with a WCF service. The service used in this example is basically the same as that used in recipe 10-13. Instead of using Visual Studio to generate a proxy class, the client project contains a reference to the service project. The reference gives the client code access to the service and data contract classes of the service, enabling the use of the ChannelFactory to create dynamic service proxies at runtime.

using System;
using System.ServiceModel;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_14Client
    {
        static void Main(string[] args)
        {
            string serviceUri = "http://localhost:8000/EmployeeService";

            // Create the ChannelFactory that is used to generate service
            // proxies.
            using (ChannelFactory<IEmployeeService> channelFactory =
                new ChannelFactory<IEmployeeService>(new WSHttpBinding(), serviceUri))
            {
                // Create a dynamic proxy for IEmployeeService.
                IEmployeeService proxy = channelFactory.CreateChannel();

                // Create a new Employee.
                Employee emp = new Employee()
                {
                    DateOfBirth = DateTime.Now,
                    Name = "Allen Jones"
                };

// Call the EmployeeService to create a new Employee record.
                emp = proxy.CreateEmployee(emp);

                Console.WriteLine("Created employee record - {0}", emp);

                // Update an existing Employee record.
                emp.DateOfBirth = new DateTime(1950, 10, 13);
                emp = proxy.UpdateEmployee(emp);

                Console.WriteLine("Updated employee record - {0}", emp);

                // Wait to continue.
                Console.WriteLine(Environment.NewLine);
                Console.WriteLine("Main method complete. Press Enter");
                Console.ReadLine();
            }
        }
    }
}

The following example takes the URL of a feed as a command-line argument, downloads the feed, determines whether it is an RSS or Atom feed, and parses it using the appropriate SyndicationFeedFormatter. The output from running the example contains the title and description of the overall feed, and then the title, summary, and publication date of each item in the feed.

using System;
using System.Net;
using System.ServiceModel.Syndication;
using System.Xml.Linq;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_15
    {
        static void Main(string[] args)
        {
            Uri feedUrl = null;

if (args.Length == 0 || String.IsNullOrEmpty(args[0])
                || !Uri.TryCreate(args[0], UriKind.RelativeOrAbsolute,
                    out feedUrl))
            {
                // Error and wait to continue.
                Console.WriteLine("Invalid feed URL. Press Enter.");
                Console.ReadLine();
                return;
            }

            // Create the web request based on the URL provided for the feed.
            WebRequest req = WebRequest.Create(feedUrl);

            // Get the data from the feed.
            WebResponse res = req.GetResponse();

            // Simple test for the type of feed: Atom 1.0 or RSS 2.0.
            SyndicationFeedFormatter formatter = null;
            XElement feed = XElement.Load(res.GetResponseStream());

            if (feed.Name.LocalName == "rss")
            {
                formatter = new Rss20FeedFormatter();
            }
            else if (feed.Name.LocalName == "feed")
            {
                formatter = new Atom10FeedFormatter();
            }
            else
            {
                // Error and wait to continue.
                Console.WriteLine("Unsupported feed type: "
                    + feed.Name.LocalName);
                Console.ReadLine();
                return;
            }

            // Read the feed data into the formatter.
            formatter.ReadFrom(feed.CreateReader());

            // Display feed level data:
            Console.WriteLine("Title: " + formatter.Feed.Title.Text);
            Console.WriteLine("Description: "
                + formatter.Feed.Description.Text);
            Console.Write(Environment.NewLine);
            Console.WriteLine("Items: ");

// Display the item data.
            foreach (var item in formatter.Feed.Items)
            {
                Console.WriteLine("	Title: " + item.Title.Text);
                Console.WriteLine("	Summary: " + item.Summary.Text);
                Console.WriteLine("	Publish Date: " + item.PublishDate);
                Console.Write(Environment.NewLine);
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following code demonstrates the use of the Uri and UriBuilder classes.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Apress.VisualCSharpRecipes.Chapter10
{
    class Recipe10_16
    {
        private static string defualtUrl
            = "http://www.apress.com:80/book/view/9781430225256";

        static void Main(string[] args)
        {
            Uri uri = null;

            // Extract information from a string URL passed as a
            // command line argument or use the default URL.
            string strUri = defualtUrl;

            if (args.Length > 0 && !String.IsNullOrEmpty(args[0]))
            {
                strUri = args[0];
            }

            // Safely parse the url
            if (Uri.TryCreate(strUri, UriKind.RelativeOrAbsolute, out uri))
            {
                Console.WriteLine("Parsed URI: " + uri.OriginalString);
                Console.WriteLine("	Scheme: " + uri.Scheme);
                Console.WriteLine("	Host: " + uri.Host);
                Console.WriteLine("	Port: " + uri.Port);
                Console.WriteLine("	Path and Query: " + uri.PathAndQuery);
            }

else
            {
                Console.WriteLine("Unable to parse URI: " + strUri);
            }

            // Create a new URI.
            UriBuilder newUri = new UriBuilder();
            newUri.Scheme = "http";
            newUri.Host = "www.apress.com";
            newUri.Port = 80;
            newUri.Path = "book/view/9781430225256";

            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Created URI: " + newUri.Uri.AbsoluteUri);

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}