C# IMessage.ToString方法代码示例

        public void onMessage(IClientSessionChannel channel, IMessage message)
        {
            var data = message.DataAsDictionary;
            #if DEBUG
            Console.WriteLine(message.ToString());
            #endif

            string command = this.GetString(data, "command");
            switch (command)
            {
                case "status":
                case "statusOK":
                case "statusFAIL":
                    string computer = this.GetString(data, "computer");
                    string statusMessage = this.GetString(data, "status");

                    Console.WriteLine(string.Format("{0} - {1}", computer, statusMessage));

                    Status status;
                    if (command == "statusOK")
                        status = Status.Successful;
                    else if (command == "statusFAIL")
                        status = Status.Failure;
                    else
                        status = Status.Information;

                    var handler = this.StatusReceived;
                    if (handler != null)
                        handler(this, new StatusEventArgs(computer, status, statusMessage));
                    break;
            }
        }

        private void TraitementPREappel(IMessage msg)
        {
            if (msg is IMethodCallMessage) frmDemoInterceptionAppel.LogInfo(" is IMethodCallMessage");
            if (msg is IMethodMessage) frmDemoInterceptionAppel.LogInfo(" is IMethodMessage");

            if (msg is IMethodCallMessage)
            {
                IMethodCallMessage mcmsg=msg as IMethodCallMessage;
                string logtxt="Appel de " + mcmsg.MethodName;
                frmDemoInterceptionAppel.LogInfo(logtxt);
            }
            else frmDemoInterceptionAppel.LogInfo("PRE :" + msg.ToString());
        }

        public void guessTheWord(IMessage message)
        {
            if (message.ToString().Equals(gameRoom.Word, StringComparison.CurrentCultureIgnoreCase) == true)
            {
                gameRoom.WinnerId = user.Id;

                ServerContext.Instance.roomServices.addRoom(gameRoom);

                this.InvokeTo(c => c.gameRoom.Id == gameRoom.Id, gameRoom, "win");

                gameRoom = null;
            }
            else
            {
                this.InvokeTo(c => c.gameRoom.Id == gameRoom.Id, new UserMessage() { message = message.Data, user = user}, "wrong");
            }
        }

 // just for logging purposes
 private static void ClientServiceCallback(IMessage msg)
 {
     Console.WriteLine("{0}", msg.DescriptorForType.FullName);
     Console.WriteLine("{0}", msg.ToString());
 }

 private static void MessageHandler(IMessage msg)
 {
     //  Log incoming messages
     Log.Info(msg.ToString());
 }

        public override IMessage ServiceMessage(IMessage message)
        {
            if (FluorineContext.Current.Client != null)
                FluorineContext.Current.Client.Renew();

            if (message is CommandMessage)
            {
                CommandMessage commandMessage = message as CommandMessage;
                switch (commandMessage.operation)
                {
                    case CommandMessage.PollOperation:
                        {
                            if (log.IsDebugEnabled)
                                log.Debug(__Res.GetString(__Res.Endpoint_HandleMessage, this.Id, message.ToString()));

                            if (FluorineContext.Current.Client != null)
                                FluorineContext.Current.Client.Renew();

                            //IMessage[] messages = null;
                            IList messages = null;
                            _waitingPollRequests.Increment();
                            int waitIntervalMillis = this.ChannelDefinition.Properties.WaitIntervalMillis != -1 ? this.ChannelDefinition.Properties.WaitIntervalMillis : 60000;// int.MaxValue;

                            if (commandMessage.HeaderExists(CommandMessage.FluorineSuppressPollWaitHeader))
                                waitIntervalMillis = 0;
                            //If async handling was not set long polling is not supported
                            if (!FluorineConfiguration.Instance.FluorineSettings.Runtime.AsyncHandler)
                                waitIntervalMillis = 0;
                            if (this.ChannelDefinition.Properties.MaxWaitingPollRequests <= 0 || _waitingPollRequests.Value >= this.ChannelDefinition.Properties.MaxWaitingPollRequests)
                                waitIntervalMillis = 0;

                            if (message.destination != null && message.destination != string.Empty)
                            {
                                string clientId = commandMessage.clientId as string;
                                MessageDestination messageDestination = this.GetMessageBroker().GetDestination(message.destination) as MessageDestination;
                                MessageClient client = messageDestination.SubscriptionManager.GetSubscriber(clientId);
                                client.Renew();
                                //messages = client.GetPendingMessages();
                            }
                            else
                            {
                                //if (FluorineContext.Current.Client != null)
                                //    messages = FluorineContext.Current.Client.GetPendingMessages(waitIntervalMillis);
                            }

                            if (FluorineContext.Current.Client != null)
                            {
                                IEndpointPushHandler handler = FluorineContext.Current.Client.GetEndpointPushHandler(this.Id);
                                if (handler != null)
                                    messages = handler.GetPendingMessages();
                                if (messages == null)
                                {
                                    lock (handler.SyncRoot)
                                    {
                                        Monitor.Wait(handler.SyncRoot, waitIntervalMillis);
                                    }
                                    messages = handler.GetPendingMessages();
                                }
                            }

                            _waitingPollRequests.Decrement();
                            IMessage response = null;
                            if (messages == null || messages.Count == 0)
                                response = new AcknowledgeMessage();
                            else
                            {
                                CommandMessage resultMessage = new CommandMessage();
                                resultMessage.operation = CommandMessage.ClientSyncOperation;
                                resultMessage.body = messages;
                                response = resultMessage;
                            }
                            if (log.IsDebugEnabled)
                                log.Debug(__Res.GetString(__Res.Endpoint_Response, this.Id, response.ToString()));
                            return response;

                        }
                    case CommandMessage.SubscribeOperation:
                        {
                            /*
                            if (FluorineContext.Current.Client == null)
                                FluorineContext.Current.SetCurrentClient(this.GetMessageBroker().ClientRegistry.GetClient(message));
                            RemotingConnection remotingConnection = null;
                            foreach (IConnection connection in FluorineContext.Current.Client.Connections)
                            {
                                if (connection is RemotingConnection)
                                {
                                    remotingConnection = connection as RemotingConnection;
                                    break;
                                }
                            }
                            if (remotingConnection == null)
                            {
                                remotingConnection = new RemotingConnection(this, null, FluorineContext.Current.Client.Id, null);
                                FluorineContext.Current.Client.Renew(this.ClientLeaseTime);
                                remotingConnection.Initialize(FluorineContext.Current.Client);
                            }
                            FluorineWebContext webContext = FluorineContext.Current as FluorineWebContext;
                            webContext.SetConnection(remotingConnection);
                            */

//.........这里部分代码省略.........

 public void onMessage(IClientSessionChannel channel, IMessage message)
 {
     #if DEBUG
     Console.WriteLine("META: " + message.ToString());
     #endif
 }

 private static void ModuleLoadResponse(IMessage response)
 {
     Logger.Trace("ModuleLoadResponse(): {0}", response.ToString());
 }

		/// <summary>
		/// Call this method in order to send a message from your code into the message routing system.
		/// The message is routed to a service that is defined to handle messages of this type.
		/// Once the service is identified, the destination property of the message is used to find a destination configured for that service.
		/// The adapter defined for that destination is used to handle the message.
		/// </summary>
		/// <param name="message">The message to be routed to a service.</param>
		/// <param name="endpoint">This can identify the endpoint that is sending the message but it is currently not used so you may pass in null.</param>
        /// <returns>The result of the message routing.</returns>
		internal IMessage RouteMessage(IMessage message, IEndpoint endpoint)
		{
			IService service = null;
			object result = null;
			IMessage responseMessage = null;

            if( log.IsDebugEnabled )
                log.Debug(__Res.GetString(__Res.MessageBroker_RoutingMessage, message.ToString()));

			CommandMessage commandMessage = message as CommandMessage;
			if( commandMessage != null && (commandMessage.operation == CommandMessage.LoginOperation || commandMessage.operation == CommandMessage.LogoutOperation) )//Login, Logout
			{
				try
				{
					service = GetService(AuthenticationService.ServiceId);
					result = service.ServiceMessage(commandMessage);
					responseMessage = result as IMessage;
				}
                catch (UnauthorizedAccessException uae)
                {
                    if (log.IsDebugEnabled)
                        log.Debug(uae.Message);
                    responseMessage = ErrorMessage.GetErrorMessage(message, uae);
                }
                catch (SecurityException exception)
                {
                    if (log.IsDebugEnabled)
                        log.Debug(exception.Message);
                    responseMessage = ErrorMessage.GetErrorMessage(message, exception);
                }
				catch(Exception exception)
				{
					if(log.IsErrorEnabled)
						log.Error(__Res.GetString(__Res.MessageBroker_RoutingError), exception);
					responseMessage = ErrorMessage.GetErrorMessage(message, exception);
				}
			}
            else if (commandMessage != null && commandMessage.operation == CommandMessage.ClientPingOperation)
            {
                responseMessage = new AcknowledgeMessage();
                responseMessage.body = true;
            }
            else
            {
				//The only case when context is not set should be when one starts a new thread in the backend
                //if( FluorineContext.Current != null )
                //    FluorineContext.Current.RestorePrincipal(this.LoginCommand);
                _loginManager.RestorePrincipal();
				service = GetService(message);
                if (service != null)
                {
                    try
                    {
                        service.CheckSecurity(message);
                        result = service.ServiceMessage(message);
                    }
                    catch (UnauthorizedAccessException uae)
                    {
                        if (log.IsDebugEnabled)
                            log.Debug(uae.Message);
                        result = ErrorMessage.GetErrorMessage(message, uae);
                    }
                    catch (SecurityException exception)
                    {
                        if (log.IsDebugEnabled)
                            log.Debug(exception.Message);
                        result = ErrorMessage.GetErrorMessage(message, exception);
                    }
                    catch (ServiceException exception)
                    {
                        if (log.IsDebugEnabled)
                            log.Debug(exception.Message);
                        result = ErrorMessage.GetErrorMessage(message, exception);
                    }
                    catch (Exception exception)
                    {
                        if (log.IsErrorEnabled)
                            log.Error(exception.Message, exception);
                        result = ErrorMessage.GetErrorMessage(message, exception);
                    }
                }
                else
                {
                    string msg = __Res.GetString(__Res.Destination_NotFound, message.destination);
                    if (log.IsErrorEnabled)
                        log.Error(msg);
                    result = ErrorMessage.GetErrorMessage(message, new FluorineException(msg));
                }
                if (!(result is IMessage))
                {
                    responseMessage = new AcknowledgeMessage();
//.........这里部分代码省略.........

            public void Send(IMessage msg)
            {
                try
                {
                    // Only send retry once for each connection
                    if (IsRetrySent)
                        msg.Retry = null;

                    var text = msg.ToString();
                    StreamWriter.WriteLine(text);
                    StreamWriter.Flush();

                    if(!Message.IsOnlyComment(msg))
                        LastMessageId = msg.Id;

                    if (!string.IsNullOrWhiteSpace(msg.Retry))
                        IsRetrySent = true;
                }
                catch (HttpException ex)
                {
                    if (ex.ErrorCode == -2147023667) // The remote host closed the connection.
                    {
                        IsConnected = false;
                    }
                }
                catch (System.ServiceModel.CommunicationException)
                {
                    IsConnected = false;
                }
            }

        /// <summary>
        /// 对消息进行处理
        /// </summary>
        /// <param name="message">需处理的消息</param>
        /// <param name="logger">日志对象</param>
        /// todo：增加日志功能，需要设计变更
        public void Process(IMessage message, ILogger logger)
        {
            //if (logger != null && message != null)
            //{
            //	logger.WriteLog(Mysoft.ESB.Entity.Enumeration.LogLevel.Info, string.Format("{0}处理器Process前的日志", this.GetType().Name), message.ToString());
            //}

            this.EnterProcess(message);

            if (this.nextHandler != null)
            {
                this.nextHandler.Process(message, logger);
            }

            this.ReturnProcess(message);

            if (logger != null && message != null)
            {
                logger.WriteLog(Mysoft.ESB.Entity.Enumeration.LogLevel.Info, string.Format("{0}处理器Process后的日志", this.GetType().Name), message.ToString());
            }
        }

        public bool setTheWord(IMessage message)
        {
            try
            {

                gameRoom.Word = message.ToString();
                return true;

            }
            catch(Exception e)
            {
                return false;
            }
        }

        public void onMessage(IClientSessionChannel channel, IMessage message)
        {
            if (message.Channel.Equals(Channel_Fields.META_HANDSHAKE))
            {
                subscribed = false;
            }

            if (message.Channel.Equals(Channel_Fields.META_CONNECT) && message.Successful)
            {
                if (!subscribed)
                {
                    // Subscribe
                    callEventChannel.subscribe(this);
                    subscribed = true;
                }
            }

            if (message.ChannelId.ToString().Equals(channelId))
            {
                // Our message
                var data = message.DataAsDictionary;

                NameValueCollection nvc = new NameValueCollection(data.Count);
                foreach (var kvp in data)
                    nvc.Add(kvp.Key, kvp.Value.ToString());

                string command = nvc["command"];
                if (string.IsNullOrEmpty(command) || command == "status")
                    return;

                log.InfoFormat("Received command = {0}", command);

                string computer = nvc["computer"];
                if (!string.IsNullOrEmpty(computer) && !computer.Equals(Environment.MachineName, StringComparison.OrdinalIgnoreCase))
                    return;

                switch (command)
                {
                    case "deploy":
                        RaiseUpdateAvailable(nvc);
                        break;
                    case "ping":
                        PublishStatus("Pong");
                        break;
                }

                return;
            }

            try
            {
                log.Debug("Message on " + message.ChannelId.ToString() + "   Data: " + message.ToString());
            }
            catch
            {
            }
        }

        public static IMessage Deserialize(BinaryReader reader, IMessage messageBase)
        {
            var messageType = messageBase.GetType();
            var fieldInfo = messageType.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);

            var attributeCount = reader.ReadByte();

            for (int i = 0; i < attributeCount; i++)
            {
                // TODO: Be brave enough to find an elegant fix for this
                // XFire decides not to follow its own rules. Message type 32 does not have a prefix byte for the length of the attribute name
                // and breaks this code. Assume first byte after the attribute count as the attribute name
                string attributeName = null;
                if (messageType == typeof(StatusChange))
                {
                    attributeName = Encoding.UTF8.GetString(reader.ReadBytes(1));
                }
                else
                {
                    var attributeNameLength = reader.ReadByte();
                    attributeName = Encoding.UTF8.GetString(reader.ReadBytes(attributeNameLength));
                }
                var attributeType = reader.ReadByte();

                dynamic value = XFireAttributeFactory.Instance.GetAttribute(attributeType).ReadValue(reader);

                var field = fieldInfo.Where(a => a.GetCustomAttribute<XFireAttributeDef>() != null)
                    .FirstOrDefault(a => a.GetCustomAttribute<XFireAttributeDef>().Name == attributeName);

                if (field != null)
                {
                    field.SetValue(messageBase, value);
                }
                else
                {
                    Debug.WriteLine(string.Format("WARN: No attribute defined for {0} on class {1}", attributeName, messageType.Name));
                }
            }

            Debug.WriteLine("Deserialized [{0}]: {1}", messageType, messageBase.ToString());

            return messageBase as IMessage;
        }

        private void ProcessInThread(IMessage processor, string replyTo, string method, object args)
        {
            try
            {
                // TODO: vladi: implement the long running part
                //if (processor.GetType().GetMethod(method) != null)
                if (processor != null)
                {
                    if (processor.IsLongRunning())
                    {
                        if (this.RestartingAgent)
                        {
                            RemoteException exception = new RemoteException("restarting agent");
                            // todo: vlad: fix the hash here
                            this.Publish(replyTo, exception.ToHash().ToString());
                        }
                        else
                        {
                            this.Lock.WaitOne();
                            try
                            {
                                if (this.LongRunningAgentTask.Count == 0)
                                {
                                    this.ProcessLongRunning(replyTo, processor, args);
                                }
                                else
                                {
                                    RemoteException exception = new RemoteException("already running long running task");
                                    // todo: vlad: fix the hash here
                                    this.Publish(replyTo, exception.ToHash().ToString());
                                }
                            }
                            finally
                            {
                                this.Lock.ReleaseMutex();
                            }
                        }
                    }
                    else
                    {
                        string payload = this.Process(processor, args);

                        if (Config.Configure != null && (method == "prepare_network_change"))
                        {
                            // todo: vladi: fix payload
                            this.Publish(replyTo, payload, () => PostPrepareNetworkChange());
                        }
                        else
                        {
                            // todo: vladi: fix payload
                            this.Publish(replyTo, payload.ToString());
                        }
                    }
                }

            }
            catch (Exception ex)
            {
                // since this is running in a thread we're going to be nice and
                // log an error as this would otherwise be lost
                Logger.Error("{0}: {1)", processor.ToString(), ex.ToString());
            }
        }