Yeah, yeah, I know, right! Who uses Vb 6 in 2012, 2015 2016 anymore? And who for goodness’ sake would want to implement System.Net.Sockets.Socket the same way Winsock was implemented in Visual Basic 6? Well, I have news for you: many (and I mean a lot) of developers STILL use VB6 all around the world. A huge percentage of them are still learning .NET and getting used to the Object Oriented Programming paradigm. These people have no idea how it all works and I don’t blame them: OOP concepts were difficult for me to grasp back in 2004 when I started learning about them.

So, how do you cope with all these new changes? Well, with a lot of practice and patience you will – in time – get the hang of it, but you will never stop learning (there is always something good and better to learn). I know there are a bunch of developers out there who kind of have a similar background as me, and want to help people to become better. They also struggled with .NET and don’t want fellow developers to go through these changes and challenges without any kind of assistance. With this in mind, consider this (and maybe some more posts to come) as my tiny contribution to those who come from VB 6 and are still learning .NET.

Someone did a really good job at describing the Winsock interface already, so I will not even talk about it. But, if you have had the opportunity to work with them in VB 6 (like I did), you will remember that it was pretty simple to use, you just had to Connect and take care of the events it raised. It is nothing like it in .NET. In fact, it is so different that the first time you use it you will puke rainbows. Another peculiar (and disappointing when I tried it) thing is that if you try to import VB 6 code to .NET using Winsocks, the process won’t work, and finish with a lot of errors. After all, the Import tool is not as magical as I thought it was.

There are many tutorials in the Web explaining how to use Sockets in .net (I will post a couple at the bottom). But the purpose of this particular post is to give you one class that will help you see one way in which you can use the Socket class. There are many other ways to use it, but my main goal when making this was to create the sense that you are still using VB 6 Socket (but who would want that, right?)

Imports System.Net.Sockets
Imports System.Net
Imports System.Text.Encoding

Public Class HSocket
   Private Class SocketHolder
      Private _socket As Socket

      Private _DataBuffer As Byte() = New Byte(1024) {}

      Public Property Socket() As Socket
         Get
            Return _socket
         End Get
         Set(ByVal value As Socket)
            _socket = value
         End Set
      End Property

      Public Property DataBuffer() As Byte()
         Get
            Return _DataBuffer
         End Get
         Set(ByVal value As Byte())
            _DataBuffer = value
         End Set
      End Property
   End Class

   'Enums
   Public Enum SocketStatus
      Connected = 0
      Connecting = 1
      Sending = 2
      Receiving = 3
      Disconnecting = 4
      Disconnected = 5
   End Enum

   'Members
   Private _sock As SocketHolder
   Private _socketStatus As SocketStatus
   Private _pfnCallBack As AsyncCallback
   Private _asynResult As IAsyncResult

   'Events

   Public Event OnConnect()
   Public Event OnDataReceived(ByVal Data As String)
   Public Event OnError(ByVal ex As SocketException)
   Public Event OnStatusChanged(ByVal Status As SocketStatus)
   Public Event OnDataSent()
   Public Event OnDisconnect()
   Public Event OnConnecting()

   'Properties
   Public Property Status() As SocketStatus
      Get
         Return _socketStatus
      End Get
      Set(ByVal value As SocketStatus)
         RaiseEvent OnStatusChanged(value)
         _socketStatus = value
      End Set
   End Property

   'Implementation
   Public Sub Connect(ByVal IP As String, ByVal Port As Integer)
      If Not String.IsNullOrEmpty(IP) AndAlso Port > 0 Then
         Try

            _sock = New SocketHolder()
            _sock.Socket = New Socket(AddressFamily.InterNetwork, _
            SocketType.Stream, ProtocolType.IP)

            Dim ThisIP As IPAddress = IPAddress.Parse(IP)
            Dim RemoteEP As IPEndPoint = New IPEndPoint(ThisIP, Port)
            _sock.Socket.Connect(RemoteEP)

            Status = SocketStatus.Connecting
            RaiseEvent OnConnecting()

            ResumeConnection()
            Status = SocketStatus.Receiving
         Catch ex As Exception
            RaiseEvent OnError(ex)
         End Try
      End If
   End Sub

   Public Sub ResumeConnection()
      Try
      If _pfnCallBack Is Nothing Then
         _pfnCallBack = New AsyncCallback(AddressOf DataReceived)
      End If

      Status = SocketStatus.Connected
      RaiseEvent OnConnect()

      _asynResult = _sock.Socket.BeginReceive(_sock.DataBuffer, 0,
      _sock.DataBuffer.Length, SocketFlags.None, _pfnCallBack, _sock)

      Catch ex As Exception
         RaiseEvent OnError(ex)
      End Try
   End Sub

   Public Sub DataReceived(ByVal asyn As IAsyncResult)
      Try
         Dim sock As SocketHolder = DirectCast(asyn.AsyncState, SocketHolder)
         Dim irx As Integer = 0
         irx = sock.Socket.EndReceive(asyn)
         Dim chars As Char() = New Char(irx) {}

         Dim d As Text.Decoder = Text.Encoding.UTF8.GetDecoder()

         Dim charLen As Integer = d.GetChars(sock.DataBuffer, 0, irx, chars, 0)

         RaiseEvent OnDataReceived(New String(chars))
         ResumeConnection()
      Catch ex As Exception
         RaiseEvent OnError(ex)
      End Try
   End Sub

   Public Sub Send(ByVal Data As String)
      Send(ASCII.GetBytes(Data))
   End Sub

   Public Sub Send(ByVal Data As Byte())
      Try
         _sock.Socket.Send(Data)
      Catch ex As SocketException
         RaiseEvent OnError(ex)
      End Try
   End Sub

   Public Sub Disconnect()
      Try
         If Not Status = SocketStatus.Disconnected Then
            _sock.Socket.Disconnect(False)
            Status = SocketStatus.Disconnected
            _sock.Socket = Nothing

            RaiseEvent OnDisconnect()
         End If
      Catch ex As Exception
         RaiseEvent OnError(ex)
      End Try
   End Sub
End Class

That’s pretty much it! You can either put this in a new project and create your own library, or just use the class in whichever project you have. Import the class, create a new instance -declare it WithEvents- and handle the events you need.

You will notice that it is almost identical (at least it feels that way to me) to using the old Windows Socket from VB6. If you need to do a couple of extra touches to the class, go ahead and do it till you feel comfortable with it; you can make it completely async, non-blocking, multi-thread, etc.

Have fun with your implementation!

References:
http://msdn.microsoft.com/en-us/library/system.net.sockets.socket.aspx
http://en.wikipedia.org/wiki/Network_socket
http://vb.net-informations.com/communications/vb.net_socket_programming.htm
http://www.osix.net/modules/article/?id=25
http://www.devasp.net/net/articles/display/192.html