An Introduction to Socket Programming in .NET（转载）

Introduction

In this article, we will learn the basics of socket programming in .NET Framework using C#. Secondly, we will create a small application consisting of a server and a client, which will communicate using TCP and UDP protocols.
Pre-requisites

    * Must be familiar with .NET Framework.
    * Should have good knowledge of C#.
    * Basic knowledge of socket programming.

1.1 Networking basics:

Inter-Process Communication i.e. the capability of two or more physically connected machines to exchange data, plays a very important role in enterprise software development. TCP/IP is the most common standard adopted for such communication. Under TCP/IP each machine is identified by a unique 4 byte integer referred to as its IP address (usually formatted as 192.168.0.101). For easy remembrance, this IP address is mostly bound to a user-friendly host name. The program below (showip.cs) uses the System.Net.Dns class to display the IP address of the machine whose name is passed in the first command-line argument. In the absence of command-line arguments, it displays the name and IP address of the local machine.

using System;
using System.Net;
class ShowIP{
    public static void Main(string[] args){
        string name = (args.Length < 1) ? Dns.GetHostName() : args[0];
        try{
            IPAddress[] addrs = Dns.Resolve(name).AddressList;
            foreach(IPAddress addr in addrs)
                Console.WriteLine("{0}/{1}",name,addr);
        }catch(Exception e){
            Console.WriteLine(e.Message);
        }
    }
}

Dns.GetHostName() returns the name of the local machine and Dns.Resolve() returns IPHostEntry for a machine with a given name, the AddressList property of which returns the IPAdresses of the machine. The Resolve method will cause an exception if the mentioned host is not found.

Though IPAddress allows to identify machines in the network, each machine may host multiple applications which use network for data exchange. Under TCP/IP, each network oriented application binds itself to a unique 2 byte integer referred to as its port-number which identifies this application on the machine it is executing. The data transfer takes place in the form of byte bundles called IP Packets or Datagrams. The size of each datagram is 64 KByte and it contains the data to be transferred, the actual size of the data, IP addresses and port-numbers of sender and the prospective receiver. Once a datagram is placed on a network by a machine, it will be received physically by all the other machines but will be accepted only by that machine whose IP address matches with the receiver’s IP address in the packet. Later on, this machine will transfer the packet to an application running on it which is bound to the receiver’s port-number present in the packet.

TCP/IP suite actually offers two different protocols for data exchange. The Transmission Control Protocol (TCP) is a reliable connection oriented protocol while the User Datagram Protocol (UDP) is not very reliable (but fast) connectionless protocol.
1.2 Client-Server programming with TCP/IP:

Under TCP there is a clear distinction between the server process and the client process. The server process starts on a well known port (which the clients are aware of) and listens for incoming connection requests. The client process starts on any port and issues a connection request.

The basic steps to create a TCP/IP server are as follows:

   1. Create a System.Net.Sockets.TcpListener with a given local port and start it:

      TcpListener listener = new TcpListener(local_port);
      listener.Start();

   2. Wait for the incoming connection request and accept a System.Net.Sockets.Socket object from the listener whenever the request appears:

      Socket soc = listener.AcceptSocket(); // blocks

   3. Create a System.Net.Sockets.NetworkStream from the above Socket:

      Stream s = new NetworkStream(soc);

   4. Communicate with the client using the predefined protocol (well established rules for data exchange):
   5. Close the Stream:

      s.Close();

   6. Close the Socket:

      s.Close();

   7. Go to Step 2.

Note when one request is accepted through step 2 no other request will be accepted until the code reaches step 7. (Requests will be placed in a queue or backlog.) In order to accept and service more than one client concurrently, steps 2 – 7 must be executed in multiple threads. Program below (emptcpserver.cs) is a multithreaded TCP/IP server which accepts employee name from its client and sends back the job of the employee. The client terminates the session by sending a blank line for the employee’s name. The employee data is retrieved from the application’s configuration file (an XML file in the directory of the application and whose name is the name of the application with a .config extension).
Collapse

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

