public override bool OnStart()
{
//Setting up service bus
var credentials = TokenProvider.CreateSharedSecretTokenProvider(_issuerName, _issuerKey);
_factory =
MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", _serviceNamespace, string.Empty), credentials);
//Input queue client and error queue client creation
_inputQueueClient = _factory.CreateQueueClient(_inputQueue);
_errorQueueClient = _factory.CreateQueueClient(_errorQueue);
return base.OnStart();
}
public DurableSender(MessagingFactory messagingFactory, string serviceBusQueueName)
{
// Create a Service Bus queue client to send messages to the Service Bus queue.
this.queueClient = messagingFactory.CreateQueueClient(serviceBusQueueName);
// Create MSMQ queue if it doesn't exit. If it does, open the existing MSMQ queue.
this.msmqQueue = MsmqHelper.GetMsmqQueue(MsmqHelper.CreateMsmqQueueName(messagingFactory.Address.DnsSafeHost, serviceBusQueueName, "SEND"));
// Create MSMQ deadletter queue if it doesn't exit. If it does, open the existing MSMQ deadletter queue.
this.msmqDeadletterQueue = MsmqHelper.GetMsmqQueue(MsmqHelper.CreateMsmqQueueName(messagingFactory.Address.DnsSafeHost, serviceBusQueueName, "SEND_DEADLETTER"));
// Start receiving messages from the MSMQ queue.
this.MsmqPeekBegin();
}
protected void btnSend_Click(object sender, EventArgs e)
{
// create a parameter object for the messaging factory that configures
// the MSI token provider for Service Bus and use of the AMQP protocol:
MessagingFactorySettings messagingFactorySettings = new MessagingFactorySettings
{
TokenProvider = TokenProvider.CreateManagedServiceIdentityTokenProvider(ServiceAudience.ServiceBusAudience),
TransportType = TransportType.Amqp
};
// create the messaging factory using the namespace endpoint name supplied by the user
MessagingFactory messagingFactory = MessagingFactory.Create($"sb://{txtNamespace.Text}/",
messagingFactorySettings);
// create a queue client using the queue name supplied by the user
QueueClient queueClient = messagingFactory.CreateQueueClient(txtQueueName.Text);
// send a message using the input text
queueClient.Send(new BrokeredMessage(Encoding.UTF8.GetBytes(txtData.Text)));
queueClient.Close();
messagingFactory.Close();
}
private static void CreateQueue(int messageCount)
{
QueueDescription catsQueue = null;
if (!_namespaceManager.QueueExists("categoryqueue"))
{
catsQueue = _namespaceManager.CreateQueue("categoryqueue");
}
MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, _namespaceManager.Settings.TokenProvider);
QueueClient catsQueueClient = factory.CreateQueueClient("categoryqueue");
Console.WriteLine("Sending messages to the queueu.....");
for (int i = 0; i < messageCount; i++)
{
var cat = _messageList[i];
cat.Label = cat.Properties[(i + 1).ToString()].ToString();
//Console.WriteLine(cat.GetType());
catsQueueClient.Send(cat);
Console.WriteLine($"Message ID: {cat.MessageId}, Message Sent: {cat.Label}");
}
}
public static void SendQ(FireEvent fireEvent)
{
TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(QSender.IssuerName, QSender.IssuerKey);
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", QSender.ServiceNamespace, string.Empty);
MessagingFactory factory = null;
factory = MessagingFactory.Create(serviceUri, credentials);
QueueClient qClient = factory.CreateQueueClient(QSender.QueueName);
BrokeredMessage brokeredMessage = new BrokeredMessage(fireEvent, new DataContractSerializer(typeof(FireEvent)));
brokeredMessage.Properties.Add("ZipCode", fireEvent.ZipCode);
brokeredMessage.Properties.Add("AlertType", fireEvent.AlertType);
brokeredMessage.Properties.Add("EventType", "Weather");
brokeredMessage.Properties.Add("IsAlert", true);
qClient.Send(brokeredMessage);
Console.WriteLine("press enter to exit....");
Console.Read();
}
public ActionResult Create(EmpDetailsInfo emp)
{
const string QueueName = "empQueue";
string connectionString = CloudConfigurationManager.GetSetting("Microsoft.ServiceBus.ConnectionString");
var nameSpaceManager = NamespaceManager.CreateFromConnectionString(connectionString);
if (!nameSpaceManager.QueueExists(QueueName))
{
nameSpaceManager.CreateQueue(QueueName);
}
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(connectionString);
QueueClient myQ = factory.CreateQueueClient(QueueName);
BrokeredMessage bm = new BrokeredMessage(emp);
myQ.Send(bm);
ViewBag.Status = "Message Send";
return(View());
}
public static void Main()
{
// Get credentials and set up management and runtime messaging entities:
GetUserCredentials();
NamespaceManager namespaceClient = CreateNamespaceManager();
MessagingFactory messagingFactory = CreateMessagingFactory();
Console.WriteLine("Creating queue 'OrdersService'...");
if (namespaceClient.QueueExists("OrdersService"))
{
namespaceClient.DeleteQueue("OrdersService");
}
QueueDescription queue = namespaceClient.CreateQueue("OrdersService");
QueueClient queueClient = messagingFactory.CreateQueueClient(queue.Path, ReceiveMode.ReceiveAndDelete);
// Send messages to queue, of different order types:
Console.WriteLine("Sending messages to queue...");
CreateAndSendOrderMessage("DeliveryOrder", 1, 10, 15, queueClient);
CreateAndSendOrderMessage("StayInOrder", 2, 15, 500, queueClient);
CreateAndSendOrderMessage("TakeOutOrder", 3, 1, 25, queueClient);
CreateAndSendOrderMessage("TakeOutOrder", 5, 3, 25, queueClient);
CreateAndSendOrderMessage("DeliveryOrder", 4, 100, 100000, queueClient);
Console.WriteLine();
Console.WriteLine("Press [Enter] to delete queue and exit.");
Console.ReadLine();
// Cleanup:
messagingFactory.Close();
namespaceClient.DeleteQueue(queue.Path);
}
static void CreateQueueToRead()
{
TokenProvider tokenProvider = _namespaceManager.Settings.TokenProvider;
if (_namespaceManager.QueueExists("categoryqueue"))
{
MessagingFactory factory = MessagingFactory.Create(_namespaceManager.Address, tokenProvider);
QueueClient catsQueueclient = factory.CreateQueueClient("categoryqueue");
Console.WriteLine("Receiving the message from the queue...");
BrokeredMessage message;
int ctr = 1;
while ((message = catsQueueclient.Receive(new TimeSpan(hours: 0, minutes: 1, seconds: 5))) != null)
{
Console.WriteLine($"Message received,Sequence:{message.SequenceNumber}, MessageID :{message.MessageId},\nCat:{ message.Properties[(ctr++).ToString()]}");
message.Complete();
Console.WriteLine("processing Message(Sleeping)...");
Thread.Sleep(2000);
}
factory.Close();
catsQueueclient.Close();
_namespaceManager.DeleteQueue("categoryqueue");
Console.WriteLine("Finished getting alll the data from the queue ,Press any key to exit");
}
}
public static QueueClient GetServiceBusQueueClient(MessagingFactory messagingFactory, string queueName, ReceiveMode receiveMode = ReceiveMode.ReceiveAndDelete)
{
QueueClient client = messagingFactory.CreateQueueClient(queueName, receiveMode);
return(client);
}
public async Task SetupAsync(Type[] allMessageTypes, Type[] recievingMessageTypes)
{
_logger.Debug("Starting the setup of AzureServicebusTransport...");
_namespaceManager = NamespaceManager.CreateFromConnectionString(_configuration.GetConnectionString());
_messagingFactory = MessagingFactory.CreateFromConnectionString(_configuration.GetConnectionString());
_messageTypes = allMessageTypes;
var sendCommandTypes = _messageTypes
.Where(t => typeof (IBusCommand)
.IsAssignableFrom(t));
var sendEventTypes = _messageTypes
.Where(t => typeof(IBusEvent)
.IsAssignableFrom(t));
var recieveCommandTypes = recievingMessageTypes
.Where(t => typeof(IBusCommand)
.IsAssignableFrom(t));
var recieveEventTypes = recievingMessageTypes
.Where(t => typeof(IBusEvent)
.IsAssignableFrom(t));
if (_configuration.GetEnableTopicAndQueueCreation())
{
foreach (var type in sendCommandTypes)
{
var path = PathFactory.QueuePathFor(type);
if (!_namespaceManager.QueueExists(path))
await _namespaceManager.CreateQueueAsync(path);
var client = _messagingFactory.CreateQueueClient(path);
client.PrefetchCount = 10; //todo;: in config?
var eventDrivenMessagingOptions = new OnMessageOptions
{
AutoComplete = true, //todo: in config?
MaxConcurrentCalls = 10 //todo: in config?
};
eventDrivenMessagingOptions.ExceptionReceived += OnExceptionReceived;
client.OnMessageAsync(OnMessageRecieved, eventDrivenMessagingOptions);
if (!_queues.TryAdd(type, client))
{
_logger.Error("Could not add the queue with type: {0}", type.FullName);
}
}
foreach (var type in sendEventTypes)
{
var path = PathFactory.TopicPathFor(type);
if (!_namespaceManager.TopicExists(path))
_namespaceManager.CreateTopic(path);
var client = _messagingFactory.CreateTopicClient(path);
if (!_topics.TryAdd(type, client))
{
_logger.Error("Could not add the topic with type: {0}", type.FullName);
}
}
}
_logger.Debug("Setup of AzureServicebusTransport completed!");
throw new NotImplementedException();
}
protected override void OnStart()
{
trackingQueueClient = messagingFactory.CreateQueueClient(trackingEntityName);
}
static void Main(string[] args)
{
GetUserCredentials();
MessagingFactory factory = null;
try
{
//*****************************************************************************************************
// Management Operations
//*****************************************************************************************************
NamespaceManager namespaceClient = NamespaceManager.CreateFromConnectionString(ServiceBusConnectionString);
if (namespaceClient == null)
{
Console.WriteLine("\nUnexpected Error: NamespaceManager is NULL");
return;
}
//Retreive details of the queue
QueueDescription queueDescription = namespaceClient.GetQueue(AsyncReceiver.QueueName);
if (queueDescription == null)
{
Console.WriteLine("\nUnexpected Error: QueueDescription is NULL");
return;
}
//*****************************************************************************************************
// Runtime Operations
//*****************************************************************************************************
factory = MessagingFactory.CreateFromConnectionString(ServiceBusConnectionString);
QueueClient myQueueClient = factory.CreateQueueClient(AsyncReceiver.QueueName, ReceiveMode.PeekLock);
//*****************************************************************************************************
// Receiving messages from a Queue
//*****************************************************************************************************
Console.WriteLine("\nReceiving messages from Queue '{0}'...", AsyncReceiver.QueueName);
// Retreive the number of messages currently in the Queue
long messageCount = queueDescription.MessageCount;
// Initiate the Asynchronous Receive using BeginReceive() call to receive the messages.
for (long count = 0; count < messageCount; count++)
{
myQueueClient.BeginReceive(TimeSpan.FromSeconds(30), OnMessageReceive, myQueueClient);
}
Console.WriteLine("\nAfter all messages are received, press ENTER to exit.");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Unexpected exception {0}", e.ToString());
throw;
}
finally
{
// Closing factory close all entities created from the factory.
if (factory != null)
{
factory.Close();
}
}
}
static QueueClient CreateQueueClient(Uri serviceUri, TokenProvider credentials, out MessagingFactory factory)
{
factory = MessagingFactory.Create(serviceUri, credentials);
return factory.CreateQueueClient(QueueName);
}
private static void Main(string[] args)
{
ServerFQDN = System.Net.Dns.GetHostEntry(string.Empty).HostName;
ServiceBusConnectionStringBuilder connBuilder =
new ServiceBusConnectionStringBuilder
{
ManagementPort = HttpPort,
RuntimePort = TcpPort
};
connBuilder.Endpoints.Add(new UriBuilder {
Scheme = "sb", Host = ServerFQDN, Path = ServiceNamespace
}.Uri);
connBuilder.StsEndpoints.Add(new UriBuilder
{
Scheme = "https",
Host = ServerFQDN,
Port = HttpPort,
Path = ServiceNamespace
}.Uri);
MessagingFactory messageFactory = MessagingFactory.CreateFromConnectionString(connBuilder.ToString());
NamespaceManager namespaceManager = NamespaceManager.CreateFromConnectionString(connBuilder.ToString());
if (namespaceManager == null)
{
Console.WriteLine("\nUnepected Error");
return;
}
string queueName = "ServiceBusQueueSample";
if (namespaceManager.QueueExists(queueName))
{
namespaceManager.DeleteQueue(queueName);
}
namespaceManager.CreateQueue(queueName);
QueueClient myQueueClient = messageFactory.CreateQueueClient(queueName);
try
{
BrokeredMessage sendMessage = new BrokeredMessage("Hello World!");
myQueueClient.Send(sendMessage);
//Receive the message from the queue
BrokeredMessage receivedMessage = myQueueClient.Receive(TimeSpan.FromSeconds(5));
if (receivedMessage != null)
{
Console.WriteLine(string.Format($"Message received:{receivedMessage.GetBody<string>()}"));
receivedMessage.Complete();
}
}
catch (Exception e)
{
Console.WriteLine($"Unexpected exception {e}");
throw;
}
finally
{
if (messageFactory != null)
{
messageFactory.Close();
}
Console.WriteLine("Press ENTER to clean up and exit.");
Console.ReadLine();
}
}
public QueueDeadletterEndpoint(NamespaceManager namespaceManager, MessagingFactory clientFactory, string name) : base(namespaceManager, clientFactory, name)
{
Client = clientFactory.CreateQueueClient(name + "/$DeadletterQueue");
}
static void Main(string[] args)
{
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", "ndservice", String.Empty);
TokenProvider credentials = TokenProvider.CreateSharedAccessSignatureTokenProvider("RootManageSharedAcc essKey", "2geKYuIEGyHKeN4DiuGFDdHBe4Xc7vsVROJ2TVfe4hc="); MessagingFactory factory = MessagingFactory.Create(serviceUri, credentials); QueueClient client = factory.CreateQueueClient("messaging");
BrokeredMessage msg = client.Receive();
Console.WriteLine("TID:" + msg.Properties["Tid"] + "\t Tval:" + msg.Properties["Tval"]);
Console.Read();
msg.Complete();
}
public AzureServiceBusChannel(string queue)
{
_queue = queue;
_factory = MessagingFactory.Create();
_queueClient = _factory.CreateQueueClient(_queue);
}
static void Main(string[] args)
{
GetUserCredentials();
TokenProvider credentials =
TokenProvider.CreateSharedSecretTokenProvider(IssuerName, IssuerKey);
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty);
//*****************************************************************************************************
// Management Operations
//*****************************************************************************************************
NamespaceManager namespaceClient = new NamespaceManager(serviceUri, credentials);
Console.WriteLine("\nCreating Queue 'IssueTrackingQueue'...");
// Delete if exists
if (namespaceClient.QueueExists(queueName))
{
namespaceClient.DeleteQueue(queueName);
}
namespaceClient.CreateQueue(queueName);
//*****************************************************************************************************
// Runtime Operations
//*****************************************************************************************************
MessagingFactory factory = MessagingFactory.Create(serviceUri, credentials);
try
{
QueueClient myQueueClient = factory.CreateQueueClient(queueName);
//*****************************************************************************************************
// Sending messages to a Queue
//*****************************************************************************************************
List <BrokeredMessage> messageList = new List <BrokeredMessage>();
messageList.Add(CreateIssueMessage("1", "Package lost"));
messageList.Add(CreateIssueMessage("2", "Package damaged"));
messageList.Add(CreateIssueMessage("3", "Package defective"));
Console.WriteLine("\nSending messages to queue...");
foreach (BrokeredMessage message in messageList)
{
myQueueClient.Send(message);
Console.WriteLine(
string.Format("Message sent: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>()));
}
Console.WriteLine("\nFinished sending messages, press ENTER to clean up and exit.");
Console.ReadLine();
// Closing factory close all entities created from the factory.
factory.Close();
}
catch (Exception)
{
factory.Abort();
throw;
}
namespaceClient.DeleteQueue(queueName);
}
static void Main(string[] args)
{
Console.WriteLine("Tag Reader Console");
// Create the MessagingFactory
MessagingFactory factory = MessagingFactory.CreateFromConnectionString(AccountDetails.ConnectionString); //MessagingFactory.Create(serviceBusUri, credentials);
// Use the MessagingFactory to create a queue client for the
// specified queue.
QueueClient queueClient = factory.CreateQueueClient(AccountDetails.QueueName);
// Create a sample order
RfidTag[] orderItems = new RfidTag[]
{
new RfidTag() { Product = "Ball", Price = 4.99 },
new RfidTag() { Product = "Whistle", Price = 1.95 },
new RfidTag() { Product = "Bat", Price = 12.99 },
new RfidTag() { Product = "Bat", Price = 12.99 },
new RfidTag() { Product = "Gloves", Price = 7.99 },
new RfidTag() { Product = "Gloves", Price = 7.99 },
new RfidTag() { Product = "Cap", Price = 9.99 },
new RfidTag() { Product = "Cap", Price = 9.99 },
new RfidTag() { Product = "Shirt", Price = 14.99 },
new RfidTag() { Product = "Shirt", Price = 14.99 },
};
// Display the order data.
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Order contains {0} items.", orderItems.Length);
Console.ForegroundColor = ConsoleColor.Yellow;
double orderTotal = 0.0;
foreach (RfidTag tag in orderItems)
{
Console.WriteLine("{0} - ${1}", tag.Product, tag.Price);
orderTotal += tag.Price;
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Order value = ${0}.", orderTotal);
Console.WriteLine();
Console.ResetColor();
Console.WriteLine("Press enter to scan...");
Console.ReadLine();
// Send the order with random duplicate tag reads
int sentCount = 0;
int position = 0;
Random random = new Random(DateTime.Now.Millisecond);
Console.WriteLine("Reading tags...");
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Cyan;
var sessionId = Guid.NewGuid().ToString();
while (position < 10)
{
RfidTag rfidTag = orderItems[position];
// Create a new brokered message from the order item RFID tag.
BrokeredMessage tagRead = new BrokeredMessage(rfidTag);
// Comment in to set message id.
tagRead.MessageId = rfidTag.TagId;
// Comment in to set session id.
tagRead.SessionId = sessionId;
// Send the message
queueClient.Send(tagRead);
//Console.WriteLine("Sent: {0}", orderItems[position].Product);
Console.WriteLine("Sent: {0} - MessageId: {1}", orderItems[position].Product, tagRead.MessageId);
// Randomly cause a duplicate message to be sent.
if (random.NextDouble() > 0.4) position++;
sentCount++;
Thread.Sleep(100);
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("{0} total tag reads.", sentCount);
Console.WriteLine();
Console.ResetColor();
Console.ReadLine();
}
public QueueClient Create(string description, MessagingFactory factory)
{
var client = factory.CreateQueueClient(description, ShouldRetry() ? ReceiveMode.PeekLock : ReceiveMode.ReceiveAndDelete);
client.PrefetchCount = BatchSize;
return client;
}
static void Main(string[] args)
{
GetUserCredentials();
MessagingFactory factory = null;
try
{
//*****************************************************************************************************
// Management Operations
//*****************************************************************************************************
NamespaceManager namespaceClient = NamespaceManager.CreateFromConnectionString(ServiceBusConnectionString);
Console.WriteLine("\nCreating Queue '{0}'...", QueueName);
// Delete if exists
if (namespaceClient.QueueExists(AsyncSender.QueueName))
{
namespaceClient.DeleteQueue(AsyncSender.QueueName);
}
namespaceClient.CreateQueue(QueueName);
//*****************************************************************************************************
// Runtime Operations
//*****************************************************************************************************
factory = MessagingFactory.CreateFromConnectionString(ServiceBusConnectionString);
QueueClient myQueueClient = factory.CreateQueueClient(AsyncSender.QueueName);
//*****************************************************************************************************
// Sending messages to a Queue
//*****************************************************************************************************
List <BrokeredMessage> messageList = new List <BrokeredMessage>();
messageList.Add(CreateIssueMessage("1", "First Package"));
messageList.Add(CreateIssueMessage("2", "Second Package"));
messageList.Add(CreateIssueMessage("3", "Third Package"));
Console.WriteLine("\nSending messages to Queue...");
foreach (BrokeredMessage message in messageList)
{
// Initiate the asynchronous send
myQueueClient.BeginSend(message, OnSendComplete, new Tuple <QueueClient, string>(myQueueClient, message.MessageId));
Console.WriteLine(string.Format("Asynchronous Message Send Begin: Id = {0}, Body = {1}", message.MessageId, message.GetBody <string>()));
}
Console.WriteLine("\nAfter all messages are sent, press ENTER to clean up and exit.\n");
Console.ReadLine();
}
catch (Exception e)
{
Console.WriteLine("Unexpected exception {0}", e.ToString());
throw;
}
finally
{
// Closing factory close all entities created from the factory.
if (factory != null)
{
factory.Close();
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Checkout Console");
// Create the NamespaceManager
NamespaceManager namespaceMgr =
//new NamespaceManager(serviceBusUri, credentials);
NamespaceManager.CreateFromConnectionString(AccountDetails.ConnectionString);
// Create the MessagingFactory
MessagingFactory factory =
//MessagingFactory.Create(serviceBusUri, credentials);
MessagingFactory.CreateFromConnectionString(AccountDetails.ConnectionString);
// Delete the queue if it exists.
if (namespaceMgr.QueueExists(AccountDetails.QueueName))
{
namespaceMgr.DeleteQueue(AccountDetails.QueueName);
}
// Create a description for the queue.
QueueDescription rfidCheckoutQueueDescription =
new QueueDescription(AccountDetails.QueueName)
{
// Comment in to require duplicate detection
RequiresDuplicateDetection = true,
DuplicateDetectionHistoryTimeWindow = TimeSpan.FromMinutes(10),
// Comment in to require sessions
RequiresSession = true
};
// Create a queue based on the queue description.
namespaceMgr.CreateQueue(rfidCheckoutQueueDescription);
// Use the MessagingFactory to create a queue client for the
// specified queue.
QueueClient queueClient = factory.CreateQueueClient(AccountDetails.QueueName);
Console.WriteLine("Receiving tag read messages...");
while (true)
{
int receivedCount = 0;
double billTotal = 0.0;
// Comment in to use a session receiver
Console.ForegroundColor = ConsoleColor.Cyan;
var messageSession = queueClient.AcceptMessageSession();
Console.WriteLine("Accepted session: " + messageSession.SessionId);
Console.ForegroundColor = ConsoleColor.Yellow;
while (true)
{
// Receive a tag read message.
// Swap comments to use a session receiver
//var receivedTagRead = queueClient.Receive(TimeSpan.FromSeconds(5));
var receivedTagRead = messageSession.Receive(TimeSpan.FromSeconds(5));
if (receivedTagRead != null)
{
// Process the message.
RfidTag tag = receivedTagRead.GetBody <RfidTag>();
Console.WriteLine("Bill for {0}", tag.Product);
receivedCount++;
billTotal += tag.Price;
// Mark the message as complete
receivedTagRead.Complete();
}
else
{
break;
}
}
if (receivedCount > 0)
{
// Bill the customer.
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine
("Bill customer ${0} for {1} items.", billTotal, receivedCount);
Console.WriteLine();
Console.ResetColor();
}
}
}
protected override void OnStart()
{
workerQueueClient = messagingFactory.CreateQueueClient(workerQueueName);
deciderSender = messagingFactory.CreateMessageSender(orchestratorQueueName, workerQueueName);
}
public static QueueClient CreateQueueClient(MessagingFactory queueClientFactory, string entityPath)
{
return(queueClientFactory.CreateQueueClient(entityPath));
}
public QueueEndpoint(NamespaceManager namespaceManager, MessagingFactory clientFactory, string name) : base(namespaceManager, name)
{
Client = clientFactory.CreateQueueClient(name);
}
static void Test(NamespaceManager namespaceManager, MessagingFactory messageFactory)
{
var q = namespaceManager.GetQueue(QueueName);
var t = namespaceManager.GetTopic(TopicName);
var gf = namespaceManager.GetTopics();
if (!namespaceManager.QueueExists(QueueName))
{
namespaceManager.CreateQueue(QueueName);
}
QueueClient myQueueClient = messageFactory.CreateQueueClient(QueueName);
try
{
BrokeredMessage sendMessage = new BrokeredMessage("Hello World !");
myQueueClient.Send(sendMessage);
//// Receive the message from the queue
//BrokeredMessage receivedMessage = myQueueClient.Receive(TimeSpan.FromSeconds(5));
//if (receivedMessage != null)
//{
// Console.WriteLine(string.Format("Message received: {0}", receivedMessage.GetBody<string>()));
// receivedMessage.Complete();
//}
//Check for messages that are older than they should be
int minutesOld = 1;
DateTime oldest = DateTime.UtcNow.AddMinutes(-minutesOld);
int oldMessageCount = 0;
List <BrokeredMessage> messages = new List <BrokeredMessage>(myQueueClient.PeekBatch(1000));
foreach (BrokeredMessage b in messages)
{
if (b.EnqueuedTimeUtc < oldest)
{
oldMessageCount++;
}
}
BrokeredMessage bd = myQueueClient.Receive();
bd.DeadLetter();
//check for dead letter messages
QueueClient dlClient = messageFactory.CreateQueueClient(QueueClient.FormatDeadLetterPath(QueueName));
List <BrokeredMessage> dlMessages = new List <BrokeredMessage>(dlClient.PeekBatch(1000));
int i = dlMessages.Count;
//b.DeadLetter();
if (!namespaceManager.TopicExists(TopicName))
{
namespaceManager.CreateTopic(TopicName);
}
if (!namespaceManager.SubscriptionExists(TopicName, SubName))
{
namespaceManager.CreateSubscription(TopicName, SubName);
}
TopicClient topicClient = messageFactory.CreateTopicClient(TopicName);
topicClient.Send(new BrokeredMessage("Message"));
SubscriptionDescription s = namespaceManager.GetSubscription(TopicName, SubName);
SubscriptionClient subClient = messageFactory.CreateSubscriptionClient(TopicName, SubName);
List <BrokeredMessage> subMessages = new List <BrokeredMessage>(subClient.PeekBatch(1000));
BrokeredMessage bms = subClient.Receive();
bms.DeadLetter();
foreach (BrokeredMessage b in messages)
{
if (b.EnqueuedTimeUtc < oldest)
{
oldMessageCount++;
}
}
}
catch (Exception e)
{
Console.WriteLine("Unexpected exception {0}", e.ToString());
throw;
}
finally
{
if (messageFactory != null)
{
messageFactory.Close();
}
}
//Send Message
}
static void Setup()
{
Console.WriteLine("Reading configuration...");
_serviceNamespace = ConfigurationManager.AppSettings["ServiceBusNamespace"];
Console.WriteLine(string.Format("* Service bus namespace is \"{0}\"", _serviceNamespace));
_issuerName = ConfigurationManager.AppSettings["Issuer"];
Console.WriteLine(string.Format("* Issuer \"{0}\"", _issuerName));
_issuerKey = ConfigurationManager.AppSettings["Key"];
Console.WriteLine(string.Format("* Key \"{0}\"", _issuerKey));
_inputQueue = ConfigurationManager.AppSettings["InputQueueIdentifier"];
Console.WriteLine(string.Format("* Input queue identifier \"{0}\" \r\n", _inputQueue));
//Create queue client for posting to the input queue
var credentials = TokenProvider.CreateSharedSecretTokenProvider(_issuerName, _issuerKey);
_factory = MessagingFactory.Create(ServiceBusEnvironment.CreateServiceUri("sb", _serviceNamespace, string.Empty), credentials);
_inputQueueClient = _factory.CreateQueueClient(_inputQueue);
}
