Introduction
This simple project can be used instead of TcpClient
, TcpListen
- socket classes, because it's easy. You can create a server application in just three or four lines of code, and a client application in just two lines of code. This is the main idea of this article.
ConnectionSocket Class
Use this class instead of TcpClient
class. Create an instance of it and use the function Connect
to connect to a remote endpoint, and Send
to send data. When the receive
event fires, then there is a data that has been sent to you from the remote endpoint.
Host
string
, specifies the IP, it can be (e.g. "127.0.0.1") or (e.g. "www.codeproject.com").
port
int
, specifies the port in the remote endpoint that there is a socket listening to it.
Mode
One of the ConnectionMode
enum
, it is recommended to use SyncConnectAsyncRecv
, other options can also be used.
Bind
This function is optional to use, use it to bind this socket to a specific endpoint. If you don't use this function the framework will bind the socket for you.
Send
Send the array of bytes to the remote endpoint, use this function for a connected socket only.
Receive
This function is used in Blocking
mode, to receive data from the remote endpoint, if there is no data received then the thread will be blocked until the data is made available. (It is not recommended to use this function for receiving data.)
Length
int
, the maximum length of the array that can be passed to the buffer. If the received data is greater than the Length
, then the returned array will contain only the data of size Length
, you must call Receive
again to receive the other data. If the received data is less than the Length
, then the returned array will be of the size of the data received.
Close
Use this function to close any created socket, for every created socket you must call close socket
to close the socket.
Shutdown
Use this function to disable send
or receive
or both, the param is documented in the MSDN.
recieve
event
Fired when there is data available to be received, the RecieveEventArg
contains the data and the data length that is received, don't call Recieve
in the recieve
event, it will receive the next available data.
create
event
Fired when the socket is created.
connect
event
Fired in non Blocking
mode (or AsyncConnectionxxxxxxxxx
) when the connection is accepted by the remote endpoint.
shutdown
event
Fired when calling the shutdown function.
send
event
Fired after the send process ends.
close
event
Fired if the close
function is called or if the remote endpoint closes the connection or if there is any socket exception received. CloseEventArgs
contains the exception and a string
that specifies the error. You can use it in a message box.
ListenSocket Class
Use this call, instead of the TcpListen
class. You can start listen, stop listen and accept connection from a remote end point.
IsBlocked
If true
, the accept
event will not be fired when there is a request for connection, you must call the Accept
function. If false
, then the accept
event fires.
StopListen
Stop listening.
close
Use this function to close any created socket, for every socket created, you must call close socket
to close the socket.
Accept
Use this function if you pass true
to StartListen
. This function will block the thread, until a remote endpoint request connection is made.
create
event
Fired after creating the socket.
close
event
Fired if the close
function is called or if the remote endpoint closes the connection or if there is any socket exception received. CloseEventArgs
contains the exception and a string
that specifies the error. You can use it in a message box.
accept
event
Fired when a connection is accepted from the remote endpoint. The AcceptEventArgs
contains a connected socket that is used to create a connection.
Example
- Create a new Windows application project, named
SimpleServer
. - Right click on the Toolbox - add/remove item.
- Click Browse - select sockets.dll (download it from this article).
- Click OK.
- The two classes
ConnectSocket
, ListenSocket
are now in the Toolbox.
First drag one listen socket and one connect socket to your dialog. Change the port of the listen socket to 4000, from the properties. Change IsBlocked
of the connect socket to false
. Add a button, name it Listen
, and handle the Click
event:
private void button1_Click(object sender, System.EventArgs e)
{
Socket_Listen.StratListen(false);
}
Add a TextBox
for sending a message and add a Button
named send
, to send the text to the client, handle the clicked
event:
private void button2_Click(object sender, System.EventArgs e)
{
byte[] buff = Socktes.ByesConvertor.GetBytes(textBox1.Text);
Socket_Connection.Send(buff);
}
Add a ListBox
to add the received messages.
Let's get to the main code of the project. For the listen socket, handle the accept
event:
private void Socket_Listen_accept(object Sender, Socktes.AcceptEventArgs e)
{
Socket_Connection.SocketHandle = e.ConnectedSocket;
}
For the connect socket, handle the receive
event:
private void Socket_Connection_recieve(object Sender,
Socktes.RecieveEventArgs e)
{
string s = Socktes.ByesConvertor.BytesToString(e.Data);
listBox1.Items.Add(s);
}
That's all the code for the server, now let's go to the client.
Create a new Windows application, named SimpleClient
. Drag one connect socket to your form, change IsBlocked
to false
. Add a Button
, name it connect
, now handle the Click
event:
private void button1_Click(object sender, System.EventArgs e)
{
Socket_Connection.Connect("127.0.0.1",4000);
}
Add a TextBox
and a Button
, handle the Click
event:
private void button2_Click(object sender, System.EventArgs e)
{
byte[] b = Socktes.ByesConvertor.GetBytes(textBox1.Text);
Socket_Connection.Send(b);
}
Add a ListBox
, handle the receive
event of the connect socket:
private void Socket_Connection_recieve(object Sender, Socktes.RecieveEventArgs e)
{
string s = Socktes.ByesConvertor.BytesToString(e.Data);
listBox1.Items.Add(s);
}
That's all about the client and the server. Sorry for not commenting the demo, but Socket.dll is well commented.
This member has not yet provided a Biography. Assume it's interesting and varied, and probably something to do with programming.