class EmployeeTCPServer{
    static TcpListener listener;
    const int LIMIT = 5; //5 concurrent clients
    
    public static void Main(){
        listener = new TcpListener(2055);
        listener.Start();
        #if LOG
            Console.WriteLine("Server mounted,
                            listening to port 2055");
        #endif
        for(int i = 0;i < LIMIT;i++){
            Thread t = new Thread(new ThreadStart(Service));
            t.Start();
        }
    }
    public static void Service(){
        while(true){
            Socket soc = listener.AcceptSocket();
            //soc.SetSocketOption(SocketOptionLevel.Socket,
            //        SocketOptionName.ReceiveTimeout,10000);
            #if LOG
                Console.WriteLine("Connected: {0}",
                                         soc.RemoteEndPoint);
            #endif
            try{
                Stream s = new NetworkStream(soc);
                StreamReader sr = new StreamReader(s);
                StreamWriter sw = new StreamWriter(s);
                sw.AutoFlush = true; // enable automatic flushing
                sw.WriteLine("{0} Employees available",
                      ConfigurationSettings.AppSettings.Count);
                while(true){
                    string name = sr.ReadLine();
                    if(name == "" || name == null) break;
                    string job =
                        ConfigurationSettings.AppSettings[name];
                    if(job == null) job = "No such employee";
                    sw.WriteLine(job);
                }
                s.Close();
            }catch(Exception e){
                #if LOG
                    Console.WriteLine(e.Message);
                #endif
            }
            #if LOG
                Console.WriteLine("Disconnected: {0}",
                                        soc.RemoteEndPoint);
            #endif
            soc.Close();
        }
    }
}

Here is the content of the configuration file (emptcpserver.exe.config) for the above application:

<configuration>
    <appSettings>
        <add key = "john" value="manager"/>
        <add key = "jane" value="steno"/>
        <add key = "jim" value="clerk"/>
        <add key = "jack" value="salesman"/>
    </appSettings>
</configuration>

The code between #if LOG and #endif will be added by the compiler only if the symbol LOG is defined during compilation (conditional compilation). You can compile the above program either by defining the LOG symbol (information is logged on the screen):

    * csc /D:LOG emptcpserver.cs

or without the LOG symbol (silent mode):

    * csc emptcpserver.cs

Mount the server using the command start emptcpserver.

To test the server you can use: telnet localhost 2055.

Or, we can create a client program. Basic steps for creating a TCP/IP client are as follows:

   1. Create a System.Net.Sockets.TcpClient using the server’s host name and port:

      TcpClient client = new TcpClient(host, port);

   2. Obtain the stream from the above TCPClient.

      Stream s = client.GetStream()

   3. Communicate with the server using the predefined protocol.
   4. Close the Stream:

      s.Close();

   5. Close the connection:

      client.Close();

The program below (emptcpclient.cs) communicates with EmployeeTCPServer:
Collapse

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

class EmployeeTCPClient{
    public static void Main(string[] args){
        TcpClient client = new TcpClient(args[0],2055);
        try{
            Stream s = client.GetStream();
            StreamReader sr = new StreamReader(s);
            StreamWriter sw = new StreamWriter(s);
            sw.AutoFlush = true;
            Console.WriteLine(sr.ReadLine());
            while(true){
                Console.Write("Name: ");
                string name = Console.ReadLine();
                sw.WriteLine(name);
                if(name == "") break;
                Console.WriteLine(sr.ReadLine());
            }
            s.Close();
        }finally{
            // code in finally block is guranteed
            // to execute irrespective of
            // whether any exception occurs or does
            // not occur in the try block
            client.Close();
        }
    }
}

1.3 Multicasting with UDP

Unlike TCP, UDP is connectionless i.e. data can be send to multiple receivers using a single socket. Basic UDP operations are as follows:

   1. Create a System.Net.Sockets.UdpClient either using a local port or remote host and remote port:

      UdpClient client = new UdpClient(local_ port);

      or

      UdpClient client = new UdpClient(remote_host, remote_port);

