C#

<br />
Process notepadProcess;<br />
private void button1_Click(object sender, EventArgs e) {<br />
	notepadProcess = new Process();<br />
	notepadProcess.EnableRaisingEvents = true; // tell process to raise Exited event<br />
	notepadProcess.Exited += new EventHandler(notepadProcess_Exited); // Exited event handler<br />
	notepadProcess.StartInfo.FileName = "notepad.exe";<br />
	notepadProcess.Start();<br />
}<br />
void notepadProcess_Exited(object sender, EventArgs e) {<br />
	MessageBox.Show("Notepad process just has been exited.");<br />
	notepadProcess.Dispose();<br />
}<br />

Dave Kreskowiak wrote:

It's clear that you don't have the black-belt-level of knowledge

Socket newSock = serverSock.Accept();

// usually start another thread, so you can return to Accept.

newSock.Send(myPacket);

        <br />
private void acceptCallBack(IAsyncResult result)<br />
        {<br />
            try<br />
            {<br />
                sck = sck.EndAccept(result);<br />
                byte[] data = new byte[2 * MAXBYTES];<br />
                sck.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(receiveCallBack), data);<br />
                this.Invoke(new noParamsDelegate(connected));<br />
            }<br />
            catch { this.Invoke(new noParamsDelegate(idle)); }<br />
        }

Michel Prévost wrote:

I don't know if your acceptCallBack method is to be called repeatedly (like calling BeginAccept in loop), but if it is the case, you use a socket returned by EndAccept to accept new calls. This is wrong.

        private void receiveCallBack(IAsyncResult result)<br />
        {<br />
            try<br />
            {<br />
                byte[] data = (byte[])result.AsyncState;<br />
                short bytes = (short)sck.EndReceive(result);<br />
<br />
                if (bytes == 0)<br />
                {<br />
                    if (disconnectWait != null)<br />
                        disconnectWait.Set();<br />
                    this.Invoke(new noParamsDelegate(idle));<br />
                }<br />
                else<br />
                {<br />
                    short currByte = 0;<br />
<br />
                    while (currByte < bytes)<br />
                    {<br />
                        //Seperate packs within the buffer<br />
                        //and enqueue them.<br />
<br />
                        packs.Enqueue(pack);<br />
                    }<br />
                    if (sck != null)<br />
                        sck.BeginReceive(data, 0, data.Length, SocketFlags.None, new AsyncCallback(this.receiveCallBack), data);<br />
                }<br />
            }<br />
            catch { }<br />
        }

Michel Prévost wrote:

One problem I can see is that you don't close the Accept'ing socket, and you lose any reference to it (unless there is a hidden Socket variable also holding a reference to this socket).

shyagam wrote:

Sorry the code isn't tabified.
This editor destroys it.

shyagam wrote:

Michel Prévost wrote:
One problem I can see is that you don't close the Accept'ing socket, and you lose any reference to it (unless there is a hidden Socket variable also holding a reference to this socket).


I didn't quite get that... Could you please explain it more detailed please?
How and where should I close it?

aSocket.Shutdown(SocketShutdown.Both);
aSocket.Close();

private void performDisconnect(bool sendDisconnectionPack)
{
    if (sck != null)
    {
        if (sendDisconnectionPack)
        {
            sendPack(CMD_DISCONNECT);
            disconnectWait = new EventWaitHandle(false, EventResetMode.ManualReset);
            disconnectWait.WaitOne(5000, true);
            disconnectWait.Close();
            disconnectWait = null;
        }

        if (sck.Connected) sck.Shutdown(SocketShutdown.Both);
        sck.Close();
        sck = null;

        GC.Collect();
    }
}

shyagam wrote:

Hmm... BTW... What do you suggest to do with this:
sck = sck.EndAccept(result);

Socket tempSck = sck.EndAccept(result);
sck.Shutdown(SocketShutdown.Both);
sck.Close();

sck = tempSck;

private void sendPack(byte command, byte param)
{
    byte[] data, pack;

    // Do some stuff :)
    // .
    // .
    // .

    // Retrieve the pack's data.
    data = makePack(command, param);

    // Here I create a header, combine it with the data, and store it in pack.

    sck.BeginSend(pack, 0, pack.Length, SocketFlags.None, new AsyncCallback(sendCallBack), null);
}

private void sendCallBack(IAsyncResult result)
{
    try
    { sck.EndSend(result); }
    catch(Exception ex)
    { this.Invoke(new stringDelegate(setStatus), ex.Message); }
}

private void cmdListen_Click(object sender, EventArgs e)
{
    if (cmdListen.Text == "Listen")
    {
        try
        {
            IPEndPoint ipEP = new IPEndPoint
            (IPAddress.Any, int.Parse(txtPort.Text));

            if (sck == null)
                sck = new Socket(ipEP.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);

            sck.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);

            sck.Bind(ipEP);
            sck.Listen(100);
            sck.BeginAccept(new AsyncCallback(this.acceptCallBack), null);
            listening();
        }
        catch (Exception ex)
        {
            setStatus(ex.Message);
            this.Invoke(new booleanDelegate(performDisconnect), false);
        }
    }
    else performDisconnect(false);
}