Доступ к ликвидированному объекту невозможен

class Server
    {
        public class StateObject
        {
            // Client  socket.
            public Socket workSocket = 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();
            // Client name
            public string name = "";
        }
 
        public class AsynchronousSocketListener
        {
            // Thread signal.
            public static ManualResetEvent allDone = new ManualResetEvent(false);
            private static List<StateObject> sockets = new List<StateObject>();
 
            public AsynchronousSocketListener()
            {
            }
 
            public static void StartListening()
            {
                // Data buffer for incoming data.
                byte[] bytes = new Byte[1024];
 
                // Establish the local endpoint for the socket.
                // The DNS name of the computer
                // running the listener is "host.contoso.com".
                IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName());
                IPAddress ipAddress = ipHostInfo.AddressList[0];
                IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 31111);
 
                // Create a TCP/IP socket.
                Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
                // Bind the socket to the local endpoint and listen for incoming connections.
                try
                {
                    listener.Bind(localEndPoint);
                    listener.Listen(100);
 
                    while (true)
                    {
                        // Set the event to nonsignaled state.
                        allDone.Reset();
 
                        // Start an asynchronous socket to listen for connections.
                        Console.WriteLine("Waiting for a connection...");
                        listener.BeginAccept(
                            new AsyncCallback(AcceptCallback),
                            listener);
 
                        // Wait until a connection is made before continuing.
                        allDone.WaitOne();
                    }
 
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
 
                Console.WriteLine("\nPress ENTER to continue...");
                Console.Read();
 
            }
 
            public static void AcceptCallback(IAsyncResult ar)
            {
                // Signal the main thread to continue.
                allDone.Set();
 
                // Get the socket that handles the client request.
                Socket listener = (Socket)ar.AsyncState;
                Socket handler = listener.EndAccept(ar);
 
                // Create the state object.
                StateObject state = new StateObject();
                state.workSocket = handler;
                sockets.Add(state);
                handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                    new AsyncCallback(ReceiveCallback), state);
            }
 
            public static void ReceiveCallback(IAsyncResult ar)
            {
                try
                {
                    // Retrieve the state object and the client socket 
                    // from the asynchronous state object.
                    StateObject state = (StateObject)ar.AsyncState;
                    Socket client = state.workSocket;
                    // Read data from the remote device.
                    int bytesRead = client.EndReceive(ar);
                    if (bytesRead > 0)
                    {
                        // There might be more data, so store the data received so far.
                        state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));
                        string text = state.sb.ToString();
                        if (text.Contains("@@onConnection"))
                        {
                            string[] parts = text.Split('#');
                            state.name = parts[1];
                        }
                        else
                        {
                            string[] parts = text.Split('#');
                            
                            foreach (var item in sockets)
                            {
                                if (item.name.Equals(state.name + "-pc"))
                                {
                                    Send(item.workSocket, parts[1]);
                                }
                            }
                            Console.WriteLine(parts[1]);
                        }
                        state.sb.Clear();
                        //  Get the rest of the data.
                        client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                            new AsyncCallback(ReceiveCallback), state);
                    }
                    else {
                        // All the data has arrived; put it in response.
                        if (state.sb.Length > 1)
                        {
                            Console.WriteLine(state.sb.ToString());
                        }
                        // Signal that all bytes have been received.
                        //receiveDone.Set();
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
 
            public static void ReadCallback(IAsyncResult ar)
            {
                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);
 
                if (bytesRead > 0)
                {
                    // There  might be more data, so store the data received so far.
                    state.sb.Append(Encoding.ASCII.GetString(
                        state.buffer, 0, bytesRead));
                    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                        new AsyncCallback(ReadCallback), state);
 
                    // Check for end-of-file tag. If it is not there, read 
                    // more data.
                    content = state.sb.ToString();
                    
                    Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",
                            content.Length, content);
                }
            }
 
            private static void Send(Socket handler, String data)
            {
                // Convert the string data to byte data using ASCII encoding.
                byte[] byteData = Encoding.ASCII.GetBytes(data);
 
                // Begin sending the data to the remote device.
                handler.BeginSend(byteData, 0, byteData.Length, 0,
                    new AsyncCallback(SendCallback), handler);
            }
 
            private static void SendCallback(IAsyncResult ar)
            {
                try
                {
                    // Retrieve the socket from the state object.
                    Socket handler = (Socket)ar.AsyncState;
 
                    // Complete sending the data to the remote device.
                    int bytesSent = handler.EndSend(ar);
                    Console.WriteLine("Sent {0} bytes to client.", bytesSent);
 
                    handler.Shutdown(SocketShutdown.Both);
                    handler.Close();
 
                }
                catch (Exception e)
                {
                    Console.WriteLine(e.ToString());
                }
            }
 
            public static void Main(String[] args)
            {
                StartListening();
            }
        }
    }

class Connection
    {
        TcpClient client = null;
 
        private class State
        {
            public State(byte[] buffer, Socket socket, string msg)
            {
                this.buffer = buffer;
                this.socket = socket;
                this.msg = msg;
            }
 
            public byte[] buffer;
            public Socket socket;
            public string msg;
        }
 
        public Connection(string name, string ip, int port)
        {
            client = new TcpClient();
 
            IPEndPoint point = new IPEndPoint(IPAddress.Parse(ip), port);
            client.Connect(point);
            using (NetworkStream ns = client.GetStream())
            {
                byte[] buffer = Encoding.ASCII.GetBytes("@@onConnection#" + name + "-pc");
                ns.Write(buffer, 0, buffer.Length);
            }
 
            StartReceiving(client);
        }
 
        public void StartReceiving(TcpClient client)
        {
            byte[] buffer = new byte[1024];
            string message = String.Empty;
            using (Socket socket = client.Client)
            {
                State state = new State(buffer, socket, message);
                socket.BeginReceive(state.buffer, 0, state.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
                message = Encoding.ASCII.GetString(buffer);
            }
        }
 
        private void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                State state = (State)ar.AsyncState;
                Socket socket = state.socket;
 
                int bytesRead = socket.EndReceive(ar);
                if (bytesRead > 0)
                {
                    string msg = Encoding.ASCII.GetString(state.buffer, 0, bytesRead);
                    MessageBox.Show(msg);
                }
            }
            catch(Exception e)
            {
                MessageBox.Show(e.ToString());
            }
        }
    }

public partial class MainWindow : Window
    {
        private string name = "";
        private string ip = "";
        Connection conntection = null;
 
        public MainWindow()
        {
            InitializeComponent();
        }
 
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            name = nameTextBox.Text;
            ip = ipTextBox.Text;
            conntection = new Connection(name, ip, 31111);
        }
    }