[x]
Posted via EE Mobile

Search, ask, and monitor your questions on the go with EE Mobile. Visit Experts Exchange from your mobile device and never be out of touch again.
Question
[x]
Attachment Details
[x]
The Solution Rating System

With so many solutions, how can you tell which solutions are most likely to help you and which ones are not? To provide you with a tool to use, we rate our solutions based on various elements that most accurately determine if a solution is a quality solution. To explain what factors affect the solution rating, here are the elements we take into consideration when formulating our solution rating.

  • The Grade of the Solution
  • The Zone Rank of the Expert Providing the Solution
  • The Number of Author and Expert Comments
  • The Number of Experts Contributing
  • The Feedback of the Community

Your Input Matters
Because of the way the system is set up, the most important variable in this equation is you. As a member of Experts Exchange, you are able to cast your vote on the quality of the solutions in regard to how complete, accurate, helpful and easy to understand each solution is. When you provide your feedback, each rating is adjusted accordingly. So, if you see a solution that has a poor rating that you think is a good solution, let us know by rating it. As you do, the rating will be adjusted and will become more accurate for other members of our site.

If you have any suggestions that you would like to make for our rating system, please ask a question in the Suggestions Zone of Community Support.

Thank you!
9.2

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

Asked by PHD in C# Programming Language, .Net Application Servers, .NET

Tags: c# 2.0

Hello,

My mothertong is french.
I have a tcplistener that asynchronously wait for clients when I start my server component.

In my callback method I wrote  TcpClient client = listener.EndAcceptTcpClient(ar);
With this line I have some troubles when I stop the listener.

my question is  : why the callback method is called when I stop the listener. Is it true ?

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:

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);
                };
            }
 
        }
 
    }
}
[+][-]07/08/08 01:49 PM, ID: 21958106Accepted Solution

View this solution now by starting your 30-day free trial. Setting up your free trial is quick, easy, and secure. We will return you to this solution, unlocked, when you're done.

About this solution

Zones: C# Programming Language, .Net Application Servers, .NET
Tags: c# 2.0
Sign Up Now!
Solution Provided By: ShazbotOK
Participating Experts: 1
Solution Grade: A
 
 
Loading Advertisement...
20091111-EE-VQP-92 / EE_QW_2_20070628