I want to change my Server class into TCPListner asynchronously

public static List<ClientManager> Vehicles;
       //public static List<ClientUpdateData> ClientFirmware;
       private static BackgroundWorker bwListener;
       private static  TcpListener listenerSocket;
      
       public static Int32 Port;
      
       public static  bool Status;
      
       public static event ConnectedEventHandler ClientConnected = delegate { };
     
       public static event DisconnectedEventHandler ClientDisConnected = delegate { };
      
 public static event DataReceivedEventHandler DataReceived = delegate { };
      
       public static event NotificationEventHandler OnNotificationReceived = delegate { };
    
       public static void Start( String port, String status)
       {
           Port = Convert.ToInt32(port);
           // Port = 14126;
           Status = Convert.ToBoolean(status);
           if (Status)
           {
               Vehicles = new List<ClientManager>();
               bwListener = new BackgroundWorker();
               bwListener.WorkerSupportsCancellation = true;
               //background worker that listens to the devices
               bwListener.DoWork += new DoWorkEventHandler(StartToListen);
               bwListener.RunWorkerAsync();
           }

       }
    
   public static Int32 VehicleCount
       {
           get { return Vehicles.Count; }
       }

    
   public static void StartServer()
       {
           if (!Status)
           {
               bwListener = new BackgroundWorker();
               bwListener.WorkerSupportsCancellation = true;
               //background worker that starts to listen for devices
               bwListener.DoWork += new DoWorkEventHandler(StartToListen);
               bwListener.RunWorkerAsync();
               Status = true;
           }

       }
   
 private static void StartToListen(object sender, DoWorkEventArgs e)
       {
           //starts listening to the specified port
           listenerSocket = new TcpListener(IPAddress.Any, Port);
           listenerSocket.Start();

           while (Status)
           {
               if (!listenerSocket.Pending())
               {
                   Thread.Sleep(500);
                   continue;
               }
               //creates a ClientManager object in case there is a device trying to connect to this port
               CreateNewClientManager(listenerSocket.AcceptTcpClient());
           }
       }
   
   private static void CreateNewClientManager(TcpClient socket)
       {
           //creates a object of ClientManager class and assign event handlers
           ClientManager newClientManager = new ClientManager(socket);


           newClientManager.CommandReceived += new PacketReceivedEventHandler(newPacketReceived);
           newClientManager.Disconnected += new DisconnectedEventHandler(ClientDisconnected);
           newClientManager.Connected += new ConnectedEventHandler(VehicleConnected);
           newClientManager.Notification +=new NotificationEventHandler(NotificationReceived);
           ClientConnected(null, new ClientEventArgs(newClientManager.Address, newClientManager.Address));
       }
   
    static void VehicleConnected(object sender, ClientEventArgs e)
       {
           ClientManager cm = (ClientManager)sender;
           CheckForAbnormalDC(cm);
           Vehicles.Add(cm);
           ClientConnected(sender, new ClientEventArgs(e.ADDRESS,e.NAME));

       }
  
   private static void CheckForAbnormalDC(ClientManager mngr)
       {
           RemoveClientManager(mngr);
       }
   
   static void ClientDisconnected(object sender, ClientEventArgs e)
       {

           RemoveClientManager((ClientManager)sender);

       }
      
  public static ClientManager GetClient(String address)
       {
           Int32 index = -1;
           index = IndexOfClient(address);
           if (index != -1)
           {
               return Vehicles[index];
           }
           return null;
       }
     
public static ClientManager GetClientUF(String Name)
       {
           Int32 index = -1;
           index = IndexOfClientUF(Name);
           if (index != -1)
           {
               return Vehicles[index];
           }
           return null;
       }
       public static Int32 IndexOfClientUF(String Name)
       {
           Int32 index = -1;
           foreach (ClientManager cMngr in Vehicles)
           {
               index++;
               if (cMngr.ClientName == Name)
                   return index;
           }
           return -1;
       }
     private static bool RemoveClientManager(ClientManager mngr)
       {
           lock (Vehicles)
           {
               Int32 index = IndexOfClient(mngr);
               if (index != -1)
               {
                   ClientDisConnected(null, new ClientEventArgs(Vehicles[index].Address, Vehicles[index].ClientName));
                   Vehicles.RemoveAt(index);
                   GC.Collect();
                   return true;
               }
               return false;
           }
       }
       private static Int32 IndexOfClient(ClientManager mngr)
       {
           Int32 index = -1;
           foreach (ClientManager cMngr in Vehicles)
           {
               index++;
               if ((cMngr.Address == mngr.Address) | (cMngr.ClientName == mngr.ClientName))
                   return index;
           }
           return -1;

       }
      private static Int32 IndexOfClient(String address)
       {
           Int32 index = -1;
           foreach (ClientManager cMngr in Vehicles)
           {
               index++;
               if (cMngr.Address == address)
                   return index;
           }
           return -1;
       }

      private static void NotificationReceived(object sender, NotificationEventArgs e)
       {
           if (OnNotificationReceived != null)
               OnNotificationReceived(sender, e);

       }

    
       private static void newPacketReceived(object sender, PacketEventArgs e)
       {
           if (e.packet != null)
           {
               //packet is to be only displayed in user interface
               if (e.packet.ShowOnly)
               {
                   DataReceived(null, new DataEventArgs("[Valid] " + e.data));
               }
               //in case the packet is valid
               else if (e.packet.b_Valid && e.packet.b_Gps && e.packet.Length)
               {
                   lock (Program.q_Packets)
                   {
                       Program.q_Packets.Enqueue(e.packet);
                   }
                   DataReceived(null, new DataEventArgs("[Valid] " + e.data));
               }
               //in case there is no gps data in packet
               else if (e.packet.b_Valid && !e.packet.b_Gps)
               {
                   lock (Program.q_Packets)
                   {
                       Program.q_Packets.Enqueue(e.packet);
                   }
                   DataReceived(null, new DataEventArgs("[No GPS] " + e.data));
               }
               //in case length is not valid
               else if (e.packet.b_Valid && !e.packet.Length)
               {
                   DataReceived(null, new DataEventArgs("[Invalid Length] " + e.data));
               }
               //in case no gps data and packet is not valid and length is also invalid
               else if (!e.packet.b_Valid && !e.packet.Length && !e.packet.b_Gps)
               {
                   DataReceived(null, new DataEventArgs("[Valid] " + e.data));
               }
           }


       }
     
    public static void StopServer()
       {
           Status = false;
           listenerSocket.Stop();
           bwListener.CancelAsync();
           bwListener.Dispose();

           if (Vehicles != null)
           {
               foreach (ClientManager mngr in Vehicles)
               {

                   mngr.Disconnect();
               }
               Vehicles.Clear();
           }
           GC.Collect();
       }