TCP Socket Server, ObjectDisposedException

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace Sandbox
{
    class Program
    {
        private static IDictionary<Socket, IList<Socket>> connectedClients;

        static void Main(string[] args)
        {
            // Create connected client storage.
            connectedClients = new Dictionary<Socket, IList<Socket>>();

            // Create the socket.
            Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            connectedClients.Add(listener, new List<Socket>());

            // Bind it to address.
            listener.Bind(new IPEndPoint(IPAddress.Any, 1337));

            // Listen to it.
            listener.Listen(100);

            Console.WriteLine("Listening on {0}...", listener.LocalEndPoint);

            // Create a reusable event handler.
            SocketAsyncEventArgs e = new SocketAsyncEventArgs();

            // Bind event to be called once the Async operation ends.
            e.Completed += AcceptCallback;

            // Begin asynchronous accept.
            listener.AcceptAsync(e);

            Console.WriteLine("Accepting on {0}...", listener.LocalEndPoint);

            Console.ReadKey();
        }

        private static void AcceptCallback(object sender, SocketAsyncEventArgs e)
        {
            // The server we're working with.
            Socket listener = (Socket)sender;
            IPEndPoint serverCoordinates = listener.LocalEndPoint as IPEndPoint;

            // Client, that has been accepted.
            Socket client = e.AcceptSocket;
            IPEndPoint clientCoordinates = client.RemoteEndPoint as IPEndPoint;

            if (client.Connected)
            {
                Console.WriteLine("{0} connected to {1}.", clientCoordinates, serverCoordinates);
                connectedClients[listener].Add(client);

                try
                {
                    Debug.Assert(client != null);

                    // Lets work!
                    client.Send(Encoding.ASCII.GetBytes(String.Format("Welcome {0}!", clientCoordinates)));

                    SocketAsyncEventArgs ce = new SocketAsyncEventArgs();
                    ce.Completed += ReceiveCallback;
                    ce.SetBuffer(new Byte[4096], 0, 4096);
                    ce.UserToken = listener;

                    // Bind listening event.
                    client.ReceiveAsync(ce);

                    Console.WriteLine("Listening to {0} on {1}...", clientCoordinates, serverCoordinates);
                }
                catch (Exception ex)
                {
                    Console.WriteLine("Exception encountered:");
                    Console.WriteLine(ex);
                }
                finally
                {
                    // Reuse the event arguments.
                    e.AcceptSocket = null;
                }

                // Listen for the next connection.
                listener.AcceptAsync(e);
            }
        }

        private static void ReceiveCallback(object sender, SocketAsyncEventArgs e)
        {
            Socket client = (Socket)sender;
            Socket listener = (Socket)e.UserToken;

            string message = Encoding.ASCII.GetString(e.Buffer, e.Offset, e.BytesTransferred);

            IPEndPoint clientCoordinates = client.RemoteEndPoint as IPEndPoint;
            IPEndPoint serverCoordinates = listener.LocalEndPoint as IPEndPoint;

            Console.WriteLine("{0} bytes from {1} on {2}", e.BytesTransferred, clientCoordinates, serverCoordinates);

            if (e.BytesTransferred > 0)
            {
                Console.WriteLine("{0} from {1} on {2}", message, clientCoordinates, serverCoordinates);
            }

            if (message == "disconnect" || e.BytesTransferred == 0)
            {
                try
                {
                    Console.WriteLine("{0} on {1} requested to be disconnected.", clientCoordinates, serverCoordinates);
                    client.Send(Encoding.ASCII.GetBytes("Disconnecting..."));
                    client.Disconnect(false);
                    Console.WriteLine("{0} on {1} disconnected.", clientCoordinates, serverCoordinates);
                }
                catch (Exception)
                {
                    // Throw if client has closed, so it is not necessary to catch.
                }
                finally
                {
                    connectedClients[listener].Remove(client);

                    client.Close();
                    Console.WriteLine("{0} on {1} closed.", clientCoordinates, serverCoordinates);

                    e.Dispose();
                }

                return;
            }

            if (message == "stop")
            {
                try
                {
                    Console.WriteLine("{0} on {1} requested to close the server.", clientCoordinates, serverCoordinates);
                    client.Send(Encoding.ASCII.GetBytes("Shutting down your server..."));
                    client.Disconnect(false);
                    Console.WriteLine("{0} on {1} disconnected.", clientCoordinates, serverCoordinates);
                }
                catch (Exception)
                {
                    // ...
                }
                finally
                {
                    connectedClients[listener].Remove(client);

                    client.Close();
                    Console.WriteLine("{0} on {1} closed.", clientCoordinates, serverCoordinates);

                    Console.WriteLine("Remaining clients on {0}: {1}", serverCoordinates, connectedClients[listener].Count);

                    // Disconnect remaining clients.
                    for (int i = 0; i < connectedClients[listener].Count; i++)
                    {
                        Socket connectedClient = connectedClients[listener][i];

                        IPEndPoint connectedClientCoordinates = connectedClient.RemoteEndPoint as IPEndPoint;

                        try
                        {
                            connectedClient.Send(Encoding.ASCII.GetBytes("Server shutting down..."));
                            connectedClient.Disconnect(false);
                            Console.WriteLine("{0} on {1} disconnected by shutdown.", connectedClientCoordinates, serverCoordinates);
                        }
                        catch (Exception)
                        {

                        }
                        finally
                        {
                            connectedClients[listener].Remove(connectedClient);

                            connectedClient.Close();
                            Console.WriteLine("{0} on {1} closed by shutdown.", connectedClientCoordinates, serverCoordinates);
                        }
                    }

                    Console.WriteLine("{0} closing...", serverCoordinates);
                    listener.Close();
                    Console.WriteLine("{0} closed.", serverCoordinates);

                    connectedClients.Remove(listener);
                }

                return;
            }

            // Listen for next.
            client.ReceiveAsync(e);
        }
    }
}