With this info lets now try to check the code behind this:
Socket programming in .NET is made possible by the Socket class present inside the System.Net.Sockets namespace. This Socket class has several method and properties and a constructor. The first step is to create an object of this class. Since there is only one constructor we have no choice but to use it.
Here is how to create the socket:
m_socListener = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
The first parameter is the address family which we will use, in this case,
interNetwork (which is IP version 4) - other options include Banyan
NetBios, AppleTalk etc. (
AddressFamily is an enum defined in Sockets
namespace). Next we need to specify socket type: and we would use reliable
two way connection-based sockets (stream) instead of un-reliable Connectionless
. So we obviously specify stream as the socket type and finally we are using
TCP/IP so we would specify protocol type as
Once we have created a Socket we need to make a connection to the server
since we are using connection-based communication.
To connect to the remote computer we need to know the IP Address and port
at which to connect.
In .NET there is a class under
System.Net namespace called
represents a network computer as an IP address and a port number.
IPEndPoint has two constructors - one that takes a IP Address and Port
number and one that takes long and port number. Since we have computer
IP address we would use the former
public IPEndPoint(System.Net.IPAddress address, int port);
As you can see the first parameter takes a IPAddress object. If you examine
IPAddress class you will see that it has a static method called
IPAddress given a string (of dot notation) and second
parameter will be the port number. Once we have endpoint ready we can use
of this Socket class to connect to the end point ( remote server computer ).
Here is the code:
System.Net.IPAddress ipAdd = System.Net.IPAddress.Parse("10.10.101.200");
System.Net.IPEndPoint remoteEP = new IPEndPoint (iAdd,8221);
These three lines of code will make a connection to the remote host running on computer with IP 10.10.101.200 and listening at port 8221. If the Server is running and started ( listening ), the connection will succeed. If however the server is not running an exception called SocketException will be thrown. If you catch the exception and check the Message property of the exception in this case you see following text:
"No connection could be made because the target machine
actively refused it."
Similarly if you already have made a connection and the server somehow dies , you will get following exception if you try to send data.
"An existing connection was forcibly closed by the
Assuming that the connection is made, you can send data to other side using the Send method of the Socket class. Send method has several overloads. All of them take a byte array . For example if you want to send "Hello There" to host you can use following call:
String szData = "Hello There";
byte byData = System.Text.Encoding.ASCII.GetBytes(szData);
catch (SocketException se)
MessageBox.Show ( se.Message );
Note that the
Send method is blocking. This means the call will block (wait)
till the data has been sent or an exception has been thrown. There is an non-blocking
version of the send which we will discuss in the next part
this article. Similar to Send there is a
Receive method on the Socket class. You can receive
data using following call:
byte  buffer = new byte;
int iRx = m_socClient.Receive (buffer);
Receive method again is blocking. It means that if there is no data available
the call will block until some data arrives or an exception is thrown.
Non-blocking version of Receive method is more useful than the non-blocking version of
Send because if we opt for block
Receive , we are effectively doing
polling. There is no events about data arrival. This model does not work well
for serious applications. But all that is the subject of our next part of this
article. For now we will settle with the blocking version.