public XmlSerializerOperationFormatter(OperationDescription description, XmlSerializerFormatAttribute xmlSerializerFormatAttribute,
     MessageInfo requestMessageInfo, MessageInfo replyMessageInfo) :
     base(description, xmlSerializerFormatAttribute.Style == OperationFormatStyle.Rpc, false/*isEncoded*/)
 {
     _requestMessageInfo = requestMessageInfo;
     _replyMessageInfo = replyMessageInfo;
 }

        public string PermanentlyDeleteMessage(Stream message)
        {
            try
            {

                MessageBox objInput = JSonHelper.JsonDeserialize<MessageBox>(new StreamReader(message).ReadToEnd());
                if (System.Configuration.ConfigurationManager.AppSettings[objInput.Pin] == null)
                {
                    return "Invalid PIN";
                }
                if (objInput.Pin != null && objInput.Pin.Length > 0)
                {
                    MessageBox obj2 = new MessageBox();
                    List<MessageInfo> objcol = new List<MessageInfo>();
                    MessageInfo obj = new MessageInfo();
                    MessageBLL objbll = new MessageBLL();

                    obj.MessageComposeId = objInput.MessageComposeId;
                    obj.Pin = System.Configuration.ConfigurationManager.AppSettings[objInput.Pin].ToString();
                    int i = objbll.DeleteMessages_DeletedItems(obj);
                    if (i > 0)
                        return "Delete sucessful";
                    else
                        return "Delete Unsucessful";
                }
                else
                {
                    return "Pin is a required field";
                }
            }
            catch (Exception ex)
            {
                return "Unable to delete. Please try again later";
            }
        }

 public DataContractSerializerOperationFormatter(OperationDescription description, DataContractFormatAttribute dataContractFormatAttribute, DataContractSerializerOperationBehavior serializerFactory) : base(description, dataContractFormatAttribute.Style == OperationFormatStyle.Rpc, false)
 {
     if (description == null)
     {
         throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
     }
     this.serializerFactory = serializerFactory ?? new DataContractSerializerOperationBehavior(description);
     foreach (System.Type type in description.KnownTypes)
     {
         if (this.knownTypes == null)
         {
             this.knownTypes = new List<System.Type>();
         }
         if (type == null)
         {
             throw System.ServiceModel.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxKnownTypeNull", new object[] { description.Name })));
         }
         this.ValidateDataContractType(type);
         this.knownTypes.Add(type);
     }
     this.requestMessageInfo = this.CreateMessageInfo(dataContractFormatAttribute, base.RequestDescription, this.serializerFactory);
     if (base.ReplyDescription != null)
     {
         this.replyMessageInfo = this.CreateMessageInfo(dataContractFormatAttribute, base.ReplyDescription, this.serializerFactory);
     }
 }

 public void Callback(MessageInfo message)
 {
     //Note: This is for demo purposes only.
     //Note: It is not a good practice to call MessageBox.Show from a non-View class.
     //Note: Consider implementing a MessageBoxService.
     MessageBox.Show(message.Message, message.Title, MessageBoxButton.OK);
 }

 IEnumerator CreateTextDisplay(MessageInfo info)
 {
     textField.text = info.message;
     textField.color = info.color;
     yield return new WaitForSeconds(textTime);
     textField.text = "";
     yield break;
 }

 public Trigger(MessageInfo msg, TriggerType type)
 {
     this.OnlyOneUse = false;
     this.RunOnReceivedMsg = false;
     this.Conditions = new List<Condition>();
     this.Message = msg;
     this.Type = type;
 }

 public XmlSerializerOperationFormatter(OperationDescription description, XmlSerializerFormatAttribute xmlSerializerFormatAttribute, MessageInfo requestMessageInfo, MessageInfo replyMessageInfo) : base(description, xmlSerializerFormatAttribute.Style == OperationFormatStyle.Rpc, xmlSerializerFormatAttribute.IsEncoded)
 {
     if (xmlSerializerFormatAttribute.IsEncoded && (xmlSerializerFormatAttribute.Style != OperationFormatStyle.Rpc))
     {
         throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(System.ServiceModel.SR.GetString("SFxDocEncodedNotSupported", new object[] { description.Name })));
     }
     this.isEncoded = xmlSerializerFormatAttribute.IsEncoded;
     this.requestMessageInfo = requestMessageInfo;
     this.replyMessageInfo = replyMessageInfo;
 }

 /// <summary>
 /// メッセージを連続送信。
 /// </summary>
 /// <param name="windowHandle">ウィンドウハンドル。</param>
 /// <param name="info">メッセージ情報。</param>
 public static void SendMessage(IntPtr windowHandle, MessageInfo[] info)
 {
     if (info == null)
     {
         throw new ArgumentNullException("info");
     }
     for (int i = 0; i < info.Length; i++)
     {
         NativeMethods.SendMessage(windowHandle, info[i].Message, info[i].WParam, info[i].LParam);
     }
 }

 public IEnumerable<ISubscription> Shape(IEnumerable<ISubscription> subscriptions, object message)
 {
     var info = new MessageInfo(message);
     var resultingSubscriptions = subscriptions;
     for (int i = _shapeProviders.Count - 1; i >= 0; i--) //Backwards as we keep the default at index 0
     {
         if (!_shapeProviders[i].Handles(info))
             continue;
         resultingSubscriptions = _shapeProviders[i].Enhance(subscriptions);
         break;
     }
     return resultingSubscriptions;
 }

        protected override void Arrange()
        {
            Cleanup();

            _queueService = new QueueService();
            _queuePath = QueueTestHelper.CreateQueuePathForPrivateQueue(ComputerName, TestQueueName, _isTransactional);
            _queueService.CreateQueue(_queuePath, _isTransactional);

            _queueService.CreateMessage(_queuePath, new TestClass1 { StringValue1 = "Should not be deleted" }, TestMessagesLabelForMessageWhichShouldNotBeDeleted);

            _messageData = new TestClass1 { IntValue1 = 1, StringValue1 = "string1" };
            _queueService.CreateMessage(_queuePath, _messageData, TestMessagesLabel);
            
            _messageToDelete = _queueService.GetMessageInfos(_queuePath, TestMessagesLabel).Single();
        }

 internal static IEnumerable<Task> GetTasks()
 {
     IList<Task> tasks = new List<Task>();
     tasks.Add(new StartProcess("http://www.google.it"));
     Task task = new MessageInfo("Periodioco 30s", Task.TaskType.Periodic);
     task.Delay=new TimeSpan(0,0,0,30);
     tasks.Add(task);
     task = new MessageInfo("Delayed 10 s ", Task.TaskType.Delayed);
     task.Delay=new TimeSpan(0,0,0,10);
     tasks.Add(task);
     task = new MessageInfo("Periodic 60s",Task.TaskType.Periodic);
     task.Delay=new TimeSpan(0,0,1,0);
     tasks.Add(task);
     return tasks;
 }

        public virtual bool RunTrigger(MessageInfo msg, List<MessageInfo> Received, bool triggerFired)
        {
            if (msg == null)
                return false;

            var result = true;
            var xml = msg.xml;
            NpuToUse = msg.NPU;

            if (triggerFired && OnlyOneUse)
                return false;

            foreach (var cond in Conditions)
            {
                if (!cond.IsConditionTrue(xml))
                    result =  false;
            }

            if (!result && RunOnReceivedMsg)
            {
                foreach (var oldMsg in Received)
                {

                    var oldXml = oldMsg.xml;
                    result = true;
                    foreach (var cond in Conditions)
                    {
                        if (!cond.IsConditionTrue(oldXml))
                        {
                            result = false;
                            break;
                        }
                    }

                    if (result == true)
                    {
                        NpuToUse = oldMsg.NPU;
                        break;
                    }
                }

            }

            return result;
        }

 /// <summary>
 /// Converts the color of the resultant text
 /// </summary>
 /// <param name="message"></param>
 /// <param name="type"></param>
 public void ShowMessage(string message, MessageInfo type)
 {
     Label commonLabel = this.Page.Master.FindControl("CommonLabel") as Label;
     if (commonLabel != null)
     {
         switch (type)
         {
             case MessageInfo.Error:
                 commonLabel.ForeColor = Color.Red;
                 break;
             case MessageInfo.Information:
                 commonLabel.ForeColor = Color.Green;
                 commonLabel.Font.Bold = true;
                 break;
         }
         commonLabel.Text = message;
     }
 }

 private SharpMimeMessage( anmar.SharpMimeTools.SharpMimeMessageStream message, long startpoint, long endpoint )
 {
     this.message = message;
     this.mi = new MessageInfo ( this.message, startpoint );
     this.mi.end = endpoint;
 }

        public ChatResult SendMessageToFriend(MessageInfo msg)
        {
            CustomerInfo myCustomer = Manager.Instance.GetCustomerByConnectionId(Context.ConnectionId);
            CustomerInfo friendCustomer = Manager.Instance.GetCustomerByCustomerId(msg.ReceiverId);
            //send message to friend
            List<string> friendConnectionIds = friendCustomer.ConnectionList;
            Clients.Clients(friendConnectionIds).OnReceiveMessage(msg);
            //send message to myCustomer(#connectionId)
            List<string> myConnectionIds = new List<string>(myCustomer.ConnectionList);
            myConnectionIds.Remove(Context.ConnectionId);
            Clients.Clients(myConnectionIds).OnReceiveMessage(msg);

            ChatResult result = Manager.Instance.AddMessage(msg);
            return result;
        }

                private void CreateHeaderDescriptionTable(MessageDescription message, MessageInfo info, XmlMembersMapping headersMapping)
                {
                    int headerNameIndex = 0;
                    OperationFormatter.MessageHeaderDescriptionTable headerDescriptionTable = new OperationFormatter.MessageHeaderDescriptionTable();
                    info.SetHeaderDescriptionTable(headerDescriptionTable);
                    foreach (MessageHeaderDescription header in message.Headers)
                    {
                        if (header.IsUnknownHeaderCollection)
                            info.SetUnknownHeaderDescription(header);
                        else if (headersMapping != null)
                        {
                            XmlMemberMapping memberMapping = headersMapping[headerNameIndex++];

                            if (GeneratedXmlSerializers.IsInitialized)
                            {
                                // If GeneratedXmlSerializers has been initialized, we would use the 
                                // mappings generated by .Net Native tools. In that case, the mappings
                                // we genrated at Runtime are just fake mapping instance which have
                                // no valid name/namespace. Therefore we cannot do the checks in the
                                // else block. Those checks should have been done during NET Native 
                                // precompilation.
                                headerDescriptionTable.Add(header.Name, header.Namespace, header);
                            }
                            else
                            {
                                string headerName, headerNs;
                                headerName = memberMapping.XsdElementName;
                                headerNs = memberMapping.Namespace;
                                if (headerName != header.Name)
                                {
                                    if (message.MessageType != null)
                                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNameMismatchInMessageContract, message.MessageType, header.MemberInfo.Name, header.Name, headerName)));
                                    else
                                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNameMismatchInOperation, this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, header.Name, headerName)));
                                }
                                if (headerNs != header.Namespace)
                                {
                                    if (message.MessageType != null)
                                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNamespaceMismatchInMessageContract, message.MessageType, header.MemberInfo.Name, header.Namespace, headerNs)));
                                    else
                                        throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.Format(SR.SFxHeaderNamespaceMismatchInOperation, this.Operation.Name, this.Operation.DeclaringContract.Name, this.Operation.DeclaringContract.Namespace, header.Namespace, headerNs)));
                                }

                                headerDescriptionTable.Add(headerName, headerNs, header);
                            }
                        }
                    }
                }

 private MessageInfo CreateMessageInfo(MessageDescription message, string key)
 {
     if (message.IsUntypedMessage)
         return null;
     MessageInfo info = new MessageInfo();
     bool isEncoded = false;
     if (message.IsTypedMessage)
         key = message.MessageType.FullName + ":" + isEncoded + ":" + IsRpc;
     XmlMembersMapping headersMapping = LoadHeadersMapping(message, key + ":Headers");
     info.SetHeaders(_parent._generation.AddSerializer(headersMapping));
     MessagePartDescriptionCollection rpcEncodedTypedMessgeBodyParts;
     info.SetBody(_parent._generation.AddSerializer(LoadBodyMapping(message, key, out rpcEncodedTypedMessgeBodyParts)), rpcEncodedTypedMessgeBodyParts);
     CreateHeaderDescriptionTable(message, info, headersMapping);
     return info;
 }

 protected virtual void RunRequest(MessageInfo message, CommandInfo command)
 {
     Client.SendMessage(message.Chat.Id, command.StaticAcceptMessage);
 }

 protected virtual void OnUnknownCommandReceived(MessageInfo message)
 {
     if (UnknownCommandReceived != null)
         UnknownCommandReceived(this, new MessageEventArgs(message));
 }

 protected virtual void GetFirstParameter(MessageInfo message, CommandInfo command)
 {
     var parameter = command.Parameters.First();
     Data.SetCommand(message.From.Id, message.Chat.Id, command.Text);
     Client.SendMessage(message.Chat.Id, parameter.StaticPrompt);
 }