async Socket , la réference d'objet n'est pas définie à une instance d'objet

Bonjour,

Je developpe un serveur qui recoit des sockets " protocole UDP". J'ai un petit problème. Quand j'execute mon programme je ne recois rien et le message suivant s'affiche :

Citation:

La réference d'objet n'est pas définie à une instance d'objet

Et voila je crois que le prob est ici :

Code:

1
2
3
4
5
6
public static void ReceiveCallback(IAsyncResult ar)
{
   . 
   .
   .
 int reclient = handler.EndReceive(ar); ;

Auriez vous une solution ?
Merci de m'aider.

Voila mon code

Code:

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
public class StateObject
{
    // Client  socket.
    public Socket workSocket = null;
    //public Socket handler = null;
    // Size of receive buffer.
    public const int BufferSize = 1024;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
}

public class AsynchronousSocketListener
{
    // Thread signal.
    public static ManualResetEvent allDone = new ManualResetEvent(false);



    public static void StartListening()
    {
            byte[] bytes = new Byte[1024];
            Socket workSocket = new Socket(AddressFamily.InterNetwork,
            SocketType.Dgram, ProtocolType.Udp);
           
            IPEndPoint ipEndPoint = new IPEndPoint(IPAddress.Any, 80);
          
            IPEndPoint ipeSender = new IPEndPoint(IPAddress.Any, 0);
            
            EndPoint epSender = (EndPoint)ipeSender;
           
            

            Console.WriteLine("Waiting for a connection...");
           
                // Create the state object.
                StateObject state = new StateObject();

              //  Socket handler = new Socket(AddressFamily.InterNetwork,   SocketType.Dgram, ProtocolType.Udp);
               // Socket handler = state.workSocket;
               
                // Begin receiving the data from the remote device.
                
                    workSocket.Bind(ipEndPoint);
                    while (true)
                    {
                        allDone.Reset();

                        workSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                        allDone.WaitOne();
                        
                    }
                }

    public static void ReceiveCallback(IAsyncResult ar)
    {
        //allDone.Set();
        try
        {
            String content = String.Empty;

            // Retrieve the state object and the handler socket
            // from the asynchronous state object.
            StateObject state = (StateObject)ar.AsyncState;
            Socket handler = state.workSocket;


            // Read data from the client socket. 
            //int bytesRead = handler.EndReceive(ar);
            int reclient = handler.EndReceive(ar);
            if (reclient > 0)
            {
                // There  might be more data, so store the data received so far.
                state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, reclient));


                // Check for end-of-file tag. If it is not there, read 
                // more data.
                content = state.sb.ToString();
                if (content.IndexOf("<EOF>") > -1)
                {
                    // All the data has been read from the 
                    // client. Display it on the console.
                    Console.WriteLine("Read {0} bytes from socket. \n Data : {1}", content.Length, content);

                    // Echo the data back to the client.
                    // Send(handler, content);
                }
                else
                {
                    // Not all data received. Get more.
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                    new AsyncCallback(ReceiveCallback), state);
                }
            }
        }
        catch (Exception ex)
        {
            Console.Write("ReceiveCallback = " + ex.ToString());
            throw ex;

        }
    }