TCP-IP client-server application to manipulate a dictionary

问题

I am writing a Client-server program.

The Server would hold a dictionary, and clients are able to add an update key-values to the dictionary.

Suppose a client-'A' adds an item (1, 111). When another client-'B' wants to update the value of (1, 111), it has to seek a confirmation from 'A', and vice versa.

---

Kindly, take a look at the following program:

using MyClientServerLib;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace MyServerProgram
{
    class ServerProgram
    {
        static Dictionary<string, KeyValue> KeyValueDictionary;
        static Dictionary<string, ClientClass> ClientDictionary;

        static void Main(string[] args)
        {
            Console.Title = "Server";
            Console.WriteLine("Server program started...");

            KeyValueDictionary = new Dictionary<string, KeyValue>();
            ClientDictionary = new Dictionary<string, ClientClass>();

            string ipAddress = "127.0.0.1";
            int portNo = 2000;

            IPAddress ip = IPAddress.Parse(ipAddress);            
            TcpListener listener = new TcpListener(ip, portNo);            

            // poll for clients in a 2nd thread
            Thread thread = new Thread(delegate()
            {
                ServerProgram.PollIncomingClientConns(listener);
            });

            thread.Start();
        }

        #region catching client connections
        static void PollIncomingClientConns(TcpListener listener)
        {
            listener.Start();

            try
            {
                bool keepRunning = true;

                while (keepRunning)
                {
                    ClientClass client = new ClientClass(listener);

                    ClientDictionary.Add(client.ID, client);

                    Thread thread = new Thread(delegate()
                    {
                        ServerProgram.ReadFromClient(client);
                    });
                    thread.Start();
                }
            }
            catch (Exception ex)
            {
                var inner = ex.InnerException as SocketException;
                if (inner != null && inner.SocketErrorCode == SocketError.ConnectionReset)
                    Console.WriteLine("Disconnected");
                else
                    Console.WriteLine(ex.Message);

                listener.Stop();
            }
        } 
        #endregion

        static void ReadFromClient(ClientClass client)
        {
           try
            {
                ClientClass origClient = null; 

                while (client.Tcp.Connected)
                {
                    string str = client.ReadString();

                    switch(str)
                    {
                        case Commands.AddKeyValue:
                            string key = client.ReadString();
                            string val = client.ReadString();
                            KeyValue keyValue = new KeyValue(client.ID, key, val);
                            KeyValueDictionary.Add(key, keyValue);
                            Console.WriteLine(keyValue.ToString() + " added.");
                            break;

                        case Commands.ListKeys:
                            if (KeyValueDictionary.Keys.Count > 0)
                            {
                                foreach (string key1 in KeyValueDictionary.Keys)
                                {
                                    client.Write("(" + key1 + "," + KeyValueDictionary[key1].Value + ")\t");
                                }
                            }
                            else
                            {
                                client.Write("No KV");
                            }
                            break;

                        case Commands.UpdateValue: //obtain update requester client-ID                            
                            client.Key = client.ReadString(); //read key 
                            client.Value = client.ReadString(); //read val

                            KeyValue oldKeyVal = null;

                            bool currClientFound = KeyValueDictionary.TryGetValue(client.Key, out oldKeyVal); //search the dictionary with the client name

                            if (currClientFound) //if found
                            {
                                if (oldKeyVal.ClientID.Equals(client.ID))//if rem requested by same client...
                                {
                                    KeyValueDictionary[client.Key].Value = client.Value;
                                    client.Write(client.Key + " is updated.");
                                }
                                else //if rem requested by a different client...
                                {
                                    //get the original client                                                                        
                                    bool origClientFound = ClientDictionary.TryGetValue(oldKeyVal.ClientID, out origClient); //search the dictionary with the client name

                                    if (origClientFound)
                                    {
                                        origClient.Write(client.ID + " wants to change " + oldKeyVal.ToString() + "(y/n)");
                                    }
                                }
                            }
                            break;

                        case Commands.Yes:
                            Console.WriteLine(client.Key + ", " + client.Value);
                            KeyValueDictionary[client.Key].Value = client.Value;
                            client.Write(client.Key + " is updated.");
                            break;
                    }
                }
            }
            catch
            {
                client.Disconnect();
            }
        }
    }
}

The problem is in case Commands.UpdateValue and case Commands.Yes.

When a client requests for an update in previous iteration, the key-value pair is saved with the client-instance. Then, in the next iteration, when the other client sends an affirmation, the key-value pair is updated.

But, in the next iteration, client.Key is showing null. Hence case Commands.Yes is failing.

How can I solve this issue?

---

Additional source code files:

1. ClientProgram.cs
2. ClientClass.cs

回答1:

I have solve this problem by making key and value holding variables static:

 class ServerProgram
 { 
      static stKey;
      static stValue;

      ....
      ....      
                    case Commands.UpdateValue: //obtain update requester client-ID                            
                        stKey = client.ReadString(); //read key 
                        stValue = client.ReadString(); //read val

                        ....
                        ....

                    case Commands.Yes:
                        Console.WriteLine(stKey + ", " + stValue);
                        KeyValueDictionary[stKey].Value = stValue;
                        client.Write(stKey + " is updated.");
                        break;

     }

来源：https://stackoverflow.com/questions/55988212/tcp-ip-client-server-application-to-manipulate-a-dictionary