搭建QQ聊天通信的程序：（1）基于 networkcomms.net 创建一个WPF聊天客户端服务器应用程序 （1）

 1 using System;
 2 using System.Collections.Generic;
 3 using System.Linq;
 4 using System.Text;
 5 using System.Windows;
 6 using System.Windows.Controls;
 7 using System.Windows.Data;
 8 using System.Windows.Documents;
 9 using System.Windows.Input;
10 using System.Windows.Media;
11 using System.Windows.Media.Imaging;
12 using System.Windows.Navigation;
13 using System.Windows.Shapes;
14 
15 namespace WPFChatExample
16 {
17     /// <summary>
18     /// Interaction logic for MainWindow.xaml
19     /// </summary>
20     public partial class MainWindow : Window
21     {
22         public MainWindow()
23         {
24             InitializeComponent();
25         }
26     }
27 }

 1 /// <summary>
 2 /// Append the provided message to the chatBox text box.
 3 /// </summary>
 4 /// <param name="message"></param>
 5 private void AppendLineToChatBox(string message)
 6 {
 7     //To ensure we can successfully append to the text box from any thread
 8     //we need to wrap the append within an invoke action.
 9     chatBox.Dispatcher.BeginInvoke(new Action<string>((messageToAdd) =>
10     {
11         chatBox.AppendText(messageToAdd + "\n");
12         chatBox.ScrollToEnd();
13     }), new object[] { message });
14 }
15 
16 /// <summary>
17 /// Refresh the messagesFrom text box using the recent message history.
18 /// </summary>
19 private void RefreshMessagesFromBox()
20 {
21     //We will perform a lock here to ensure the text box is only
22     //updated one thread at  time
23     lock (lastPeerMessageDict)
24     {
25         //Use a linq expression to extract an array of all current users from lastPeerMessageDict
26         string[] currentUsers = (from current in lastPeerMessageDict.Values orderby current.SourceName select current.SourceName).ToArray();
27 
28         //To ensure we can successfully append to the text box from any thread
29         //we need to wrap the append within an invoke action.
30         this.messagesFrom.Dispatcher.BeginInvoke(new Action<string[]>((users) =>
31         {
32             //First clear the text box
33             messagesFrom.Text = "";
34 
35             //Now write out each username
36             foreach (var username in users)
37                 messagesFrom.AppendText(username + "\n");
38         }), new object[] { currentUsers });
39     }
40 }

 1 /// <summary>
 2 /// Send any entered message when we click the send button.
 3 /// </summary>
 4 /// <param name="sender"></param>
 5 /// <param name="e"></param>
 6 private void SendMessageButton_Click(object sender, RoutedEventArgs e)
 7 {
 8     SendMessage();
 9 }
