Why the callback method of the beginaccepttcpclient is called when I stop the listener

using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Configuration;
using System.Collections;
using System.Threading;
using System.Net.NetworkInformation;
using System.Net.Mail;
using System.ComponentModel;
using System.Windows.Forms;
 
namespace synWatcher
{
    public class OnReplyEventArtgs : EventArgs
    {
        private string _ip = string.Empty;
 
        public string IP
        {
            get { return _ip; }
            set { _ip = value; }
        }
 
    }
 
    public class OnNoReplyEventArtgs : EventArgs
    {
        private string _ip = string.Empty;
 
        public string IP
        {
            get { return _ip; }
            set { _ip = value; }
        }
 
    }
 
    public class OnClientSubscribeEventArtgs : EventArgs
    {
        private string _ip = string.Empty;
 
        public string IP
        {
            get { return _ip; }
            set { _ip = value; }
        }
 
    }
 
    public class OnAlertErrorEventArgs : EventArgs
    {
        private const string _message = "Unable to alert administrator. Please check your settings";
        private string _ip;
 
        public string Ip
        {
            get { return _ip; }
            set { _ip = value; }
        }
 
        public string Message
        {
            get { return _message; }
        }
 
 
    }
 
    public class OnAlertSentEventArgs : EventArgs
    {
        private string _ip;
 
        public string Ip
        {
            get { return _ip; }
            set { _ip = value; }
        }
 
    }
 
    public class Server : Component
    {
        //Champs de la propriété listener
        private TcpListener _listener;
 
        /// <summary>
        /// Socket auquel les clients se connectent pour sourscrire au service
        /// </summary>
        public TcpListener Listener
        {
            get { return _listener; }
            set { _listener = value; }
        }
 
        /// <summary>
        /// liste des clients qui ont souscrit au service.
        /// La clé est l'adresse IP, la valeur est le nom 
        /// </summary>
        private Hashtable _clients = new Hashtable();
 
        /// <summary>
        /// Lorsqu'un client ne répond pas, on prévient l'administrateur par mail.
        /// Ensuite, on le désinscrit du service pour ne pas envahir de mail l'administrateur.
        /// Comme on ne peut pas modifier une liste pendant qu'on l'itère, on tient une liste des
        /// clients qu'il faut déinscrire et après itération, on retire les clients qui sont dans cette liste
        /// </summary>
        private List<string> _clients_2_unregister = new List<string>();
 
        public delegate void OnAlertError_EventHandler(object sender, OnAlertErrorEventArgs e);
        public delegate void OnClientSubscribe_EventHandler(object sender, OnClientSubscribeEventArtgs e);
        public delegate void OnReply_EventHandler(object sender, OnReplyEventArtgs e);
        public delegate void OnNoReply_EventHandler(object sender, OnNoReplyEventArtgs e);
        public delegate void OnAlertSent_EventHandler(object sender, OnAlertSentEventArgs e);
 
        public event OnReply_EventHandler OnReply;
        public event OnNoReply_EventHandler OnNoReply;
        public event OnClientSubscribe_EventHandler OnClientSubscribe;
        public event OnAlertError_EventHandler OnAlertError;
        public event OnAlertSent_EventHandler OnAlertSent;
 
        public Server()
        {
           
        }
 
        public void Stop()
        {            
            if (_listener.Server.Connected) _listener.Server.Disconnect(false);
            _listener.Server.Close();
            _listener.Stop();
            timer.Dispose();
        }
 
        System.Windows.Forms.Timer timer;
 
        public void Start()
        { 
         string hostname = Dns.GetHostName();
            IPHostEntry he = Dns.GetHostEntry(hostname);
            IPAddress[] ipas = he.AddressList;
 
            try
            {
                _listener = new TcpListener(new IPEndPoint(ipas[0], Properties.Settings.Default.Port));
                _listener.Start();
 
 
                AsyncCallback cb = new AsyncCallback(ClientConnect_Callback);
                _listener.BeginAcceptTcpClient(cb, this);
 
                timer = new System.Windows.Forms.Timer();
                timer.Interval = 5000;
                timer.Tick += new EventHandler(timer_Tick);
                timer.Start();
             }
            catch (System.Net.Sockets.SocketException ex)
            {
                throw ex;
            }
        }
 
