C# Message.GetBody方法代码示例

        public Model.Message GetMessage(Message message)
        {
            var msgBytes = message.GetBody<byte[]>();
            var content = Encoding.UTF8.GetString(msgBytes);

            return JsonConvert.DeserializeObject<Model.Message>(content);
        }

        public Message Request(Message req)
        {
            ServiceResponse resp = new ServiceResponse();

            try
            {

                ServiceRequest servReq = req.GetBody<ServiceRequest>();
                servReq.Password = req.Headers.GetHeader<string>("Password", "");
                servReq.ServiceAction = req.Headers.GetHeader<string>("ServiceAction", "");

                servReq.Password = Decrypt(servReq.Password);
                servReq.Data = Decrypt(servReq.Data);

                resp.ErrorNumber = 0;
                resp.ErrorMessage = string.Empty;
                resp.IsSuccessful = true;
                //resp.Data = "Brian Spencer Test";
                resp.Data = string.Format("Action: {0}; Username: {1}; Password: {2}; Data: {3}", servReq.ServiceAction, servReq.UserName, servReq.Password, servReq.Data);

            }
            catch (Exception ex)
            {
                resp.ErrorNumber = 9000;
                resp.ErrorMessage = ex.Message;
                resp.IsSuccessful = false;
                resp.Data = "Error";
            }

            MessageVersion ver = OperationContext.Current.IncomingMessageVersion;
            return Message.CreateMessage(ver, "http://dis.lashgroup.com/Response", resp);
        }

        public MessageItem(Message message)
        {
            Action = message.Headers.Action;

            Stream body = message.GetBody<Stream>();

            using (var reader = new StreamReader(body))
                Data = reader.ReadToEnd();
        }

		public Message ConcatStrings (Message request)
		{
			string str = string.Empty;

			string [] inputStrings = request.GetBody<string []> ();
			for (int i = 0; i < inputStrings.Length; i++)
				str += inputStrings [i];

			Message response = Message.CreateMessage (request.Version, ReplyAction, str);
			return response;
		}

        public void SubscribeToCardSwipe(Message message)
        {
            var current = OperationContext.Current.GetCallbackChannel<IWebCardReaderEventsCallBack>();

            if (message == null || current==null)
            {
                throw new ArgumentNullException("message or current is null");
            }

            WebSocketMessageProperty property =
                (WebSocketMessageProperty)message.Properties["WebSocketMessageProperty"];
            WebSocketContext context = property.WebSocketContext;

            var queryParameters = HttpUtility.ParseQueryString(context.RequestUri.Query);
            string content = string.Empty;

            if (!message.IsEmpty)
            {
                byte[] body = message.GetBody<byte[]>();
                content = Encoding.UTF8.GetString(body);

                //client needs to send this to ensure connection is open.
                if(content== "KeepAlive")
                {
                    return;
                }
            }

            // Do something with the content/queryParams
            // ...

            string str = null;
            if (string.IsNullOrEmpty(content)) // Connection open message
            {
                str = "Opening connection from host " + queryParameters["Name"].ToString();
            }
            else // Message received from client
            {
                str = "Received message: " + content;
            }

            var hostName = queryParameters["Name"].ToString();

            if (!_webCardReaderSubscription.ContainsKey(hostName) && current!=null)
            {
                _webCardReaderSubscription.Add(hostName, current);
            }
            else
            {
                _webCardReaderSubscription[hostName] = current;
            }

            // current.SendCardSwipe(CreateMessage(str));
        }

        public async Task SendMessage(Message message)
        {
            if (message.IsEmpty) return;

            byte[] body = message.GetBody<byte[]>();
            WebSocketMessageProperty property = 
                (WebSocketMessageProperty)message.Properties[webSocketMessageProperty];
            WebSocketMessageType type = property.MessageType;

            IServiceCallback callback = 
                OperationContext.Current.GetCallbackChannel<IServiceCallback>();

            IChannel channel = (IChannel)callback;
            channel.Faulted += channel_Faulted;
            channel.Closed += channel_Closed;

            if (channel.State == CommunicationState.Opened)
                await callback.ReceiveMessage(CreateMessage(body, type));
        }

        public Stream GetResponseMessageStream(Message message)
        {
            if (message == null)
            {
                throw FxTrace.Exception.ArgumentNull("message");
            }

            ThrowIfMismatchedMessageVersion(message);

            if (!ByteStreamMessage.IsInternalByteStreamMessage(message))
            {
                return null;
            }

            return message.GetBody<Stream>();
        }

        /// <summary>
        /// Executes the request message on the target system and returns a response message.
        /// If there isn’t a response, this method should return null
        /// </summary>
        public Message Execute(Message message, TimeSpan timeout)
        {
            var generator = new NameGenerator(message,
                Connection.ConnectionFactory.ConnectionUri.Path, Connection.ConnectionFactory.ConnectionUri.FileName);

            string sourcePath = new Uri(message.Headers.Action).LocalPath;

            string targetFolder = generator.Folder;
            string targetPath = Path.Combine(targetFolder, generator.FileName).Replace('\\', '/');

            if (!targetPath.StartsWith("/"))
                targetPath = string.Concat("/", targetPath);

            var client = Connection.Client;

            if (!client.DirectoryExists(targetFolder))
                client.CreateDirectory(targetFolder);

            Stream outputStream = null;

            switch (Connection.ConnectionFactory.Adapter.OverwriteAction)
            {
                case OverwriteAction.None:
                    if (client.FileExists(targetPath))
                        throw new FtpException(string.Format("The file '{0}' already exists.", targetPath));

                    outputStream = client.OpenWrite(targetPath);
                    break;
                case OverwriteAction.Replace:
                    outputStream = client.OpenWrite(targetPath);
                    break;
                case OverwriteAction.Append:
                    outputStream = client.OpenAppend(targetPath);
                    break;
            }

            using (outputStream)
            {
                var inputStream = message.GetBody<Stream>();
                inputStream.CopyTo(outputStream);

                return Message.CreateMessage(MessageVersion.Default, string.Empty);
            }
        }

        Message AddCustomer(Message message)
        {
            Message response = null;
            HttpRequestMessageProperty requestProperties = message.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;

            HttpResponseMessageProperty responseProperties = new HttpResponseMessageProperty();

            Console.WriteLine("Received " + requestProperties.Method + " for Customer.");
            Customer customer = message.GetBody<Customer>();

            Console.WriteLine("\tCustomer Data - Name: " + customer.Name + " Address: " + customer.Address);
            if (customer != null)
            {
                this.nextId += 1;
                this.customerList[nextId.ToString()] = customer;

                Uri collectionUri = message.Properties.Via;

                responseProperties.StatusCode = HttpStatusCode.Created;
                responseProperties.Headers[ HttpResponseHeader.Location ] = new Uri( collectionUri, this.nextId.ToString() ).ToString();
            }
            else
            {
                responseProperties.StatusCode = HttpStatusCode.BadRequest;
            }

            responseProperties.SuppressEntityBody = true;
            response = Message.CreateMessage(message.Version, message.Headers.Action, String.Empty);
            response.Properties[HttpResponseMessageProperty.Name] = responseProperties;

            return response;

        }

        Message UpdateCustomer(Message message)
        {
            Message response = null;

            HttpRequestMessageProperty requestProperties = message.Properties[HttpRequestMessageProperty.Name] as HttpRequestMessageProperty;
            HttpResponseMessageProperty responseProperties = new HttpResponseMessageProperty();

            Uri endpointUri = OperationContext.Current.EndpointDispatcher.EndpointAddress.Uri;
            string id = CustomerIdFromRequestUri( message.Properties.Via, endpointUri );

            Console.WriteLine("Received " + requestProperties.Method + " for Customer.");
            Customer customer = message.GetBody<Customer>();
            Console.WriteLine("\tCustomer Data - Name: " + customer.Name + " Address: " + customer.Address);
            
            if (customer != null)
            {
                if (!customerList.ContainsKey(id))
                {
                    responseProperties.StatusCode = HttpStatusCode.NotFound;
                }
                else
                {
                    customerList[id] = customer;
                    responseProperties.StatusCode = HttpStatusCode.OK;
                }
            }
            else
            {
                responseProperties.StatusCode = HttpStatusCode.BadRequest;
            }

            responseProperties.SuppressEntityBody = true;
            response = Message.CreateMessage(message.Version, message.Headers.Action, String.Empty);
            response.Properties[HttpResponseMessageProperty.Name] = responseProperties;

            return response;
        }

        private static HttpContent CreateMessageContent(Message message, bool suppressEntityBody)
        {
            Fx.Assert(message != null, "The 'message' parameter should not be null.");

            if (suppressEntityBody || message.IsEmpty)
            {
                return new ByteArrayContent(EmptyArray<byte>.Instance);
            }

            return new StreamContent(message.GetBody<Stream>());
        }

        private static IdmResource ConvertGetResponseToIdmResource(Message getResponseMsg)
        {
            BaseObjectSearchResponse getResponseObj =
                getResponseMsg.GetBody<BaseObjectSearchResponse>(new SoapXmlSerializer(typeof(BaseObjectSearchResponse)));

            var resource = new IdmResource();

            foreach (XmlNode partialAttribute in getResponseObj.PartialAttribute)
                foreach (XmlNode attribute in partialAttribute.ChildNodes)
                    BuildAttribute(attribute, resource);
            return resource;
        }

 private void AssertIsEqualMessage(Message message1, Message message2)
 {
     Data data1 = message1.GetBody<Data>();
      Data data2 = message2.GetBody<Data>();
      Assert.AreEqual(data1.Value, data2.Value);
 }

 private static PagedSearchResults ConvertPullResponseToPagedSearchResults(PagingContext pagingContext,
     Message pullResponseMessage)
 {
     var pagedSearchResults =
         pullResponseMessage.GetBody<PagedSearchResults>(new SoapXmlSerializer(typeof(PagedSearchResults)));
     if (pagedSearchResults.Items != null)
     {
         var xmlNodes = (XmlNode[])pagedSearchResults.Items;
         var resources = xmlNodes.Select(BuildResource).ToArray();
         pagedSearchResults.Results.AddRange(resources);
         pagingContext.CurrentIndex += xmlNodes.Length;
     }
     return pagedSearchResults;
 }

        /// <summary>
        /// Executes the request message on the target system and returns a response message.
        /// If there isn’t a response, this method should return null
        /// </summary>
        public Message Execute(Message message, TimeSpan timeout)
        {
            var generator = new NameGenerator(message,
                Connection.ConnectionFactory.ConnectionUri.Path, Connection.ConnectionFactory.ConnectionUri.FileName);

            string sourcePath = new Uri(message.Headers.Action).LocalPath;

            string targetFolder = generator.Folder;
            string targetPath = Path.Combine(targetFolder, generator.FileName);

            if (!Directory.Exists(targetFolder))
                Directory.CreateDirectory(targetFolder);

            Stream outputStream = null;

            switch (Connection.ConnectionFactory.Adapter.OverwriteAction)
            {
                case OverwriteAction.None:
                    outputStream = System.IO.File.Open(targetPath, FileMode.CreateNew);
                    break;
                case OverwriteAction.Replace:
                    outputStream = System.IO.File.Create(targetPath);
                    break;
                case OverwriteAction.Append:
                    outputStream = System.IO.File.OpenWrite(targetPath);
                    break;
            }

            using (outputStream)
            {
                var inputStream = message.GetBody<Stream>();
                inputStream.CopyTo(outputStream);

                return Message.CreateMessage(MessageVersion.Default, string.Empty);
            }
        }