C# Message类代码示例

        //Can only be called inside a service
        public static void PromoteException(Exception error,MessageVersion version,ref Message fault)
        {
            StackFrame frame = new StackFrame(1);

             Type serviceType = frame.GetMethod().ReflectedType;
             PromoteException(serviceType,error,version,ref fault);
        }

        // DeckList && LibraryView
        public void handleMessage(Message msg)
        {
            if( msg is LibraryViewMessage && config.ContainsKey("user-id") ) {
                LibraryViewMessage viewMsg = (LibraryViewMessage) msg;
                if( !viewMsg.profileId.Equals(App.MyProfile.ProfileInfo.id) ) {
                    return;
                }

                inventoryCards.Clear();
                foreach( Card card in viewMsg.cards ) {
                    inventoryCards[card.id] = String.Format("{0},{1}", card.typeId, card.tradable ? 1 : 0);
                }

                if( dataPusher == null ) {
                    if( config.ContainsKey("last-card-sync") ) {
                        dataPusher = new Thread(new ThreadStart(DelayedPush));
                    } else {
                        dataPusher = new Thread(new ThreadStart(Push));
                    }

                    dataPusher.Start();
                }

            //} else if( msg is DeckCardsMessage ) {
            //    DeckCardsMessage deckMsg = (DeckCardsMessage)msg;
            //} else if( msg is DeckSaveMessage ) {
            }
        }

 // Create a message and send it to IoT Hub.
 async Task SendEvent(string power)
 {
     string dataBuffer;
     dataBuffer = power;
     Message eventMessage = new Message(Encoding.UTF8.GetBytes(dataBuffer));
     await deviceClient.SendEventAsync(eventMessage);
 }

        /// <summary>
        /// Add token message at header to using NHibernate cache
        /// </summary>
        /// <param name="request"></param>
        /// <param name="channel"></param>
        /// <returns></returns>
        public object BeforeSendRequest(ref Message request, IClientChannel channel)
        {
            // add trace log for debug and performance tuning
            if (null != (request.Headers).MessageId && (request.Headers).MessageId.IsGuid)
            {
                ServiceStopWatch = Stopwatch.StartNew();
                Guid messageId;
                (request.Headers).MessageId.TryGetGuid(out messageId);

                CurrentTraceInfo = new TraceInfo()
                {
                    SessionId = (HttpContext.Current != null && HttpContext.Current.Session != null) ? HttpContext.Current.Session.SessionID : "",
                    TraceType = TraceType.WcfActionClientCall,
                    TraceName = request.Headers.Action,
                    TraceUniqueId = messageId.ToString()
                };

                TraceLogger.Instance.TraceServiceStart(CurrentTraceInfo, true);

                // Add a message header with sessionid
                MessageHeader<string> messageHeader = new MessageHeader<string>(CurrentTraceInfo.SessionId);
                MessageHeader untyped = messageHeader.GetUntypedHeader("sessionid", "ns");
                request.Headers.Add(untyped);
            }
            return null;
        }

        public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
        {
            bool shouldCompressResponse = false;

            object propObj;
            if (request.Properties.TryGetValue(HttpRequestMessageProperty.Name, out propObj))
            {
                var prop = (HttpRequestMessageProperty)propObj;
                var accept = prop.Headers[HttpRequestHeader.Accept];
                if (accept != null)
                {
                    if (jsonContentTypes.IsMatch(accept))
                    {
                        WebOperationContext.Current.OutgoingResponse.Format = WebMessageFormat.Json;
                    }
                    else if (xmlContentTypes.IsMatch(accept))
                    {
                        WebOperationContext.Current.OutgoingResponse.Format = WebMessageFormat.Xml;
                    }
                }

                var acceptEncoding = prop.Headers[HttpRequestHeader.AcceptEncoding];
                if (acceptEncoding != null && acceptEncoding.Contains("gzip"))
                {
                    shouldCompressResponse = true;
                }
            }

            return shouldCompressResponse;
        }

        /// <summary>
        /// Parses the JSON message from Amazon SNS into the Message object.
        /// </summary>
        /// <param name="messageText">The JSON text from an Amazon SNS message</param>
        /// <returns>The Message object with properties set from the JSON document</returns>
        public static Message ParseMessage(string messageText)
        {
            var message = new Message();

            var jsonData = JsonMapper.ToObject(messageText);

            Func<string, string> extractField = ((fieldName) =>
                {
                    if (jsonData[fieldName] != null && jsonData[fieldName].IsString)
                        return (string)jsonData[fieldName];
                    return null;
                });

            message.MessageId = extractField("MessageId");
            message.MessageText = extractField("Message");
            message.Signature = extractField("Signature");
            message.SignatureVersion = extractField("SignatureVersion");
            message.SigningCertURL = ValidateCertUrl(extractField("SigningCertURL"));
            message.SubscribeURL = extractField("SubscribeURL");
            message.Subject = extractField("Subject");
            message.TimestampString = extractField("Timestamp");
            message.Token = extractField("Token");
            message.TopicArn = extractField("TopicArn");
            message.Type = extractField("Type");
            message.UnsubscribeURL = extractField("UnsubscribeURL");

            return message;
        }

 public static int AddMessage(Message obj)
 {
     int result;
     TMSDataLibrary.Message objMsg = new TMSDataLibrary.Message();
     result = objMsg.AddMessege(obj.BookingId, obj.ToId, obj.FromId, obj.Messagee);
     return result;
 }

 public object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext)
 {
     var reply = request.Headers.ReplyTo;
     OperationContext.Current.OutgoingMessageHeaders.To = reply.Uri;
     OperationContext.Current.OutgoingMessageHeaders.RelatesTo = request.Headers.MessageId;
     return null;
 }

        public static Message CreateSlackMessage(string text, IEnumerable<AttachmentField> fields, BotElement bot, string channel, string color, bool asUser)
        {
            if (text == null) return null;
            IEnumerable<Attachment> attachments = null;
            if (fields != null && fields.Any())
            {
                attachments = new[] {
                    new Attachment() {
                        Fallback = text,
                        Color = color,
                        Fields = fields
                    }
                };
            }
            var message = new Message()
            {
                Channel = channel,
                Text = text,
                Attachments = attachments
            };

            if (!asUser)
            {
                message.Username = bot.GetSetting("username");
                if (!string.IsNullOrEmpty(bot.GetSetting("iconUrl")))
                    message.IconUrl = bot.GetSetting("iconUrl");
                else if (!string.IsNullOrEmpty(bot.GetSetting("iconEmoji")))
                    message.IconEmoji = bot.GetSetting("iconEmoji");
            }

            return message;
        }

 public HotkeyMessage(Message messageType, Level messageLevel, IntPtr hWnd, int Data)
 {
     Message = messageType;
     level = messageLevel;
     handle = hWnd;
     data = Data;
 }

		private void FormattedMessage(Message message, char format, StringBuilder output)
		{
			using (var writer = CreateWriter(message, format, output))
			{
				switch (format)
				{
					case 'b':
						message.WriteBody(writer);
						break;
					case 'B':
						message.WriteBodyContents(writer);
						break;
					case 's':
						message.WriteStartBody(writer);
						break;
					case 'S':
						message.WriteStartEnvelope(writer);
						break;
					case 'm':
					case 'M':
						message.WriteMessage(writer);
						break;
					default:
						return;
				}

				writer.Flush();
			}
		}

		private void FormattedHeaders(Message message, StringBuilder output)
		{
			foreach (var header in message.Headers)
			{
				output.AppendFormat("\n{0}\n", header);
			}
		}

        public void Should_not_overwrite_correlation_id()
        {
            var autoResetEvent = new AutoResetEvent(false);
            const string expectedCorrelationId = "abc_foo";
            var actualCorrelationId = "";

            var queue = EasyNetQ.Topology.Queue.DeclareDurable("myqueue");
            var exchange = EasyNetQ.Topology.Exchange.DeclareDirect("myexchange");
            queue.BindTo(exchange, "#");
            bus.Subscribe<MyMessage>(queue, (message, info) => Task.Factory.StartNew(() =>
            {
                actualCorrelationId = message.Properties.CorrelationId;
                autoResetEvent.Set();
            }));

            var messageToSend = new Message<MyMessage>(new MyMessage());
            messageToSend.Properties.CorrelationId = expectedCorrelationId;

            using (var channel = bus.OpenPublishChannel())
            {
                channel.Publish(exchange, "abc", messageToSend);
            }

            autoResetEvent.WaitOne(1000);

            actualCorrelationId.ShouldEqual(expectedCorrelationId);
        }

        public override bool CheckAccess(OperationContext operationContext, ref Message message)
        {
            // Open the request message using an xml reader
            XmlReader xr = OperationContext.Current.IncomingMessageHeaders.GetReaderAtHeader(0);

                // Split the URL at the API name--Parameters junction indicated by the '?' character - taking the first string will ignore all parameters
                string[] urlSplit = xr.ReadElementContentAsString().Split('/');
                // Extract just the API name and rest of the URL, which will be the last item in the split using '/'
                string[] apiSplit = urlSplit[3].Split('?');
                // Logging the username and API name
                Tracer.WriteUserLog(apiSplit[0] + " request from user: " + operationContext.ServiceSecurityContext.WindowsIdentity.Name);

            // If the most-privileged-role that this user belongs has access to this api, then allow access, otherwise deny access
            // Returning true will allow the user to execute the actual API function; Returning false will deny access to the user
            if (ChassisManagerSecurity.GetCurrentUserMostPrivilegedRole() <= ChassisManagerSecurity.GetCurrentApiLeastPrivilegedRole(apiSplit[0]))
            {
                Tracer.WriteUserLog("CheckAccess: Authorized");
                return true;
            }
            else
            {
                Tracer.WriteUserLog("CheckAccess: NOT Authorized");
                return false;
            }
        }

    public void OnClick(string name )
    {
        Debug.Log("Click " + name );
        Message msg = new Message();
        msg.AddMessage("name", name);
        EventManager.Instance.PostEvent(EventDefine.TL_PRESS_BUTTON, msg);

        if (name == "Cone")
        {
            SpriteAction sa = coneEffect.GetComponent<SpriteAction>();
            SpriteRenderer render = coneEffect.GetComponent<SpriteRenderer>();

            render.color = new Color(Random.Range(0.5f , 1f) , Random.Range(0.5f , 1f) , Random.Range(0.5f , 1f) , 0.5f );
            sa.Do();
        }
        if (name == "Bubble")
        {
            bubbleEffect.enableEmission = true;
        }
        if (name == "Flower")
        {
            AudioSource[] audios = flowerEffect.GetComponents<AudioSource>();
            audios[Random.Range(0, audios.Length)].Play();
        }
    }