        void timer_Tick(object sender, EventArgs eventarg)
        {
            //faire le ping
            Ping ping = new Ping();
            PingReply reply = null;
 
            foreach (object key in this._clients.Keys)
            {
                reply = ping.Send(key.ToString());
 
                switch (reply.Status)
                {
                    case IPStatus.BadDestination:
                    case IPStatus.BadHeader:
                    case IPStatus.BadOption:
                    case IPStatus.BadRoute:
                    case IPStatus.DestinationHostUnreachable:
                    case IPStatus.DestinationNetworkUnreachable:
                    case IPStatus.DestinationPortUnreachable:
                    case IPStatus.DestinationProhibited:
                    case IPStatus.DestinationScopeMismatch:
                    case IPStatus.DestinationUnreachable:
                    case IPStatus.HardwareError:
                    case IPStatus.IcmpError:
                    case IPStatus.NoResources:
                    case IPStatus.PacketTooBig:
                    case IPStatus.ParameterProblem:
                    case IPStatus.SourceQuench:
                    case IPStatus.TimeExceeded:
                    case IPStatus.TimedOut:
                    case IPStatus.TtlExpired:
                    case IPStatus.TtlReassemblyTimeExceeded:
                    case IPStatus.Unknown:
                    case IPStatus.UnrecognizedNextHeader:
                        {
                            if (this.OnNoReply != null)
                            {
                                OnNoReplyEventArtgs e = new OnNoReplyEventArtgs();
                                e.IP = key.ToString();
 
                                this.OnNoReply(this, e);
                            }
                        }; break;
                    case IPStatus.Success:
                        {
                            if (this.OnReply != null)
                            {
                                OnReplyEventArtgs e = new OnReplyEventArtgs();
                                e.IP = key.ToString();
                                this.OnReply(this, e);
                            }
                        };
                        break;
                }
            }
 
            //on efface tous les souscripteurs du service qui n'ont pas répondu et dont l'
            //administrateur a été prévenu par mail.
            foreach (string ip in _clients_2_unregister)
            {
                _clients.Remove(ip);
            }
            _clients_2_unregister.Clear();
         }
 
        /// <summary>
        /// Fonction de retour lorsqu'un client se connecte
        /// </summary>
        private static void ClientConnect_Callback(IAsyncResult ar)
        {
            try
            {
                Server srv = (Server)ar.AsyncState;
                TcpListener listener = srv.Listener;
 
                TcpClient client = listener.EndAcceptTcpClient(ar);
                IPEndPoint ep = (IPEndPoint)client.Client.RemoteEndPoint;
                IPHostEntry he = Dns.GetHostEntry(ep.Address);
 
                srv.Subsribe(ep.Address.ToString(), string.Empty);
            }
            catch
            {
            }
         }
      
        /// <summary>
        /// Sourscrit un client au service
        /// </summary>         
        private void Subsribe(string client_adress,string client_name)
        {
            _clients.Add(client_adress, client_name);
                       
            if (OnClientSubscribe != null)
            {
                OnClientSubscribeEventArtgs e = new OnClientSubscribeEventArtgs();
                e.IP = client_adress;
                OnClientSubscribe(this, e);
            }
 
            _listener.BeginAcceptTcpClient(new AsyncCallback(ClientConnect_Callback), this);
          
        }
 
        /// <summary>
        /// Le serveur référence les clients comme suit : ip(name) 
        /// </summary>
        /// <param name="ip"></param>
        /// <returns></returns>
        public string getClientRef(string ip)
        {
            return string.Concat(ip + " (" + _clients[ip] + ")");
        }
 
        /// <summary>
        /// Pour mettre le client correpondant à l'adresse ip
        /// dans la liste des clients à désinscrire
        /// </summary>
        public void UnSubscribe(string ip)
        {
            _clients_2_unregister.Add(ip);
        }
 
        /// <summary>
        /// Envoie une alerte de type mail.
        /// </summary>
        public void SendAlert(string ip)
        {
            try
            {
                string adress_to = Properties.Settings.Default.Alert_To;
                string adress_from = Properties.Settings.Default.Alert_From;
 
                MailMessage msg = new MailMessage(adress_from, adress_to, string.Concat("(No reply)synWatcher alert : Unable to ping " + getClientRef(ip)), string.Empty);
                SmtpClient smtp_client = new SmtpClient(Properties.Settings.Default.Smtp_Server);
                smtp_client.Send(msg);
 
                if (OnAlertSent != null)
                {
                    OnAlertSentEventArgs e = new OnAlertSentEventArgs();
                    e.Ip = ip;
                    OnAlertSent(this, e);
                }
            }
            catch
            {
                if (OnAlertError != null)
                {
                    OnAlertErrorEventArgs e = new OnAlertErrorEventArgs();
                    e.Ip = ip;
                    OnAlertError(this, e);
                };
            }
 
        }
 
    }
}

                                  

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235:
236:
237:
238:
239:
240:
241:
242:
243:
244:
245:
246:
247:
248:
249:
250:
251:
252:
253:
254:
255:
256:
257:
258:
259:
260:
261:
262:
263:
264:
265:
266:
267:
268:
269:
270:
271:
272:
273:
274:
275:
276:
277:
278:
279:
280:
281:
282:
283:
284:
285:
286:
287:
288:
289:
290:
291:
292:
293:
294:
295:
296:
297:
298:
299:
300:
301:
302:
303:
304:
305:
306:
307:
308:
309:
310:
311:
312:
313:
314:
315:
316:
317:
318:
319:
320:
321: