Here's an example of opening a socket and handeling socket events

alias SocketTest {
  var %socket $Socket(google.com,80,GoogleSock)
  $socket(%socket,SockeOpen).sockopen
  $socket(%socket,SockRead).sockread
  $socket(%socket).connect
}
alias SockeOpen {
  echo -a You have successfully connected to $sock($sockname).ip $+ : $+ $sock($sockname).port - $string($socket($1).tag).get
  $socket($1,SOme **** to send).write
  echo -a Sent $qt(Some **** to send)
  $socket($1).delete
}
alias SockRead {
  var %data
  sockread %data
  echo -a Read $len(%data) bytes from socket $Socket($1).tag $+ : %data
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Description: This is a Socket class which contains   ;
; the basic structure of a class                       ;
; Usage: $Socket(<Instance>,<Params>,..).<Method>      ;
; Example: var %x $Socket(127.0.0.1,1337,LocalSock)    ;
; Example: $Socket(%x,SockOpenAlias).sockopen          ;
; Example: $Socket(%x,SockReadAlias).sockread          ;
; Example: $Socket(%x).connect                         ;
; Example: $Socket(%x).close                           ;
; Example: $Socket(%x).delete                          ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Public Declarations ;
;;;;;;;;;;;;;;;;;;;;;;;
alias Socket.DELETE.Public
alias Socket.PORT.Public
alias Socket.IP.Public
alias Socket.OPEN.Public
alias Socket.CONNECT.Public
alias Socket.LISTEN.Public
alias Socket.CLOSE.Public
alias Socket.SOCKREAD.Public
alias Socket.SOCKOPEN.Public
alias Socket.SOCKCLOSE.Public
alias Socket.SOCKACCEPT.Public
alias Socket.TAG.Public
alias Socket.SETTAG.Public
alias Socket.SETIP.Public
alias Socket.SETPORT.Public
alias Socket.WRITE.Public
alias Socket.WRITEB.Public
;;;;;;;;;;;;;;;;;;;;;;;;;;
; Exception Declarations ;
;;;;;;;;;;;;;;;;;;;;;;;;;;
alias Socket.EXCEPTION.SockErr {
  $Class($1,SockErr).getv $1-
  return $iif($bvar(&SockErr,0),$bvar(&SockErr,1-).text)
}
;;;;;;;;;;;;;;;;
; Socket Alias ;
;;;;;;;;;;;;;;;;
alias Socket {
  if (!$prop) goto init
  if ($IsPublic(Socket,$prop)) goto $prop
  return $catch($1,MemberErr, $qt($prop) is not a public member of Socket)
  :init
  return $Socket.INIT($1,$2,$3)
  :delete
  return $Socket.DELETE($1)
  :open
  :connect
  if ($sock($1).status) $catch($1,SockOpenErr,Socket $1 is already open)
  sockopen $1 $Class($1,IP).getv $Class($1,PORT).getv
  return
  :close
  if ($sock($1).status) sockclose $1
  else return $catch($1,SockCloseErr,Sock $1 was not open)
  return
  :listen
  if ($sock($1).status) $catch($1,SockOpenErr,Socket $1 is already open)
  var %x $iif($Class($1,IP).getv,$v1),%y $iif(%x,-d)
  socklisten %y %x $1 $Class($1,PORT).getv
  return
  :sockclose
  return $Class($1,CLOSE,$2).setv
  :sockopen
  return $Class($1,OPEN,$2).setv
  :sockaccept
  return $Class($1,ACCEPT,$2).setv
  :sockread
  return $Class($1,READ,$2).setv
  :settag
  $Class($1,Tag,$2).setv
  :tag
  return $Class($1,Tag).getv
  :setip
  return $Class($1,IP,$2).setv
  :setport
  return $Class($1,PORT,$2).setv
  :ip
  return $Class($1,IP).getv
  :port
  return $Class($1,PORT).getv
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ; Put your own method handlers here ;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  :write
  if ($sock($1).status != active) return $catch($1,SockErr,Socket $1 is not connected)
  sockwrite -t $1 $2
  return
  :writeb
  if ($sock($1).status != active) return $catch($1,SockErr,Socket $1 is not connected)
  sockwrite $1 $2
  :MethodHandler
}

;;;;;;;;;;;;;;;;;;
; Socket Methods ;
;;;;;;;;;;;;;;;;;;
alias Socket.INIT {
  var %instance $Class
  $inheritsFrom(%instance,Socket)
  $Class(%instance,IP,$1).setv
  $Class(%instance,PORT,$2).setv
  $Class(%instance,OPEN,Socket.DefaultSockOpen).setv
  $Class(%instance,CLOSE,Socket.DefaultSockClose).setv
  $Class(%instance,ACCEPT,Socket.DefaultSockAccept).setv
  $Class(%instance,READ,Socket.DefaultSockRead).setv
  $Class(%instance,SockErr,Socket.DefaultSockErr).setv
  $Class(%instance,Tag,$3).setv
  ;;;;;;;;;;;;;;;;;;;;;;;;
  ; Do Initializing here ;
  ;;;;;;;;;;;;;;;;;;;;;;;;
  return %instance
}
alias Socket.DELETE {
  ;;;;;;;;;;;;;;;;;;;;;;
  ; Do Destroying here ;
  ;;;;;;;;;;;;;;;;;;;;;;
  if ($sock($1).status) sockclose $1
  return $class($1).DELETE
}
;;;;;;;;;;;;;;;;;;;;;;;;;;
; Default Event Handlers ;
;;;;;;;;;;;;;;;;;;;;;;;;;;
alias Socket.DefaultSockOpen {
  if ($Window(@Debug)) echo @Debug Successfully connected to $sock($sockname).ip $+ : $+ $sock($sockname).port
}
alias Socket.DefaultSockClose {
  if ($Window(@Debug)) echo @Debug Successfully disconnected from $sock($sockname).ip $+ : $+ $sock($sockname).port
  $Socket($1).delete
}
alias Socket.DefaultSockRead {
  sockread %temp
  if ($window(@Debug)) echo @Debug %temp
}
alias Socket.DefaultSockAccept {
}
alias Socket.DefaultSockErr {
  sockclose $1
}
alias SockErr {
  bset -t &SockErr $1-
}
;;;;;;;;;;;;;;;;;;;;
; Trigger Handlers ;
;;;;;;;;;;;;;;;;;;;;
on 1:sockopen:*: $class($left($sockname,-1),OPEN).getv $left($sockname,-1)
on 1:sockclose:*: $class($left($sockname,-1),CLOSE).getv $left($sockname,-1)
on 1:socklisten:*: $class($left($sockname,-1),ACCEPT).getv $left($sockname,-1)
on 1:sockread:*: $class($left($sockname,-1),READ).getv $left($sockname,-1)
;;;;;;;;;;;;;;
; End Socket ;
;;;;;;;;;;;;;;

I have to agree with SReject that mIRC scripting is not really conducive to being put in an OOP paradigm. You almost have to write twice as much code and you are not going to really get anything that OOP brings to the table like encapsulation, inheritance, polymorphism and the list continues.

this implementation actually brings all 3 of those aspects of OOP to mIRC

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Description: This class can be used as a simulate a  ;
; stack. It inherits from my List class, so any method ;
; that can be used on an list, can also be used on a   ;
; stack.                                               ;
;                                                      ;
; Usage: $Stack(<uID>,<Params>,...).<Member>           ;
; Example: var %itemID = $stack(%x,%text).push         ;
; Example: var %text = $stack(%x).pop                  ;
; Example: var %x $stack(%x).Count                     ;
; Example: $stack(%x).Clear                            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Public Declarations ;
;;;;;;;;;;;;;;;;;;;;;;;
alias Stack.DELETE.Public
alias Stack.Push.Public
alias Stack.Pop.Public
alias Stack.Clear.Public
;;;;;;;;;;;;;;;;;;;;;;;;;;
; Exception Declarations ;
;;;;;;;;;;;;;;;;;;;;;;;;;;
alias Stack.Exception.RangeErr return Out of Bounds!
;;;;;;;;;;;;;;;;;;
; Stack Alias    ;
;;;;;;;;;;;;;;;;;;
alias Stack {
  if (!$prop) goto init
  if ($IsPublic(Stack,$prop)) goto $prop
  return $catch($1,MemberErr, $qt($prop) is not a public member of Stack)
  :init
  return $Stack.INIT($1)
  :delete
  return $Stack.DELETE($1)
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ; Put your own method handlers here ;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  :Push
  var %x $list($1,$2).add
  return
  :Pop
  if $list($1).count {
    var %y $list($1,$v1).get
    $list($1,$v1).remove
    return %y
  }
  return
  :Clear
  while ($list($1).count) {
    $list($1,1).remove
  }
  return
}

;;;;;;;;;;;;;;;;;;;;
; Stack Methods    ;
;;;;;;;;;;;;;;;;;;;;
alias Stack.INIT {
  if ($instanceOf($1,list)) return $inheritsFrom($1,Stack)
  var %instance $List
  $inheritsFrom(%instance,Stack)
  ;;;;;;;;;;;;;;;;;;;;;;;;
  ; Do Initializing here ;
  ;;;;;;;;;;;;;;;;;;;;;;;;
  return %instance
}
alias Stack.DELETE {
  ;;;;;;;;;;;;;;;;;;;;;;
  ; Do Destroying here ;
  ;;;;;;;;;;;;;;;;;;;;;;
  return $Class($1).DELETE
}
;;;;;;;;;;;;;;;;
; End Stack    ;
;;;;;;;;;;;;;;;;

as you can see the Stack class inherits from the List class and List operations can be used on a stack object by using $List(%stackObject,..).listOperation or class operations by using $Class(%stackObject,..).classOperation

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Description: This class can be used as a dynamically sized      ;
; List to store any data type                                     ;
;                                                                 ;
; Usage: $List(<ListPtr>,<Params>,...).<Member>                   ;
; Example: var %x = $List                                         ;
; Example: var %itemID = $List(%x,$long(500)).add                 ;
; Example: $List(%x,%itemID,$long(499)).set                       ;
; Example: $List(%x,%ItemID).remdel                               ;
; Example: $List(%x).delete                                       ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;
; Public Declarations ;
;;;;;;;;;;;;;;;;;;;;;;;
alias List.DELETE.Public
alias List.Add.PUBLIC
alias List.Remove.PUBLIC
alias List.Get.PUBLIC
alias List.Count.PUBLIC
alias List.Set.PUBLIC
alias List.Remdel.PUBLIC

;;;;;;;;;;;;;;;;;;;;;;;;;;
; Exception Declarations ;
;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;
; List Alias ;
;;;;;;;;;;;;;;
alias List {
  if (!$prop) goto init
  if ($IsPublic(List,$prop)) goto $prop
  return $catch($1,MemberErr, $qt($prop) is not a public member of List)
  :init
  return $List.INIT($1)
  :delete
  return $List.DELETE($1,$2)
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ; Put your own method handlers here ;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  :MethodHandler
  :add
  return $List.Add($1,$2)
  :Remdel
  :Remove
  return $List.Remove($1,$2)
  :get
  return $List.Get($1,$2)
  :count
  return $hget($1,COUNT)
  :set
  return $List.Set($1,$2,$3)
}

;;;;;;;;;;;;;;;;
; List Methods ;
;;;;;;;;;;;;;;;;
alias List.INIT {
  var %instance $Class
  $inheritsFrom(%instance,List)
  ;;;;;;;;;;;;;;;;;;;;;;;;
  ; Do Initializing here ;
  ;;;;;;;;;;;;;;;;;;;;;;;;
  return %instance
}
alias List.REMOVE {
  if $2 !isnum 1- $+ $hget($1,COUNT) { return $catch($1,RangeErr,$qt($2) is not a valid list index for object $qt($1)) }
  hdec $1 COUNT
  - $Class($1,ITEMS,&items).getb
  var %x $calc(1 + (($2 - 1) * 32)),%y %x + 32,%z $bvar(&items,%x,32).text
  if %y > $bvar(&items,0) { dec %y }
  var %var $bvar(&items,%x,32).text
  bcopy -c &items %x &items %y -1
  - $Class($1,%var).remv
  - $Class($1,ITEMS,&items).setb
}
alias List.ADD {
  hinc $1 COUNT
  hinc $1 TOTAL
  var %x $md5($hget($1,TOTAL))
  - $Class($1,ITEMS,&items).getb
  bset -t &items $calc(1 + (($hget($1,COUNT) - 1) * 32)) %x
  - $Class($1,ITEMS,&items).setb
  - $iif($bvar($2,0),$Class($1,%x,$2).setb,$Class($1,%x,$2).setv)
  return $hget($1,Count)
}
alias List.GET {
  if $2 !isnum 0- $+ $hget($1,COUNT) { return $catch($1,RangeErr,$qt($2) is not a valid list index for object $qt($1) $chr(40) $+ Valid Ranges: 1- $+ $hget($1,COUNT) $+ $chr(41)) }
  $iif($2 == 0,return $hget($1,COUNT))
  - $hget($1,ITEMS,&items)
  var %var2 $bvar(&items,$calc(1 + (($2 - 1) * 32)),32).text
  return $hget($1,%var2)
}
alias List.SET {
  var %z $bvar(&items,$calc(1 + (($2 - 1) * 32)),32).text
  var %x $Class($1,%z).getv
  if $IsInstance(%x) { noop $Object(%x).delete } 
  - $Class($1,%z,$3).setv
}
alias List.IMPORT {
  var %x $List($1).count
  while %x {
    if $ImportObject($List($1,%x).get) {
      + Loaded object $qt($List($1,%x).get) of type $qt($IsInstance($List($1,%x).get))
    }
    dec %x
  }
  if $exists($+(object/,$1.bvr)) {
    bread $+(object/,$1.bvr) 1 $file($+(object/,$1.bvr)).size &data
    - $Class($1,ITEMS,&data).setb
  }
}

alias List.EXPORT {
  var %x $List($1).count
  while %x {
    var %y $List($1,%x).get
    if $IsInstance(%y) {
      - $ExportObject(%y)
      + Saved object $qt($List($1,%x).get)
    }
    dec %x
  }
  - $Class($1,ITEMS,&data).getb
  if $exists($+(object/,$1.bvr)) { 
    .remove $+(object/,$1.bvr)
  }
  bwrite $+(object/,$1.bvr) 1 -1 &data
}
alias List.DELETE {
  ;;;;;;;;;;;;;;;;;;;;;;
  ; Do Destroying here ;
  ;;;;;;;;;;;;;;;;;;;;;;
  - $Class($1,ITEMS).remv
  - $Class($1,TOTAL).remv
  - $Class($1,COUNT).remv
  if $2 {
    while $hget($1,1).item {
      var %y $v1
      var %x $hget($1,%y)
      if $IsInstance(%x) {
        - $Object(%x,1).delete
        + Removed object: $qt(%x) from list $qt($1)
      }
      - $Class($1,%y).remv
    }
  }
  return $Class($1).DELETE
}
;;;;;;;;;;;;
; End List ;
;;;;;;;;;;;;