10 
11 /// <summary>
12 /// Send any entered message when we press enter or return
13 /// </summary>
14 /// <param name="sender"></param>
15 /// <param name="e"></param>
16 private void MessageText_KeyUp(object sender, KeyEventArgs e)
17 {
18     if (e.Key == Key.Enter || e.Key == Key.Return)
19         SendMessage();
20 }
21 
22 /// <summary>
23 /// Toggle encryption
24 /// </summary>
25 /// <param name="sender"></param>
26 /// <param name="e"></param>
27 private void UseEncryptionBox_CheckedToggle(object sender, RoutedEventArgs e)
28 {
29     if (useEncryptionBox.IsChecked != null && (bool)useEncryptionBox.IsChecked)
30     {
31         RijndaelPSKEncrypter.AddPasswordToOptions(NetworkComms.DefaultSendReceiveOptions.Options, encryptionKey);
32         NetworkComms.DefaultSendReceiveOptions.DataProcessors.Add(DPSManager.GetDataProcessor<RijndaelPSKEncrypter>());
33     }
34     else
35         NetworkComms.DefaultSendReceiveOptions.DataProcessors.Remove(DPSManager.GetDataProcessor<RijndaelPSKEncrypter>());
36 }
37 
38 /// <summary>
39 /// Correctly shutdown NetworkComms .Net when closing the WPF application
40 /// </summary>
41 /// <param name="sender"></param>
42 /// <param name="e"></param>
43 private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
44 {
45     //Ensure we shutdown comms when we are finished
46     NetworkComms.Shutdown();
47 }
48 
49 /// <summary>
50 /// Toggle whether the local application is acting as a server
51 /// </summary>
52 /// <param name="sender"></param>
53 /// <param name="e"></param>
54 private void EnableServer_Toggle(object sender, RoutedEventArgs e)
55 {
56     //Enable or disable the local server mode depending on the checkbox IsChecked value
57     if (enableServer.IsChecked != null && (bool)enableServer.IsChecked)
58         ToggleServerMode(true);
59     else
60         ToggleServerMode(false);
61 }

 1 /// <summary>
 2 /// Wrap the functionality required to enable/disable the local application server mode
 3 /// </summary>
 4 /// <param name="enableServer"></param>
 5 private void ToggleServerMode(bool enableServer)
 6 {
 7     if (enableServer)
 8     {
 9         //Start listening for new incoming TCP connections
10         //Parameters ensure we listen across all adaptors using a random port
11         Connection.StartListening(ConnectionType.TCP, new IPEndPoint(IPAddress.Any, 0));
12 
13         //Write the IP addresses and ports that we are listening on to the chatBox
14         chatBox.AppendText("Listening for incoming TCP connections on:\n");
15         foreach (IPEndPoint listenEndPoint in Connection.ExistingLocalListenEndPoints(ConnectionType.TCP))
16             chatBox.AppendText(listenEndPoint.Address + ":" + listenEndPoint.Port + "\n");
17     }
18     else
19     {
20         NetworkComms.Shutdown();
21         chatBox.AppendText("Server disabled. No longer accepting connections and all existing connections have been closed.");
22     }
23 }

 1 /// <summary>
 2 /// Performs whatever functions we might so desire when we receive an incoming ChatMessage
 3 /// </summary>
 4 /// <param name="header">The PacketHeader corresponding with the received object</param>
 5 /// <param name="connection">The Connection from which this object was received</param>
 6 /// <param name="incomingMessage">The incoming ChatMessage we are after</param>
 7 private void HandleIncomingChatMessage(PacketHeader header, Connection connection, ChatMessage incomingMessage)
 8 {
 9     //We only want to write a message once to the chat window
10     //Because we allow relaying and may receive the same message twice
11     //we use our history and message indexes to ensure we have a new message
12     lock (lastPeerMessageDict)
13     {
14         if (lastPeerMessageDict.ContainsKey(incomingMessage.SourceIdentifier))
15         {
16             if (lastPeerMessageDict[incomingMessage.SourceIdentifier].MessageIndex < incomingMessage.MessageIndex)
17             {
18                 //If this message index is greater than the last seen from this source we can safely
19                 //write the message to the ChatBox
20                 AppendLineToChatBox(incomingMessage.SourceName + " - " + incomingMessage.Message);
21 
22                 //We now replace the last received message with the current one
23                 lastPeerMessageDict[incomingMessage.SourceIdentifier] = incomingMessage;
24             }
25         }
26         else
27         {
28             //If we have never had a message from this source before then it has to be new
29             //by definition
30             lastPeerMessageDict.Add(incomingMessage.SourceIdentifier, incomingMessage);
31             AppendLineToChatBox(incomingMessage.SourceName + " - " + incomingMessage.Message);
32         }
33     }
34 
35     //Once we have written to the ChatBox we refresh the MessagesFromWindow
36     RefreshMessagesFromBox();
37 
38     //This last section of the method is the relay function
39     //We start by checking to see if this message has already been relayed
40     //the maximum number of times
41     if (incomingMessage.RelayCount < relayMaximum)
42     {
43         //If we are going to relay this message we need an array of
44         //all other known connections
45         var allRelayConnections = (from current in NetworkComms.GetExistingConnection() where current != connection select current).ToArray();
46 
47         //We increment(增量) the relay count before we send
48         incomingMessage.IncrementRelayCount();
49 
50         //We will now send the message to every other connection
51         foreach (var relayConnection in allRelayConnections)
52         {
53             //We ensure we perform the send within a try catch
54             //To ensure a single failed send will not prevent the
55             //relay to all working connections.
56             try { relayConnection.SendObject("ChatMessage", incomingMessage); }
57             catch (CommsException) { /* Catch the comms exception, ignore and continue */ }
58         }
59     }
60 }

 1 /// <summary>
 2 /// Performs whatever functions we might so desire when an existing connection is closed.
 3 /// </summary>
 4 /// <param name="connection">The closed connection</param>
 5 private void HandleConnectionClosed(Connection connection)
 6 {
 7     //We are going to write a message to the ChatBox when a user disconnects
 8     //We perform the following within a lock so that threads proceed one at a time
 9     lock (lastPeerMessageDict)
10     {
11         //Extract the remoteIdentifier from the closed connection
12         ShortGuid remoteIdentifier = connection.ConnectionInfo.NetworkIdentifier;
13 
14         //If at some point we received a message with this identifier we can
15         //include the source name in the disconnection message.
16         if (lastPeerMessageDict.ContainsKey(remoteIdentifier))
17             AppendLineToChatBox("Connection with ‘" + lastPeerMessageDict[remoteIdentifier].SourceName + "‘ has been closed.");
18         else
19             AppendLineToChatBox("Connection with ‘" + connection.ToString() + "‘ has been closed.");
20 
21         //Last thing is to remove this entry from our message history
22         lastPeerMessageDict.Remove(connection.ConnectionInfo.NetworkIdentifier);
23     }
24 
25     //Refresh the messages from box to reflect this disconnection
26     RefreshMessagesFromBox();
27 }

 1 /// <summary>
 2 /// Send our message.
 3 /// </summary>
 4 private void SendMessage()
 5 {
 6     //If we have tried to send a zero length string we just return
 7     if (messageText.Text.Trim() == "") return;
 8 
 9     //We may or may not have entered some server connection information
10     ConnectionInfo serverConnectionInfo = null;
11     if (serverIP.Text != "")
12     {
13         try { serverConnectionInfo = new ConnectionInfo(serverIP.Text.Trim(), int.Parse(serverPort.Text)); }
14         catch (Exception)
15         {
16             MessageBox.Show("Failed to parse the server IP and port. Please ensure it is correct and try again", "Server IP & Port Parse Error", MessageBoxButton.OK);
17             return;
18         }
19     }
20 
21     //We wrap everything we want to send in the ChatMessage class we created
22     ChatMessage messageToSend = new ChatMessage(NetworkComms.NetworkIdentifier, localName.Text, messageText.Text, messageSendIndex++);
23 
24     //We add our own message to the message history in-case it gets relayed back to us
25     lock (lastPeerMessageDict) lastPeerMessageDict[NetworkComms.NetworkIdentifier] = messageToSend;
26 
27     //We write our own message to the chatBox
28     AppendLineToChatBox(messageToSend.SourceName + " - " + messageToSend.Message);
29 
30     //We refresh the MessagesFrom box so that it includes our own name
31     RefreshMessagesFromBox();
32 
33     //We clear the text within the messageText box.
34     this.messageText.Text = "";
35 
36     //If we provided server information we send to the server first
37     if (serverConnectionInfo != null)
38     {
39         //We perform the send within a try catch to ensure the application continues to run if there is a problem.
40         try { TCPConnection.GetConnection(serverConnectionInfo).SendObject("ChatMessage", messageToSend); }
41         catch (CommsException) { MessageBox.Show("A CommsException occurred while trying to send message to " + serverConnectionInfo, "CommsException", MessageBoxButton.OK); }
42     }
43 
44     //If we have any other connections we now send the message to those as well
45     //This ensures that if we are the server everyone who is connected to us gets our message
46     var otherConnectionInfos = (from current in NetworkComms.AllConnectionInfo() where current != serverConnectionInfo select current).ToArray();
47     foreach (ConnectionInfo info in otherConnectionInfos)
48     {
49         //We perform the send within a try catch to ensure the application continues to run if there is a problem.
50         try { TCPConnection.GetConnection(info).SendObject("ChatMessage", messageToSend); }
51         catch (CommsException) { MessageBox.Show("A CommsException occurred while trying to send message to " + info, "CommsException", MessageBoxButton.OK); }
52     }
53 }

 1 public MainWindow()
 2 {
 3     InitializeComponent();
 4 
 5     //Write the IP addresses and ports that we are listening on to the chatBox
 6     chatBox.AppendText("Initialised WPF chat example.");
 7 
 8     //Add a blank line after the initialisation output
 9     chatBox.AppendText("\n");
10 
11     //Set the default Local Name box using to the local host name
12     localName.Text = HostInfo.HostName;
13 
14     //Configure NetworkComms .Net to handle and incoming packet of type ‘ChatMessage‘
15     //e.g. If we receive a packet of type ‘ChatMessage‘ execute the method ‘HandleIncomingChatMessage‘
16     NetworkComms.AppendGlobalIncomingPacketHandler<ChatMessage>("ChatMessage", HandleIncomingChatMessage);
17 
18     //Configure NetworkComms .Net to perform an action when a connection is closed
19     //e.g. When a connection is closed execute the method ‘HandleConnectionClosed‘
20     NetworkComms.AppendGlobalConnectionCloseHandler(HandleConnectionClosed);
21 }