软件工程 2016.7.5日报

软件工程 2016.7.5日报

---

 

　　今天我的主要工作是晚场了客户端功能的搭建、连接了客户端UI与客户端Socket部分的功能，为服务端增加了文件锁避免多个线程对同一文件同时操作。

　　具体实现的工作有：

　　客户端功能搭建：

　　　　在客户端完成了通信功能的实现：

　　补全了昨天空缺的代码，在收到消息时进行相应的处理：

                    if (arrMsg[0] == SEND_MSG)
                    {
                        ReceiveMsgFromServer(msgReceive);
                    }
                    else if (arrMsg[0] == IS_RECEIVE_MSG)
                    {
                        Application.Current.Dispatcher.Invoke(new Action(delegate
                        {
                            MessageBox.Show("发送消息成功");
                        }));
                    }
                    else if (arrMsg[0] == IS_NOT_RECEIVE_MSG)
                    {
                        Application.Current.Dispatcher.Invoke(new Action(delegate
                        {
                            MessageBox.Show("[Error]发送消息失败");
                        }));
                    }
                    else if (arrMsg[0] == INVALID_MESSAGE)
                    {
                        Application.Current.Dispatcher.Invoke(new Action(delegate
                        {
                            MessageBox.Show("[Error]通信过程出错");
                        }));
                    }
                    else
                    {
                        Application.Current.Dispatcher.Invoke(new Action(delegate
                        {
                            MessageBox.Show("[Error]通信过程出错");
                        }));
                    }

　　其中，ReceiveMsgFromServer(string str);的具体实实现如下：

        #region --- Receive Room History Message ---
        /// <summary>
        ///     Receive Message
        /// </summary>
        /// <param name="msgReceive"></param>
        private void ReceiveMsgFromServer(string msgReceive)
        {
            MsgHandler msgHandler = (MsgHandler)JsonConvert.DeserializeObject(msgReceive, typeof(MsgHandler));
            string roomId = msgHandler.roomId;
            List<string> msgList = msgHandler.msgList;

            Application.Current.Dispatcher.Invoke(new Action(delegate
            {
                tucaoWall.Document.Blocks.Clear();
                string room = (string)courseList.SelectedItem;
                 if (room.Equals(roomId))
                    foreach (string msg in msgList)
                    {
                        // TODO : 将消息逐一添加到显示框中
                        Paragraph newParagraph = new Paragraph();

                        InlineUIContainer inlineUIContainer = new InlineUIContainer()
                        {
                            Child = new TextBlock()
                            {
                                Foreground = new SolidColorBrush(Colors.Black),
                                TextWrapping = TextWrapping.Wrap,
                                Text = msg + "\r\n"
                            }
                        };
                        newParagraph.Inlines.Add(inlineUIContainer);

                        tucaoWall.Document.Blocks.Add(newParagraph);
                    }
                 
            }));
        }
        #endregion

　　客户端UI与客户端Socket的连接

　　　添加了响应控件的响应，用户点击不同的按钮会调用不同的方法与服务器进行交互。由于代码过于琐碎，在此不做列举。

　　

　　服务器端修改了部分逻辑，同时对文件增加了读写锁。

　　　由于原来在服务端对每个用户都新建了一个线程，保证了在接受消息端是同步的。但是却没有保证发送消息、处理文件等的并发性（可以同时操纵多个文件）。所以将相关的方法封装为一个类，对于每一个新链接的用户新建一个该类对象，这样每个用户就可以通过自己保存的类对象进行相关的操作，而互不影响。此部分功能实现代码如下：

　　　添加从用户ip索引处理对象的字典

        public static Dictionary<string, Handler> dictHandler = new Dictionary<string, Handler>();

　　　处理对象Handler封装的方法包括

        public void CheckRoomList(string s_roomList);
        public void AddMsgToFile(string clientIP, string msg);
        public void InvalidMsg(string clientIP);
        public void SendMessage(string clientIP, byte flag, string msg);

　　　使用特定ip对应的Handler对象的方法为

if (msgReceiver[0] == CHECK_ROOM_LIST)
    dictHandler[socketKey].CheckRoomList(msg);
else if (msgReceiver[0] == REQUEST_ROOM_MSG)
    dictHandler[socketKey].GetRoomMsg(socketKey, msg);
else if (msgReceiver[0] == SEND_MSG)
    dictHandler[socketKey].AddMsgToFile(socketKey, msg);
else if (msgReceiver[0] == DISCONNECT)
     RemoveOfflineUser(socketKey);
else
     dictHandler[socketKey].InvalidMsg(socketKey);

　　　实现上述功能之后，还需要处理文件读写同步的问题，同一文件在同一时间不能被多个线程操作，所以为解决此问题需要为每个文件添加一个读写锁，来控制文件读写同步的问题。

　　　在程序中创建由文件名索引到读写锁的字典

public static Dictionary<string, Object> dictLocker = new Dictionary<string, object>();

　　　在每次操作文件时都需要进行并发控制，检测相应读写锁的使用情况，使用例子如下：

lock(Server.dictLocker[room])
{
    FileStream fs = new FileStream(roomFile, FileMode.Create);
    fs.Close();

    lock (Server.dictLocker["room"])
    {
        string romFile = "room.txt";

        FileStream f = File.OpenWrite(romFile);

        f.Position = f.Length;

        byte[] writeMsg = Encoding.UTF8.GetBytes(room+"\r\n");

        f.Write(writeMsg, 0, writeMsg.Length);

        f.Close();
    }
}

　　通过上述方式，实现了文件的读写控制。