   2. Receive data using the above UdpClient:

      System.Net.IPEndPoint ep = null;
      byte[] data = client.Receive(ref ep);

      byte array data will contain the data that was received and ep will contain the address of the sender.
   3. Send data using the above UdpClient..

      If the remote host name and the port number have already been passed to the UdpClient through its constructor, then send byte array data using:

      client.Send(data, data.Length);

      Otherwise, send byte array data using IPEndPoint ep of the receiver:

      client.Send(data, data.Length, ep);

The program below (empudpserver.cs) receives the name of an employee from a remote client and sends it back the job of that employee using UDP:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Configuration;

class EmployeeUDPServer{
    public static void Main(){
        UdpClient udpc = new UdpClient(2055);
        Console.WriteLine("Server started, servicing on port 2055");
        IPEndPoint ep = null;
        while(true){
            byte[] rdata = udpc.Receive(ref ep);
            string name = Encoding.ASCII.GetString(rdata);
            string job = ConfigurationSettings.AppSettings[name];
            if(job == null) job = "No such employee";
            byte[] sdata = Encoding.ASCII.GetBytes(job);
            udpc.Send(sdata,sdata.Length,ep);
        }
    }
}

Here is the content of the configuration file (empudpserver.exe.config) for above application:

<configuration>
    <appSettings>
        <add key = "john" value="manager"/>
        <add key = "jane" value="steno"/>
        <add key = "jim" value="clerk"/>
        <add key = "jack" value="salesman"/>
    </appSettings>
</configuration>

The next program (empudpclient.cs) is a UDP client to the above server program:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
class EmployeeUDPClient{
    public static void Main(string[] args){
        UdpClient udpc = new UdpClient(args[0],2055);
        IPEndPoint ep = null;
        while(true){
            Console.Write("Name: ");
            string name = Console.ReadLine();
            if(name == "") break;
            byte[] sdata = Encoding.ASCII.GetBytes(name);
            udpc.Send(sdata,sdata.Length);
            byte[] rdata = udpc.Receive(ref ep);
            string job = Encoding.ASCII.GetString(rdata);
            Console.WriteLine(job);
        }
    }
}

UDP also supports multicasting i.e. sending a single datagram to multiple receivers. To do so, the sender sends a packet to an IP address in the range 224.0.0.1 – 239.255.255.255 (Class D address group). Multiple receivers can join the group of this address and receive the packet. The program below (stockpricemulticaster.cs) sends a datagram every 5 seconds containing the share price (a randomly calculated value) of an imaginary company to address 230.0.0.1:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
class StockPriceMulticaster{
    static string[] symbols = {"ABCD","EFGH", "IJKL", "MNOP"};
    public static void Main(){
        UdpClient publisher = new UdpClient("230.0.0.1",8899);
        Console.WriteLine("Publishing stock prices to 230.0.0.1:8899");
        Random gen = new Random();
        while(true){
            int i = gen.Next(0,symbols.Length);
            double price = 400*gen.NextDouble()+100;
            string msg = String.Format("{0} {1:#.00}",symbols,price);
            byte[] sdata = Encoding.ASCII.GetBytes(msg);
            publisher.Send(sdata,sdata.Length);
            System.Threading.Thread.Sleep(5000);
        }
    }
}

Compile and start stockpricemulticaster.

The next program (stockpricereceiver.cs) joins the group of address 230.0.0.1, receives 10 stock prices and then leaves the group:

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
class StockPriceReceiver{
    public static void Main(){
        UdpClient subscriber = new UdpClient(8899);
        IPAddress addr = IPAddress.Parse("230.0.0.1");
        subscriber.JoinMulticastGroup(addr);
        IPEndPoint ep = null;
        for(int i=0; i<10;i++){
            byte[] pdata = subscriber.Receive(ref ep);
            string price = Encoding.ASCII.GetString(pdata);
            Console.WriteLine(price);
        }
        subscriber.DropMulticastGroup(addr);
    }
}

Compile and run stockpricereceiver.