internal MethodInfoOperationSelector(ContractDescription description, MessageDirection directionThatRequiresClientOpSelection)
            {
                operationMap = new Dictionary<object, string>();

                for (int i = 0; i < description.Operations.Count; i++)
                {
                    OperationDescription operation = description.Operations[i];
                    if (operation.Messages[0].Direction == directionThatRequiresClientOpSelection)
                    {
                        if (operation.SyncMethod != null)
                        {
                            if (!operationMap.ContainsKey(operation.SyncMethod.MethodHandle))
                                operationMap.Add(operation.SyncMethod.MethodHandle, operation.Name);
                        }
    
                        if (operation.BeginMethod != null)
                        {
                            if (!operationMap.ContainsKey(operation.BeginMethod.MethodHandle))
                            {
                                operationMap.Add(operation.BeginMethod.MethodHandle, operation.Name);
                                operationMap.Add(operation.EndMethod.MethodHandle, operation.Name);                    
                            }
                        }

                        if (operation.TaskMethod != null)
                        {
                            if (!operationMap.ContainsKey(operation.TaskMethod.MethodHandle))
                            {
                                operationMap.Add(operation.TaskMethod.MethodHandle, operation.Name);
                            }
                        }
                    }
                }
            }

 public WSSecurityOneDotZeroSendSecurityHeader(Message message, string actor, bool mustUnderstand, bool relay,
     SecurityStandardsManager standardsManager,
     SecurityAlgorithmSuite algorithmSuite,
     MessageDirection direction)
     : base(message, actor, mustUnderstand, relay, standardsManager, algorithmSuite, direction)
 {
 }

 public DebugInfo(MessageDirection Direction, string FromID, string FromIP, Message Content)
 {
     this.FromID = FromID;
     this.FromIP = FromIP;
     this.Content = Content;
     this.Direction = Direction;
 }

 internal override void InferMessageDescription(OperationDescription operation, object owner, MessageDirection direction)
 {
     ContractInferenceHelper.CheckForDisposableParameters(operation, this.InternalDeclaredMessageType);
     string overridingAction = null;
     SerializerOption dataContractSerializer = SerializerOption.DataContractSerializer;
     Receive receive = owner as Receive;
     if (receive != null)
     {
         overridingAction = receive.Action;
         dataContractSerializer = receive.SerializerOption;
     }
     else
     {
         ReceiveReply reply = owner as ReceiveReply;
         overridingAction = reply.Action;
         dataContractSerializer = reply.Request.SerializerOption;
     }
     if (direction == MessageDirection.Input)
     {
         ContractInferenceHelper.AddInputMessage(operation, overridingAction, this.InternalDeclaredMessageType, dataContractSerializer);
     }
     else
     {
         ContractInferenceHelper.AddOutputMessage(operation, overridingAction, this.InternalDeclaredMessageType, dataContractSerializer);
     }
 }

 public WSSecurityOneDotOneReceiveSecurityHeader(Message message, string actor, bool mustUnderstand, bool relay,
     SecurityStandardsManager standardsManager,
     SecurityAlgorithmSuite algorithmSuite,
     int headerIndex, MessageDirection direction)
     : base(message, actor, mustUnderstand, relay, standardsManager, algorithmSuite, headerIndex, direction)
 {
 }

 public QueuedMessage(MessageDirection direction, int chunk_stream_id, RTMPMessage msg)
 {
   this.Direction     = direction;
   this.ChunkStreamId = chunk_stream_id;
   this.Message       = msg;
   this.TimeStamp     = Stopwatch.Elapsed;
 }

 public GmailEmail(DateTimeOffset timestamp, MessageDirection direction, string subject, string content)
 {
     _timestamp = timestamp;
     _direction = direction;
     _subject = subject;
     _content = content;
 }

		public UserCommandMessage(StringDictionary StringResources, MessageDirection Direction, byte[] Buffer, int StartIndex = 0) 
            : base () 
        {
            this.TransferDirection = Direction;
            this.StringResources = StringResources;
            ReadFrom(Buffer, StartIndex);
        }

 public MessageBufferEventArgs(byte[] MessageBuffer, int Length, IntPtr MemoryAddress, MessageDirection Direction = MessageDirection.ServerToClient)
 {
     this.MessageBuffer = MessageBuffer;
     this.Length = Length;
     this.MemoryAddress = MemoryAddress;
     this.Direction = Direction;
 }

        public Message()
        {
            this._headNumber = 1;
            this._messageNumber = 1;
            this._messageTitle = DateTime.Now.Ticks.ToString().Substring(0, 8);

            this._generalParametersPresent = true;
            this._messageTestPresent = true;
            this._numberOfCounters = 0;
            this._numberOfPostdates = 0;
            this._presentTimeCodes = false;
            this._numberOfBarcodes = 0;

            this._messageDirection = MessageDirection.Normal;
            this._horizontalDirection = HorizontalDirection.Normal;
            this._verticalDirection = VerticalDirection.Normal;
            this._tachoMode = TachoMode.No;
            this._manualTrigger = ManualTrigger.Yes;
            this._triggerMode = TriggerMode.Object;
            this._unitForMargins = UnitForMargins.Millimeters;
            this._dinMode = DINMode.No;

            this._mulitTopValue = 0;
            this._objectTopFilter = 1;
            this._tachoDivision = 1;
            this._forwardMargin = 3;
            this._returnMargin = 3;
            this._interval = 3;
            this._printingSpeed = 100;
            this._algorithmNumber = 0;

            this.Lines = new List<Line>();
        }

        public SecurityHeader(Message message,
            string actor, bool mustUnderstand, bool relay,
            SecurityStandardsManager standardsManager, SecurityAlgorithmSuite algorithmSuite,
            MessageDirection transferDirection)
        {
            if (message == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
            }
            if (actor == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("actor");
            }
            if (standardsManager == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("standardsManager");
            }
            if (algorithmSuite == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("algorithmSuite");
            }

            _message = message;
            _actor = actor;
            _mustUnderstand = mustUnderstand;
            _relay = relay;
            _standardsManager = standardsManager;
            _algorithmSuite = algorithmSuite;
            _transferDirection = transferDirection;
        }

 public GmailEmail(DateTimeOffset timestamp, MessageDirection direction, string subject, string deeplink)
 {
     _timestamp = timestamp;
     _direction = direction;
     _subject = subject;
     _deepLink = deeplink;
 }

 internal static MessageDirection Opposite(MessageDirection d)
 {
     if (d != MessageDirection.Input)
     {
         return MessageDirection.Input;
     }
     return MessageDirection.Output;
 }

 protected SendSecurityHeader(Message message, string actor, bool mustUnderstand, bool relay,
     SecurityStandardsManager standardsManager,
     SecurityAlgorithmSuite algorithmSuite,
     MessageDirection transferDirection)
     : base(message, actor, mustUnderstand, relay, standardsManager, algorithmSuite, transferDirection)
 {
     throw ExceptionHelper.PlatformNotSupported();
 }

 protected SendSecurityHeader(Message message, string actor, bool mustUnderstand, bool relay,
     SecurityStandardsManager standardsManager,
     SecurityAlgorithmSuite algorithmSuite, 
     MessageDirection transferDirection)
     : base(message, actor, mustUnderstand, relay, standardsManager, algorithmSuite, transferDirection)
 {
     this.elementContainer = new SendSecurityHeaderElementContainer();
 }

 internal static bool IsDefined(MessageDirection value)
 {
     if (value != MessageDirection.Input)
     {
         return (value == MessageDirection.Output);
     }
     return true;
 }

 protected ReceiveSecurityHeader(Message message, string actor, bool mustUnderstand, bool relay,
     SecurityStandardsManager standardsManager,
     SecurityAlgorithmSuite algorithmSuite,
     int headerIndex,
     MessageDirection direction)
     : base(message, actor, mustUnderstand, relay, standardsManager, algorithmSuite, direction)
 {
     throw ExceptionHelper.PlatformNotSupported();
 }

        internal MessageDescription(string action, MessageDirection direction, MessageDescriptionItems items)
        {
            if (!MessageDirectionHelper.IsDefined(direction))
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("direction"));

            this.action = action;
            this.direction = direction;
            this.items = items;
        }

 /// <summary>
 /// Publish the message to the scaleout so that other servers can receive it
 /// </summary>
 /// <param name="message"></param>
 public override async Task Publish(MessageDirection direction, IMessage message, ScaleOutOrigin scaleOutOrigin)
 {
     if (!InitSuccess) return;
     try
     {
         await ScaleToMongoDb(message);
     }
     catch (Exception ex)
     {
         Composable.GetExport<IXLogger>().Error(ex, "Failed to publish in MongoDB ScaleOut");
     }
 }        

 internal static void OverrideFlow(BindingParameterCollection parameters, string action, MessageDirection direction, TransactionFlowOption option)
 {
     Dictionary<DirectionalAction, TransactionFlowOption> dictionary = EnsureDictionary(parameters);
     DirectionalAction key = new DirectionalAction(direction, action);
     if (dictionary.ContainsKey(key))
     {
         dictionary[key] = option;
     }
     else
     {
         dictionary.Add(key, option);
     }
 }