C# MessageReader.Read方法代码示例

 public void HandleAdminMessage(byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         AdminMessageType messageType = (AdminMessageType)mr.Read<int>();
         switch (messageType)
         {
             case AdminMessageType.LIST:
                 {
                     string[] adminNames = mr.Read<string[]>();
                     foreach (string adminName in adminNames)
                     {
                         RegisterServerAdmin(adminName);
                     }
                 }
                 break;
             case AdminMessageType.ADD:
                 {
                     string adminName = mr.Read<string>();
                     RegisterServerAdmin(adminName);
                 }
                 break;
             case AdminMessageType.REMOVE:
                 {
                     string adminName = mr.Read<string>();
                     UnregisterServerAdmin(adminName);
                 }
                 break;
         }
     }
 }

 public static void HandlePlayerColor(ClientObject client, byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         PlayerColorMessageType messageType = (PlayerColorMessageType)mr.Read<int>();
         switch (messageType)
         {
             case PlayerColorMessageType.SET:
                 {
                     string playerName = mr.Read<string>();
                     if (playerName != client.playerName)
                     {
                         DarkLog.Debug(client.playerName + " tried to send a color update for " + playerName + ", kicking.");
                         Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for sending a color update for another player");
                         return;
                     }
                     client.playerColor = mr.Read<float[]>();
                     //Relay the message
                     ServerMessage newMessage = new ServerMessage();
                     newMessage.type = ServerMessageType.PLAYER_COLOR;
                     newMessage.data = messageData;
                     ClientHandler.SendToAll(client, newMessage, true);
                 }
                 break;
         }
     }
 }

 public static void HandleSplitMessage(ClientObject client, byte[] messageData)
 {
     if (!client.isReceivingSplitMessage)
     {
         //New split message
         using (MessageReader mr = new MessageReader(messageData))
         {
             client.receiveSplitMessage = new ClientMessage();
             client.receiveSplitMessage.type = (ClientMessageType)mr.Read<int>();
             client.receiveSplitMessage.data = new byte[mr.Read<int>()];
             client.receiveSplitMessageBytesLeft = client.receiveSplitMessage.data.Length;
             byte[] firstSplitData = mr.Read<byte[]>();
             firstSplitData.CopyTo(client.receiveSplitMessage.data, 0);
             client.receiveSplitMessageBytesLeft -= firstSplitData.Length;
         }
         client.isReceivingSplitMessage = true;
     }
     else
     {
         //Continued split message
         messageData.CopyTo(client.receiveSplitMessage.data, client.receiveSplitMessage.data.Length - client.receiveSplitMessageBytesLeft);
         client.receiveSplitMessageBytesLeft -= messageData.Length;
     }
     if (client.receiveSplitMessageBytesLeft == 0)
     {
         ClientHandler.HandleMessage(client, client.receiveSplitMessage);
         client.receiveSplitMessage = null;
         client.isReceivingSplitMessage = false;
     }
 }

 public static void HandleVesselRemoval(ClientObject client, byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         //Don't care about the subspace on the server.
         mr.Read<double>();
         string vesselID = mr.Read<string>();
         bool isDockingUpdate = mr.Read<bool>();
         if (!isDockingUpdate)
         {
             DarkLog.Debug("Removing vessel " + vesselID + " from " + client.playerName);
         }
         else
         {
             DarkLog.Debug("Removing DOCKED vessel " + vesselID + " from " + client.playerName);
         }
         if (File.Exists(Path.Combine(Server.universeDirectory, "Vessels", vesselID + ".txt")))
         {
             lock (Server.universeSizeLock)
             {
                 File.Delete(Path.Combine(Server.universeDirectory, "Vessels", vesselID + ".txt"));
             }
         }
         //Relay the message.
         ServerMessage newMessage = new ServerMessage();
         newMessage.type = ServerMessageType.VESSEL_REMOVE;
         newMessage.data = messageData;
         ClientHandler.SendToAll(client, newMessage, false);
     }
 }

        public static void HandleScenarioModuleData(ClientObject client, byte[] messageData)
        {
            using (MessageReader mr = new MessageReader(messageData))
            {
                //Don't care about subspace / send time.
                string[] scenarioName = mr.Read<string[]>();
                DarkLog.Debug("Saving " + scenarioName.Length + " scenario modules from " + client.playerName);

                for (int i = 0; i < scenarioName.Length; i++)
                {
                    byte[] scenarioData = Compression.DecompressIfNeeded(mr.Read<byte[]>());
                    File.WriteAllBytes(Path.Combine(Server.universeDirectory, "Scenarios", client.playerName, scenarioName[i] + ".txt"), scenarioData);
                }
            }
        }

 public static void HandleModDataMessage(ClientObject client, byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         string modName = mr.Read<string>();
         bool relay = mr.Read<bool>();
         bool highPriority = mr.Read<bool>();
         byte[] modData = mr.Read<byte[]>();
         if (relay)
         {
             DMPModInterface.SendDMPModMessageToAll(client, modName, modData, highPriority);
         }
         DMPModInterface.OnModMessageReceived(client, modName, modData);
     }
 }

 public void HandleLockMessage(byte[] messageData)
 {
     lock (lockObject)
     {
         using (MessageReader mr = new MessageReader(messageData, false))
         {
             LockMessageType lockMessageType = (LockMessageType)mr.Read<int>();
             switch (lockMessageType)
             {
                 case LockMessageType.LIST:
                     {
                         //We shouldn't need to clear this as LIST is only sent once, but better safe than sorry.
                         serverLocks.Clear();
                         string[] lockKeys = mr.Read<string[]>();
                         string[] lockValues = mr.Read<string[]>();
                         for (int i = 0; i < lockKeys.Length; i++)
                         {
                             serverLocks.Add(lockKeys[i], lockValues[i]);
                         }
                     }
                     break;
                 case LockMessageType.ACQUIRE:
                     {
                         string playerName = mr.Read<string>();
                         string lockName = mr.Read<string>();
                         bool lockResult = mr.Read<bool>();
                         if (lockResult)
                         {
                             serverLocks[lockName] = playerName;
                         }
                         FireAcquireEvent(playerName, lockName, lockResult);
                     }
                     break;
                 case LockMessageType.RELEASE:
                     {
                         string playerName = mr.Read<string>();
                         string lockName = mr.Read<string>();
                         if (serverLocks.ContainsKey(lockName))
                         {
                             serverLocks.Remove(lockName);
                         }
                         FireReleaseEvent(playerName, lockName);
                     }
                     break;
             }
         }
     }
 }

 public static void HandleVesselsRequest(ClientObject client, byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         int sendVesselCount = 0;
         int cachedVesselCount = 0;
         List<string> clientRequested = new List<string>(mr.Read<string[]>());
         lock (Server.universeSizeLock)
         {
             foreach (string file in Directory.GetFiles(Path.Combine(Server.universeDirectory, "Vessels")))
             {
                 string vesselID = Path.GetFileNameWithoutExtension(file);
                 byte[] vesselData = File.ReadAllBytes(file);
                 string vesselObject = Common.CalculateSHA256Hash(vesselData);
                 if (clientRequested.Contains(vesselObject))
                 {
                     sendVesselCount++;
                     VesselProto.SendVessel(client, vesselID, vesselData);
                 }
                 else
                 {
                     cachedVesselCount++;
                 }
             }
         }
         DarkLog.Debug("Sending " + client.playerName + " " + sendVesselCount + " vessels, cached: " + cachedVesselCount + "...");
         SendVesselsComplete(client);
     }
 }

 public static void HandleWarpControl(ClientObject client, byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         WarpMessageType warpType = (WarpMessageType)mr.Read<int>();
         switch (warpType)
         {
             case WarpMessageType.REQUEST_CONTROLLER:
                 {
                     HandleRequestController(client);
                 }
                 break;
             case WarpMessageType.RELEASE_CONTROLLER:
                 {
                     HandleReleaseController(client);
                 }
                 break;
             case WarpMessageType.REPLY_VOTE:
                 {
                     bool voteReply = mr.Read<bool>();
                     HandleReplyVote(client, voteReply);
                 }
                 break;
             case WarpMessageType.NEW_SUBSPACE:
                 {
                     long serverTime = mr.Read<long>();
                     double planetTime = mr.Read<double>();
                     float subspaceRate = mr.Read<float>();
                     HandleNewSubspace(client, serverTime, planetTime, subspaceRate);
                 }
                 break;
             case WarpMessageType.CHANGE_SUBSPACE:
                 {
                     int newSubspace = mr.Read<int>();
                     HandleChangeSubspace(client, newSubspace);
                 }
                 break;
             case WarpMessageType.REPORT_RATE:
                 {
                     float newSubspaceRate = mr.Read<float>();
                     HandleReportRate(client, newSubspaceRate);
                 }
                 break;
             case WarpMessageType.CHANGE_WARP:
                 {
                     bool physWarp = mr.Read<bool>();
                     int rateIndex = mr.Read<int>();
                     long serverClock = mr.Read<long>();
                     double planetTime = mr.Read<double>();
                     HandleChangeWarp(client, physWarp, rateIndex, serverClock, planetTime);
                 }
                 break;
                 #if DEBUG
             default:
                 throw new NotImplementedException("Warp type not implemented");
                 #endif
         }
     }
 }

 public void OnMessageReceived(ClientObject client, ClientMessage message)
 {
     if (message.type == ClientMessageType.CHAT_MESSAGE)
     {
         using (MessageReader mr = new MessageReader(message.data, false))
         {
             ChatMessageType messageType = (ChatMessageType)mr.Read<int>();
             string fromPlayer = mr.Read<string>();
             if (messageType == ChatMessageType.CHANNEL_MESSAGE)
             {
                 string channel = mr.Read<string>();
                 string umessage = mr.Read<string>();
                 ircClient.Channels["#" + channel].SendMessage(String.Format("{0} -> {1}", fromPlayer, umessage));
             }
         }
     }
 }

        public void HandleMessage(byte[] messageData)
        {
            using (MessageReader mr = new MessageReader(messageData))
            {
                FlagMessageType messageType = (FlagMessageType)mr.Read<int>();
                switch (messageType)
                {
                    case FlagMessageType.LIST:
                        {
                            //List code
                            string[] serverFlagFiles = mr.Read<string[]>();
                            string[] serverFlagOwners = mr.Read<string[]>();
                            string[] serverFlagShaSums = mr.Read<string[]>();
                            for (int i = 0; i < serverFlagFiles.Length; i++)
                            {
                                FlagInfo fi = new FlagInfo();
                                fi.owner = serverFlagOwners[i];
                                fi.shaSum = serverFlagShaSums[i];
                                serverFlags[Path.GetFileNameWithoutExtension(serverFlagFiles[i])] = fi;
                            }
                            syncComplete = true;
                            //Check if we need to upload the flag
                            flagChangeEvent = true;
                        }
                        break;
                    case FlagMessageType.FLAG_DATA:
                        {
                            FlagRespondMessage frm = new FlagRespondMessage();
                            frm.flagInfo.owner = mr.Read<string>();
                            frm.flagName = mr.Read<string>();
                            frm.flagData = mr.Read<byte[]>();
                            frm.flagInfo.shaSum = Common.CalculateSHA256Hash(frm.flagData);
                            newFlags.Enqueue(frm);
                        }
                        break;
                    case FlagMessageType.DELETE_FILE:
                        {
                            string flagName = mr.Read<string>();
                            string flagFile = Path.Combine(flagPath, flagName);
                            if (File.Exists(flagFile))
                            {
                                try
                                {

                                    if (File.Exists(flagFile))
                                    {
                                        DarkLog.Debug("Deleting flag " + flagFile);
                                        File.Delete(flagFile);
                                    }
                                }
                                catch (Exception e)
                                {
                                    DarkLog.Debug("Error deleting flag " + flagFile + ", exception: " + e);
                                }
                            }
                        }
                        break;
                }
            }
        }

 public static void HandleConnectionEnd(ClientObject client, byte[] messageData)
 {
     string reason = "Unknown";
     using (MessageReader mr = new MessageReader(messageData))
     {
         reason = mr.Read<string>();
     }
     DarkLog.Debug(client.playerName + " sent connection end message, reason: " + reason);
     ClientHandler.DisconnectClient(client);
 }

 public static void HandlePlayerStatus(ClientObject client, byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         string playerName = mr.Read<string>();
         if (playerName != client.playerName)
         {
             DarkLog.Debug(client.playerName + " tried to send an update for " + playerName + ", kicking.");
             Messages.ConnectionEnd.SendConnectionEnd(client, "Kicked for sending an update for another player");
             return;
         }
         client.playerStatus.vesselText = mr.Read<string>();
         client.playerStatus.statusText = mr.Read<string>();
     }
     //Relay the message
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.PLAYER_STATUS;
     newMessage.data = messageData;
     ClientHandler.SendToAll(client, newMessage, false);
 }

 public static void HandleKerbalProto(ClientObject client, byte[] messageData)
 {
     //Send kerbal
     using (MessageReader mr = new MessageReader(messageData))
     {
         //Don't care about subspace / send time.
         mr.Read<double>();
         string kerbalName = mr.Read<string>();
         DarkLog.Debug("Saving kerbal " + kerbalName + " from " + client.playerName);
         byte[] kerbalData = mr.Read<byte[]>();
         lock (Server.universeSizeLock)
         {
             File.WriteAllBytes(Path.Combine(Server.universeDirectory, "Kerbals", kerbalName + ".txt"), kerbalData);
         }
     }
     ServerMessage newMessage = new ServerMessage();
     newMessage.type = ServerMessageType.KERBAL_REPLY;
     newMessage.data = messageData;
     ClientHandler.SendToAll(client, newMessage, false);
 }

 //Receive message data (PROTOCOL 1):
 //int ckan protocol version
 //int ckan request type:
 //1: CKAN metadata file
 //Send message data (PROTOCOL 1):
 //int ckan protocol version
 //bool ckan available (true/false)
 //if ckan available: UTF-8 string (ckan export data)
 private void OnCKANRequest(ClientObject client, byte[] messageData)
 {
     using (MessageReader mr = new MessageReader(messageData))
     {
         int clientProtocol = mr.Read<int>();
         if (clientProtocol != CKAN_PROTOCOL_VERSION)
         {
             DarkLog.Error("Client " + client.playerName + " connected with CKAN protocol " + clientProtocol + ", server version: " + CKAN_PROTOCOL_VERSION);
             return;
         }
         int requestType = mr.Read<int>();
         switch (requestType)
         {
             case 1:
                 SendCKANFileToClient(client);
                 break;
             default:
                 DarkLog.Error("Unknown CKAN request type: " + requestType);
                 break;
         }
     }
 }