/// <summary>
/// Get all messages with a specific session
/// </summary>
/// <param name="client">QueueClient</param>
private void GetAllMessagesWithSession(QueueClient client)
{
foreach (MessageSession sessions in client.GetMessageSessions())
{
try
{
MessageSession ses = client.AcceptMessageSession(sessions.SessionId);
BrokeredMessage item = ses.Receive(properties.ReceiveTimeout);
while (true)
{
if (item == null)
{
break;
}
if (SubmitMessage(item) == false)
{
ses.Abort();
break;
}
//allow setting timeout
item = ses.Receive(properties.ReceiveTimeout);
}
}
catch (Exception)
{
break;
}
}
}
/// <summary>
/// Get all messages that has a session
/// </summary>
/// <param name="client">QueueClient</param>
private void GetSessionMessages(QueueClient client)
{
try
{
MessageSession ses = client.AcceptMessageSession(properties.Session);
BrokeredMessage item = ses.Receive(properties.ReceiveTimeout);
while (true)
{
if (item == null)
{
break;
}
if (SubmitMessage(item) == false)
{
ses.Abort();
break;
}
//allow setting timeout
item = ses.Receive(properties.ReceiveTimeout);
}
}
catch (Exception)
{
//probably lock
}
}
static void SendMessages(QueueClient requestClient, QueueClient responseClient)
{
// Send request messages to queue:
Console.WriteLine("Sending request messages to queue {0}", requestClient.Path);
Console.WriteLine("Receiving response messages on queue {0}", responseClient.Path);
MessageSession receiver = responseClient.AcceptMessageSession(ReplyToSessionId);
for (int i = 0; i < SampleManager.NumMessages; ++i)
{
// send request message
BrokeredMessage message = CreateRequestMessage(i);
requestClient.Send(message);
SampleManager.OutputMessageInfo("REQUEST: ", message);
// receive response message
BrokeredMessage receivedMessage = receiver.Receive(TimeSpan.FromSeconds(ResponseMessageTimeout));
if (receivedMessage != null)
{
SampleManager.OutputMessageInfo("RESPONSE: ", message);
receivedMessage.Complete();
}
else
{
Console.WriteLine("ERROR: Response timed out.");
}
}
receiver.Close();
Console.WriteLine();
}
public static void ReceiveQ()
{
Console.WriteLine("In Receive method().");
TokenProvider credentials = TokenProvider.CreateSharedSecretTokenProvider(QReceiver.IssuerName, QReceiver.IssuerKey);
Uri serviceUri = ServiceBusEnvironment.CreateServiceUri("sb", QReceiver.ServiceNamespace, string.Empty);
MessagingFactory factory = null;
factory = MessagingFactory.Create(serviceUri, credentials);
QueueClient sessionQueueClient = factory.CreateQueueClient(QReceiver.QueueName);
//Create sessionQueueClient and subscribe to SessionIDs that have a value of "Mike"
MessageSession sessionReceiver = sessionQueueClient.AcceptMessageSession("92610", TimeSpan.FromSeconds(60));
BrokeredMessage receivedMessage;
while ((receivedMessage = sessionReceiver.Receive(TimeSpan.FromSeconds(60))) != null)
{
Console.WriteLine("Received Messages.");
var data = receivedMessage.GetBody <FireEvent>(new DataContractSerializer(typeof(FireEvent)));
//Console.WriteLine(String.Format("Customer Name: {0}", data.CustomerName));
Console.WriteLine("SessionID: {0}", receivedMessage.SessionId);
//remove message from Topic
receivedMessage.Complete();
}
Console.WriteLine("All received on this session...press enter to exit");
Console.Read();
}
static void SendMessages(TopicClient topicClient, SubscriptionClient responseClient)
{
// Send request messages to queue:
Console.WriteLine("Sending request messages to topic {0}", topicClient.Path);
Console.WriteLine("Receiving response messages on subscription {0}", responseClient.Name);
MessageSession session = responseClient.AcceptMessageSession(ClientId);
for (int i = 0; i < SampleManager.NumMessages; ++i)
{
// send request message
BrokeredMessage message = new BrokeredMessage
{
ReplyToSessionId = ClientId,
MessageId = i.ToString(),
CorrelationId = SampleManager.RequestSubName
};
topicClient.Send(message);
SampleManager.OutputMessageInfo("REQUEST: ", message);
// start asynchronous receive operation
//TODO: Fix
//session.ReceiveAsync ( TimeSpan.FromSeconds(ResponseMessageTimeout), ProcessResponse, session);
var brokeredMessage = session.Receive(TimeSpan.FromSeconds(ResponseMessageTimeout));
ProcessResponse(brokeredMessage);
}
Console.WriteLine();
}
public FileMessage ReceiveLargeMessage(CancellationTokenSource cancel)
{
var largeMessageStream = new MemoryStream();
MessageSession session = _queueClient.AcceptMessageSession();
_logger.LogMessage($"Message session Id: {session.SessionId}");
_logger.LogMessage("Receiving sub messages");
bool isFirst = true;
string fileName = "";
while (true)
{
BrokeredMessage subMessage = session.Receive(TimeSpan.FromSeconds(5));
if (subMessage != null)
{
if (cancel.IsCancellationRequested)
{
break;
}
try
{
if (isFirst)
{
//receive filename
fileName = subMessage.GetBody <string>();
isFirst = false;
}
else
{
//receive filestream
Stream subMessageStream = subMessage.GetBody <Stream>();
subMessageStream.CopyTo(largeMessageStream);
}
subMessage.Complete();
}
catch (Exception ex)
{
_logger.LogException(ex);
}
}
else
{
_logger.LogMessage("Done!");
break;
}
}
BrokeredMessage largeMessage = new BrokeredMessage(largeMessageStream, true);
return(new FileMessage(fileName, largeMessage));
}
static void ReceiveSessionMessages(MessageSession receiver)
{
// Read messages from queue until queue is empty:
Console.WriteLine("Reading messages from queue {0}", receiver.Path);
Console.WriteLine("Receiver Type:" + receiver.GetType().Name);
Console.WriteLine("Receiver.SessionId = " + receiver.SessionId);
BrokeredMessage receivedMessage;
while ((receivedMessage = receiver.Receive(TimeSpan.FromSeconds(receiveSessionMessageTimeout))) != null)
{
string sessionId = receiver.SessionId;
ProcessMessage(receivedMessage, receiver);
}
receiver.Close();
}
static void Main(string[] args)
{
var client = QueueClient.CreateFromConnectionString(SasConnectionstring, QueueName);
MessageSession session = null;
do
{
session = client.AcceptMessageSession(TimeSpan.FromSeconds(20));
BrokeredMessage message = null;
do
{
message = session.Receive(TimeSpan.FromSeconds(20));
if (message != null)
{
Console.WriteLine(
$@"Message# {message.MessageId} Received.
Label: {message.Label} ({message.ContentType})
Body:
-----------------------------
{message
.GetBody<string>()}
-----------------------------
");
message.Complete();
}
} while (message != null);
Console.ReadLine();
} while (session != null);
//static async Task Queue()
//{
// // Create management credentials
// TokenProvider credentials = TokenProvider.CreateSharedAccessSignatureTokenProvider(sasKeyName, sasKeyValue);
// NamespaceManager namespaceClient = new NamespaceManager(ServiceBusEnvironment.CreateServiceUri("sb", nameSpace, string.Empty), credentials);
//}
}
public void ReadMessage()
{
MessagingFactory _messagingFactory;
const string RequestQueue = "testwithcheck";
//Console.ForegroundColor = ConsoleColor.Green;
var connectionString = ConfigurationManager.ConnectionStrings["ServiceBusConnectionString"];
_messagingFactory = MessagingFactory.CreateFromConnectionString(connectionString.ConnectionString);
var receiver = _messagingFactory.CreateQueueClient(RequestQueue, ReceiveMode.PeekLock);
#region variables
var messageBodyStream = new MemoryStream();
MessageSession receiverSession = null;
var keepPolling = true;
var isFirstMessage = true;
var expectedNoMessages = 0;
BrokeredMessage[] messages = null;
messageBodyStream = new MemoryStream();
var messagesReceived = 0;
var responseQueue = string.Empty;
var sessionId = string.Empty;
var correlationId = string.Empty;
Stream fullMessageBodyStream = null;
#endregion
while (true)
{
Console.WriteLine("Waiting for new message");
using (var scope = new TransactionScope())
{
receiverSession = receiver.AcceptMessageSession();
#region variables
messageBodyStream = new MemoryStream();
keepPolling = true;
isFirstMessage = true;
expectedNoMessages = 0;
messages = null;
messagesReceived = 0;
responseQueue = string.Empty;
sessionId = string.Empty;
correlationId = string.Empty;
#endregion
while (keepPolling)
{
var message = receiverSession.Receive(TimeSpan.FromSeconds(10));
if (message == null)
{
continue;
}
if (isFirstMessage)
{
Console.WriteLine("Receiving first message");
expectedNoMessages = (int)message.Properties["TotalMessages"];
messages = new BrokeredMessage[expectedNoMessages];
isFirstMessage = false;
responseQueue = message.ReplyTo;
sessionId = message.SessionId;
correlationId = message.CorrelationId;
}
var messageNo = (int)message.Properties["MessageNo"];
var messageIndex = messageNo - 1;
Console.WriteLine(string.Format("Receiving message {0}", messageNo));
messages[messageIndex] = message;
messagesReceived++;
if (messagesReceived == expectedNoMessages)
{
keepPolling = false;
}
}
//Rebuild Object
fullMessageBodyStream = ChunkedMessageBuilder.ReconstructMessageBody(messages);
var completeTasks = new List <Task>();
foreach (var message in messages)
{
completeTasks.Add(message.CompleteAsync());
}
Task.WaitAll(completeTasks.ToArray());
}
var obj = SerializationHelper.Deserialize <string>(fullMessageBodyStream);
Console.WriteLine(string.Format("Request Message is = {0}", obj));
Console.WriteLine("");
//var stringBuilder = new StringBuilder();
//stringBuilder.Append('I', Convert.ToInt32(fullMessageBodyStream.Length));
//var responseMessageBody = new Messages.VeryBigDataType();
//responseMessageBody.BigValue = stringBuilder.ToString();
//SendMessage(responseMessageBody, responseQueue, sessionId, correlationId);
}
Console.ReadLine();
}
private void Run1(object obj)
{
string threadName = obj.ToString();
var connectionString = textBox1.Text; //System.Configuration.ConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];
var topicName = textBox2.Text; //System.Configuration.ConfigurationManager.AppSettings["TopicName"];
var subscriptionName = textBox3.Text; //System.Configuration.ConfigurationManager.AppSettings["SubscriptionName"];
var subscriptionClient = SubscriptionClient.CreateFromConnectionString(connectionString, topicName, subscriptionName, ReceiveMode.PeekLock);
// Accept a message session and handle any timeout exceptions.
MessageSession orderSession = null;
while (orderSession == null)
{
try
{
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine("Accepting message session...");
// Accept the message session
orderSession = subscriptionClient.AcceptMessageSession();
Console.WriteLine("Session accepted.");
}
catch (TimeoutException ex)
{
Console.WriteLine(ex.Message);
}
}
int i = 0;
// Receive the order batch tag read messages.
while (true)
{
//BrokeredMessage receivedTagRead = queueClient.Receive(TimeSpan.FromSeconds(5));
// Receive the tag read messages from the message session.
BrokeredMessage receivedTagRead = orderSession.Receive(TimeSpan.FromSeconds(5));
if (receivedTagRead != null)
{
//Console.WriteLine(msg.Properties["eventData"].ToString());
string text = threadName + "_" + i++ + "\n";
foreach (var prop in receivedTagRead.Properties)
{
text += string.Format("{0}\t{1}\n", prop.Key, prop.Value);
}
// Mark the message as complete
receivedTagRead.Complete();
}
else
{
break;
}
}
//int i = 0;
//subscriptionClient.OnMessage(msg =>
//{
// Console.WriteLine(threadName + "_" + i++);
// label5.BeginInvoke((Action)delegate ()
// {
// label5.Text = threadName + "_" + i++;
// Application.DoEvents();
// });
// //Console.WriteLine(msg.Properties["eventData"].ToString());
// string text = threadName + "_" + i++ + "\n";
// foreach (var prop in msg.Properties)
// {
// text += string.Format("{0}\t{1}\n", prop.Key, prop.Value);
// }
// WriteToFileThreadSafe(text + "\n", "QueueMessages.txt");
// msg.Complete();
//});
//label5.BeginInvoke((Action)delegate ()
//{
// label5.Text = threadName + "_" + i++ + " ... Done.";
//});
}
