public JsonResult SendMessage(string topicName, string message, bool messageIsUrgent, bool messageIsImportant)
        {
            TopicClient topicClient = this.messagingFactory.CreateTopicClient(topicName);
            var customMessage = new CustomMessage() { Body = message, Date = DateTime.Now };
            bool success = false;
            BrokeredMessage bm = null;

            try
            {
                bm = new BrokeredMessage(customMessage);
                bm.Properties["Urgent"] = messageIsUrgent ? "1" : "0";
                bm.Properties["Important"] = messageIsImportant ? "1" : "0";
                bm.Properties["Priority"] = "Low";
                topicClient.Send(bm);
                success = true;
            }
            catch (Exception)
            {
                // TODO: do something
            }
            finally
            {
                if (bm != null)
                {
                    bm.Dispose();
                }
            }

            return this.Json(success, JsonRequestBehavior.AllowGet);
        }

        public static void AddToAzureQueue(this object o, string queueName, string nameSpace, string issuerName, string issuerKey)
        {
            if (_queueClient == null || queueName.ToLower() != _queueName || nameSpace.ToLower() != _nameSpace || issuerName.ToLower() != _issuerName || issuerKey.ToLower() != _issuerKey)
            {
                _queueName = queueName.ToLower();
                _nameSpace = nameSpace.ToLower();
                _issuerName = issuerName.ToLower();
                _issuerKey = issuerKey.ToLower();

                ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Http;
                System.Net.ServicePointManager.DefaultConnectionLimit = int.MaxValue;
                System.Net.ServicePointManager.Expect100Continue = false;
                System.Net.ServicePointManager.UseNagleAlgorithm = false;

                var credentials = GetToken(issuerName, issuerKey);

                // Get a client to the queue
                var messagingFactory = MessagingFactory.Create(GetAddress(nameSpace), credentials);
                _queueClient = messagingFactory.CreateQueueClient(queueName);
            }

            BrokeredMessage message = new BrokeredMessage(o);

            _queueClient.Send(message);
        }

        /// <summary>
        /// Save Message to Queue
        /// </summary>
        /// <param name="message">Message</param>
        /// <returns>Task</returns>
        public async Task Send(BrokeredMessage message)
        {
            if (null == message)
            {
                throw new ArgumentNullException("message");
            }

            while (true)
            {
                try
                {
                    await this.client.Send(message);

                    break;
                }
                catch (MessagingException ex)
                {
                    if (ex.IsTransient)
                    {
                        this.HandleTransientError(ex);
                    }
                    else
                    {
                        Trace.TraceError("Error: '{0}'", ex.ToString());

                        throw;
                    }
                }
            }
        }

        private void OnBrokerMessage(BrokeredMessage brokeredMessage)
        {
            try
            {
                //Ignore messages from self
                if (brokeredMessage.Properties[SidAttributeName].ToString() == _sid)
                {
                    brokeredMessage.Complete();
                    return;
                }

                var json = brokeredMessage.Properties[DataAttributeName].ToString();
                var message = _jsonSerializer.DeserializeFromString<Message>(json);

                var pipeline = Composable.GetExport<IXSocketPipeline>();
                var controller = Composable.GetExports<IXSocketController>().First(p => p.Alias == message.Controller);
                controller.ProtocolInstance = new XSocketInternalProtocol();
                pipeline.OnIncomingMessage(controller, message);
                brokeredMessage.Complete();
            }
            catch (Exception ex)
            {
                Composable.GetExport<IXLogger>().Error(ex.ToString());

                // Indicates a problem
                if (brokeredMessage.DeliveryCount > 3)
                {
                    brokeredMessage.DeadLetter();
                }
                else
                {
                    brokeredMessage.Abandon();
                }
            }
        }

        /// <summary>
        /// Convert the brokered message to an envelope.
        /// </summary>
        /// <param name="brokeredMessage"></param>
        /// <returns></returns>
        public async Task<IEnvelope<IMessage>> BuildMessage(BrokeredMessage brokeredMessage)
        {
            using (var stream = brokeredMessage.GetBody<Stream>())
            using (var ms = new MemoryStream())
            {
                var messageType = brokeredMessage.ContentType;

                // Log.
                MessagingEventSource.Log.DeserializingMessage(messageType, brokeredMessage.MessageId, brokeredMessage.CorrelationId, brokeredMessage.SessionId);

                // Helps us get access to the byte array.
                await stream.CopyToAsync(ms);

                // Build the envelope.
                var envelope = Envelope.Create<IMessage>(null)
                    .CorrelationId(brokeredMessage.CorrelationId)
                    .SessionId(brokeredMessage.SessionId)
                    .TimeToLive(brokeredMessage.TimeToLive)
                    .Properties(brokeredMessage.Properties);

                // Handle interceptors, then deserialize.
                var serializedMessage = await Configuration.MessageFilterInvoker.BeforeDeserialization(envelope, ms.ToArray());
                var message = await Configuration.Serializer.Deserialize<IMessage>(serializedMessage);

                // Log.
                MessagingEventSource.Log.DeserializationComplete(messageType, brokeredMessage.MessageId, brokeredMessage.CorrelationId, brokeredMessage.SessionId);

                // Done.
                return envelope.Body(message);
            }
        }

        private BrokeredMessage BuildMessage(Envelope<ICommand> command)
        {
            var stream = new MemoryStream();
            var writer = new StreamWriter(stream);
            this.serializer.Serialize(writer, command.Body);
            stream.Position = 0;

            var message = new BrokeredMessage(stream, true);
            if (!default(Guid).Equals(command.Body.Id))
            {
                message.MessageId = command.Body.Id.ToString();
            }

            var metadata = this.metadataProvider.GetMetadata(command.Body);
            if (metadata != null)
            {
                foreach (var pair in metadata)
                {
                    message.Properties[pair.Key] = pair.Value;
                }
            }

            if (command.Delay != TimeSpan.Zero)
                message.ScheduledEnqueueTimeUtc = DateTime.UtcNow.Add(command.Delay);

            return message;
        }

        protected override void PumpMessage(BrokeredMessage message)
        {
            var correlationId = Guid.Parse(message.CorrelationId);
            var responseCorrelationWrapper = _requestResponseCorrelator.TryGetWrapper(correlationId);
            if (responseCorrelationWrapper == null)
            {
                Logger.Debug("Could not find correlation wrapper for reply {0} ({1}", correlationId, message.Properties[MessagePropertyKeys.MessageType]);
                return;
            }

            var success = (bool) message.Properties[MessagePropertyKeys.RequestSuccessfulKey];
            if (success)
            {
                Logger.Debug("Request {0} was successful. Dispatching reply to correlation wrapper.", correlationId);

                var responseType = responseCorrelationWrapper.ResponseType;
                var response = message.GetBody(responseType);
                responseCorrelationWrapper.Reply(response);

                Logger.Debug("Response {0} dispatched.", correlationId);
            }
            else
            {
                var exceptionMessage = (string) message.Properties[MessagePropertyKeys.ExceptionMessageKey];
                var exceptionStackTrace = (string) message.Properties[MessagePropertyKeys.ExceptionStackTraceKey];

                Logger.Debug("Request {0} failed. Dispatching exception to correlation wrapper: {1} {2}", correlationId, exceptionMessage, exceptionStackTrace);

                responseCorrelationWrapper.Throw(exceptionMessage, exceptionStackTrace);
            }
        }

 private static void SendMessage(string name, string message)
 {
     Greeting g = new Greeting() { Name = name, Message = message };
     while(true){
         try
         {
             BrokeredMessage bmsg = new BrokeredMessage(g);
             queueClient.Send(bmsg);
             Console.Out.WriteLine("Sent message with id {0}", bmsg.MessageId);
             break;
         }
         catch (MessagingException mex)
         {
             if (!mex.IsTransient)
             {
                 throw;
             }
             else
             {
                 Console.Out.WriteLine("We experienced a temporary setback due to {0}", mex.Message);
                 Console.Out.WriteLine("Retrying in 2 seconds.");
                 Thread.Sleep(2000);
             }
         }
     }
 }

        public async Task Enqueue(object message)
        {
            var brokeredMessage = new BrokeredMessage(message);

            var topicClient = QueueClient.CreateFromConnectionString(_serviceBusNamespaceConnectionString, QueueName);
            await topicClient.SendAsync(brokeredMessage);
        }

 public void SendSBM(string msg, string channel)
 {
     message = new BrokeredMessage(msg);
     message.Properties["channel"] = channel;
     message.TimeToLive = timetolive;
     client.Send(message);
 }

 protected override async Task When()
 {
     _request = new BrokeredMessage();
     _sessionId = Guid.NewGuid().ToString();
     _request.ReplyToSessionId = _sessionId;
     _response = await Subject.CreateSuccessfulResponse(new TestResponse(), _request);
 }

        /// <summary>
        /// Create a new session handler.
        /// </summary>
        /// <param name="session"></param>
        /// <param name="message"></param>
        /// <returns></returns>
        public IMessageSessionAsyncHandler CreateInstance(MessageSession session, BrokeredMessage message)
        {
            ServiceBusEventSource.Log.SessonAccepted(_receiverNamespace, _receiverPath, session.SessionId, message.MessageId, message.CorrelationId);

            // Use the current handler.
            return new SessionMessageAsyncHandler(_receiverNamespace, _receiverPath, session, _messageHandler, _options);
        }

        static void Main(string[] args)
        {

            try
            {
                //ServiceBusEnvironment.SystemConnectivity.Mode = ConnectivityMode.Http;

                string topicName = "sb-salesorder-topic";
                string sbconnection = "Endpoint=sb://sb-twocents-ns.servicebus.windows.net/;SharedAccessKeyName=Sender;SharedAccessKey=TzYnAEaXHAP3dVJ0J/knLc+2+99C/E2ytbo8qDJQ+TI=";
                MessagingFactory factory = MessagingFactory.CreateFromConnectionString(sbconnection);
                TopicClient client = factory.CreateTopicClient(topicName);

                string postBody = "{'ServiceNumber': 'TST100', 'AddressCode': 'HAG', 'ServiceContractNumber': 'SOC920001', Description': 'Testmelding'}";

                BrokeredMessage msg = new BrokeredMessage(postBody);
                msg.Properties["Priority"] = 1;

                client.Send(msg);

                msg = null;

                Console.WriteLine("Press Enter");
                Console.Read();

            }
            catch (Exception ex)
            {
                Console.WriteLine(String.Format("Error: {0}", ex.ToString()));
                Console.Read();
            }

        }

        static void Main(string[] args)
        {
            string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");

            NamespaceManager ConnectorNamespaceMgr = NamespaceManager.CreateFromConnectionString(connectionString);
            if (!ConnectorNamespaceMgr.QueueExists("TestQueue"))
            {
                ConnectorNamespaceMgr.CreateQueue("TestQueue");
            }

            QueueClient Client = QueueClient.CreateFromConnectionString(connectionString, "TestQueue", ReceiveMode.PeekLock);

            for (int i = 0; i < 5; i++)
            {
                // Create message, passing a string message for the body.
                BrokeredMessage message = new BrokeredMessage("Test message " + i);

                // Set some addtional custom app-specific properties.
                message.Properties["TestProperty"] = "TestValue";
                message.Properties["Message number"] = i;

                // Send message to the queue.
                Client.Send(message);
            }
            ReceiveQueueMessages(Client);
        }

 public static SBMessage FromBrokeredMessage(BrokeredMessage message)
 {
     SBMessage ret = new SBMessage(message.GetBody());
     foreach (var key in message.Properties.Keys)
         ret.Headers.Add(key, message.Properties[key]);
     return ret;
 }

        public static string SendMessage(MessageFormat msg,string SharedKey)
        {
            try
            {
                string connectionString = string.Format("Endpoint=sb://myflow-ns.servicebus.windows.net/;SharedAccessKeyName={0};SharedAccessKey={1}", msg.PolicyName, SharedKey);
                string JsonMessage = JsonConvert.SerializeObject(msg);
                var jsonObjStream = new MemoryStream(Encoding.UTF8.GetBytes(JsonMessage));
                MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString);
                MessageSender MessageSender = factory.CreateMessageSender("flowspec");
                BrokeredMessage Message = new BrokeredMessage(jsonObjStream);
                MessageSender.Send(Message);
                if (msg.Action == "Add")
                {
                    return "The Filter is added";
                }
                else
                {
                    return "The Filter is removed";
                }

            }
            catch (MessagingCommunicationException)
            {

                return "Client is not able to establish a connection to Service Bus.";
            }

            catch (UnauthorizedAccessException)
            {
                return "PolicyName or SharedAccessKey is incorrect";
            }
        }

        public void HandleMessage(BrokeredMessage message)
        {
            if (message.GetMessageType() == "Create")
            {
                var virtualMachine = message.GetObject<VirtualMachine>();
                var imageName = CloudConfigurationManager.GetSetting("VirtualMachineBaseImageName");
                var dataDiskBase = CloudConfigurationManager.GetSetting("DataDiskName");
                var dataDiskName = String.Format("{0}-{1}", dataDiskBase, virtualMachine.Name);
                var sourceVhdName = String.Format("{0}.vhd", dataDiskBase);
                var storageContainerUrl = CloudConfigurationManager.GetSetting("StorageContainerUrl");
                var vhdContainerName = CloudConfigurationManager.GetSetting("VhdContainerName"); //TODO: does this work with multiple storage accounts?
                var serviceName = CloudConfigurationManager.GetSetting("ServiceName");

                //var subscriptionId = CloudConfigurationManager.GetSetting("Azure.SubscriptionId");
                //var managementCertificateString = CloudConfigurationManager.GetSetting("Azure.ManagementCertificate");
                //var managementCertificate = new X509Certificate2(Convert.FromBase64String(managementCertificateString));
                //var credentials = new CertificateCloudCredentials(subscriptionId, managementCertificate);

                //TODO: find a subscription?

                //TODO: get storage account?

                if (AzureVmExists(_executor, virtualMachine) == false)
                {
                    CreateNewVirtualMachine(_executor, virtualMachine, imageName, serviceName, sourceVhdName, storageContainerUrl, vhdContainerName, dataDiskName);
                }
            }
            else
            {
                throw new ArgumentException("Invalid Message Type.", "message");
            }
        }

        public TransportMessage ToTransportMessage(BrokeredMessage message)
        {
            TransportMessage t;
            var rawMessage = message.GetBody<byte[]>();

            if (message.Properties.Count == 0)
            {
                t = DeserializeMessage(rawMessage);
            }
            else
            {
                t = new TransportMessage(message.MessageId, message.Properties.ToDictionary(kvp=>kvp.Key,kvp=>kvp.Value.ToString()))
                        {
                            CorrelationId = message.CorrelationId,
                            TimeToBeReceived = message.TimeToLive
                        };

                t.MessageIntent =
                    (MessageIntentEnum)
                    Enum.Parse(typeof(MessageIntentEnum), message.Properties[Headers.MessageIntent].ToString());

                if ( !String.IsNullOrWhiteSpace( message.ReplyTo ) )
                {
                    t.ReplyToAddress = Address.Parse( message.ReplyTo ); // Will this work?
                }

                t.Body = rawMessage;
            }

            return t;
        }

        private async Task ProcessMessage(BrokeredMessage message)
        {
            try
            {
                if (!this.IsValidMessage(message))
                {
                    // Send the message to the Dead Letter queue for further analysis.
                    await message.DeadLetterAsync("Invalid message", "The message Id is invalid");
                    Trace.WriteLine("Invalid Message. Sending to Dead Letter queue");
                }

                // Simulate message processing.
                await Task.Delay(TimeSpan.FromSeconds(2)).ConfigureAwait(false);

                Trace.WriteLine("Consumer " + RoleEnvironment.CurrentRoleInstance.Id + " : Message processed successfully: " + message.MessageId);

                // Complete the message.
                await message.CompleteAsync();
            }
            catch (Exception ex)
            {
                // Abandon the message when appropriate.  If the message reaches the MaxDeliveryCount limit, it will be automatically deadlettered.
                message.Abandon();
                Trace.TraceError("An error has occurred while processing the message: " + ex.Message);
            }
        }

        private void SendToQueue_Click(object sender, RoutedEventArgs e)
        {
            Trace.WriteLine("SendMessage()");

            var namespaceManager = NamespaceManager.Create();

            if (namespaceManager.QueueExists(QueueName))
            {
                try
                {
                    BrokeredMessage message = new BrokeredMessage(messageBody);
                    message.MessageId = messageId;

                    queueClient.Send(message);
                }
                catch (MessagingException ex)
                {
                    if (!ex.IsTransient)
                    {
                        Trace.WriteLine(ex.Message);
                        throw;
                    }
                    else
                    {
                        HandleTransientErrors(e);
                    }
                }
            }
            else
            {
                Trace.WriteLine("Queue does not exist: " + QueueName);
            }
        }