TCP-IP客户端服务器应用程序操作字典。

Question

我在写一个客户端服务器程序。

服务器将保存一个字典，并且客户端能够向字典中添加一个更新键值。

假设一个客户端-‘A’添加了一个项(1, 111)。当另一个客户-‘B’想更新(1, 111)的值时，它必须向'A'寻求确认，反之亦然。

请看下面的节目：

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();
            }
        }
    }
}

问题在于case Commands.UpdateValue和case Commands.Yes。

当客户端在前一次迭代中请求更新时，键值对将与客户端实例一起保存。然后，在下一次迭代中，当另一个客户端发送断言时，键值对将被更新。

但是，在下一次迭代中，client.Key将展示null。因此，case Commands.Yes失败了。

我怎样才能解决这个问题？

其他源代码文件：

1. ClientProgram.cs
2. ClientClass.cs

Answer 1

我通过使键和值保持变量静态解决了这个问题：

 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;

     }