static AmqpMap GetCorrelationFilterMap(CorrelationFilter correlationFilter)
{
var correlationFilterMap = new AmqpMap
{
[ManagementConstants.Properties.CorrelationId] = correlationFilter.CorrelationId,
[ManagementConstants.Properties.MessageId] = correlationFilter.MessageId,
[ManagementConstants.Properties.To] = correlationFilter.To,
[ManagementConstants.Properties.ReplyTo] = correlationFilter.ReplyTo,
[ManagementConstants.Properties.Label] = correlationFilter.Label,
[ManagementConstants.Properties.SessionId] = correlationFilter.SessionId,
[ManagementConstants.Properties.ReplyToSessionId] = correlationFilter.ReplyToSessionId,
[ManagementConstants.Properties.ContentType] = correlationFilter.ContentType
};
var propertiesMap = new AmqpMap();
foreach (var property in correlationFilter.Properties)
{
propertiesMap[new MapKey(property.Key)] = property.Value;
}
correlationFilterMap[ManagementConstants.Properties.CorrelationFilterProperties] = propertiesMap;
return(correlationFilterMap);
}
public async Task SendMessagesAsync(object message, CorrelationFilter filter)
{
try
{
var msg = new Message(Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(message)))
{
ContentType = filter.ContentType,
CorrelationId = filter.CorrelationId,
Label = filter.Label,
ReplyTo = filter.ReplyTo,
ReplyToSessionId = filter.ReplyToSessionId,
SessionId = filter.SessionId,
MessageId = filter.MessageId ?? Guid.NewGuid().ToString(),
To = filter.To
};
await _topicClient.SendAsync(msg);
await _topicClient.CloseAsync();
}
catch (Exception ex)
{
Trace.TraceInformation($"Erro: {ex.Message}");
Console.WriteLine(ex);
throw;
}
}
internal ServiceBusRuleData(ResourceIdentifier id, string name, ResourceType resourceType, SystemData systemData, FilterAction action, FilterType?filterType, SqlFilter sqlFilter, CorrelationFilter correlationFilter) : base(id, name, resourceType, systemData)
{
Action = action;
FilterType = filterType;
SqlFilter = sqlFilter;
CorrelationFilter = correlationFilter;
}
public static Filter GetFilter(AmqpFilter amqpFilter)
{
Filter sqlFilter;
if (amqpFilter.DescriptorCode == AmqpSqlFilter.Code)
{
sqlFilter = new SqlFilter(((AmqpSqlFilter)amqpFilter).Expression);
}
else if (amqpFilter.DescriptorCode == AmqpTrueFilter.Code)
{
sqlFilter = new TrueFilter();
}
else if (amqpFilter.DescriptorCode != AmqpFalseFilter.Code)
{
if (amqpFilter.DescriptorCode != AmqpCorrelationFilter.Code)
{
throw new NotSupportedException();
}
sqlFilter = new CorrelationFilter(((AmqpCorrelationFilter)amqpFilter).CorrelationId);
}
else
{
sqlFilter = new FalseFilter();
}
return(sqlFilter);
}
public async Task SetupSubscriptionRules()
{
var exitstingRules = await _subscriptionClient.GetRulesAsync();
var subscriptionRuleName = _subscriptionName + "-rule";
if (exitstingRules != null)
{
exitstingRules
.Where(r => r.Name != subscriptionRuleName)
.ToList()
.ForEach(async r => await _subscriptionClient.RemoveRuleAsync(r.Name));
if (exitstingRules.Any(r => r.Name == subscriptionRuleName))
{
return;
}
}
var corrFilter = new CorrelationFilter();
corrFilter.Properties.Add(_filterProperty, true);
var rule = new RuleDescription
{
Filter = corrFilter,
Name = subscriptionRuleName
};
await _subscriptionClient.AddRuleAsync(rule);
}
private static void CreateTopicSubscriptions(string topic)
{
//subcription to all messages for home and vehicles
if (!nsManager.SubscriptionExists(topic, "AllVehicleAndHomeMessages"))
{
nsManager.CreateSubscription(topic, "AllVehicleAndHomeMessages");
}
Filter filter;
//add temperature and type(car or home) based subscription
if (!nsManager.SubscriptionExists(topic, "DangeorusHomeTemperatureMessages"))
{
filter = new SqlFilter("Temperature < 72.0");
nsManager.CreateSubscription(topic, "DangeorusHomeTemperatureMessages", filter);
}
if (!nsManager.SubscriptionExists(topic, "DangeorusCarTemperatureMessages"))
{
filter = new CorrelationFilter("Car");
nsManager.CreateSubscription(topic, "DangeorusCarTemperatureMessages", filter);
}
//add theft based subscription
if (!nsManager.SubscriptionExists(topic, "TheftMessages"))
{
filter = new SqlFilter("Theft = 'Yes. Please call 911.'");
nsManager.CreateSubscription(topic, "TheftMessages", filter);
}
}
public void TestCorrelationFilter()
{
string topicName = "TestCorrelationFilter";
string SubscriptionName = "TestCorrelationFilter".ToLower() + Guid.NewGuid().ToString().Substring(0, 5);
var ns = NamespaceManager.CreateFromConnectionString(TestServiceBus.serviceBusConnectionString);
try
{
ns.CreateTopic(topicName);
var filter = new CorrelationFilter();
filter.Label = "blah";
filter.ReplyTo = "x";
filter.Properties["prop1"] = "abc"; //from message.Properties["prop1"] = "abc";
filter.Properties["prop2"] = "xyz";
SubscriptionDescription initialDesc = ns.CreateSubscription(topicName, SubscriptionName, filter);
IEnumerable <RuleDescription> rules = ns.GetRules(topicName, SubscriptionName);
Assert.IsTrue((rules.First().Filter as CorrelationFilter).Label.Equals("blah"));
Assert.IsTrue((rules.First().Filter as CorrelationFilter).ReplyTo.Equals("x"));
//TODO properties dont serialize correctly yet!!
}
finally
{
ns.DeleteTopic(topicName);
}
}
public async Task CorrelationFilterPropertiesTest()
{
var topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
try
{
await client.CreateTopicAsync(topicName);
await client.CreateSubscriptionAsync(topicName, subscriptionName);
var sClient = new SubscriptionClient(ConnectionString, topicName, subscriptionName);
var filter = new CorrelationFilter();
filter.Properties.Add("stringKey", "stringVal");
filter.Properties.Add("intKey", 5);
filter.Properties.Add("dateTimeKey", DateTime.UtcNow);
var rule = await client.CreateRuleAsync(topicName, subscriptionName, new RuleDescription("rule1", filter));
Assert.True(filter.Properties.Count == 3);
Assert.Equal(filter, rule.Filter);
await client.DeleteTopicAsync(topicName);
}
catch
{
await SafeDeleteTopic(topicName);
throw;
}
}
static CorrelationFilter CreateFilter(string propertyName, object value)
{
var filter = new CorrelationFilter();
filter.Properties[propertyName] = value;
return(filter);
}
private static async Task AddCorrelationFilter(string region)
{
var rules = await salesCancelSubscriptionClient.GetRulesAsync();
if (!rules.Any(r => r.Name == "CorrelationRule"))
{
var correlationFilter = new CorrelationFilter(region);
await salesCancelSubscriptionClient.AddRuleAsync("CorrelationRule", correlationFilter);
}
}
/// <summary>
/// Creates the filter which xml definition is contained in the element parameter.
/// </summary>
/// <param name="serviceBusHelper">A ServiceBusHelper object.</param>
/// <param name="filter">The XElement containing the filter definition.</param>
/// <returns>The filter.</returns>
private static Filter CreateFilter(ServiceBusHelper serviceBusHelper, XElement filter)
{
if (filter == null)
{
return(null);
}
string fullName = null;
if (filter.Name == string.Format(NodeNameFormat, Namespace, SqlFilterEntity))
{
fullName = typeof(SqlFilter).FullName;
}
if (filter.Name == string.Format(NodeNameFormat, Namespace, CorrelationFilterEntity))
{
fullName = typeof(CorrelationFilter).FullName;
}
if (string.IsNullOrEmpty(fullName) ||
!propertyCache.ContainsKey(fullName))
{
return(null);
}
var propertyDictionary = propertyCache[fullName];
var propertyValue = new Dictionary <string, object>();
var properties = filter.Elements();
foreach (var property in properties)
{
var xmlReader = property.CreateReader();
GetPropertyValue(propertyDictionary,
propertyValue,
xmlReader);
}
Filter ruleFilter = null;
if (filter.Name == string.Format(NodeNameFormat, Namespace, SqlFilterEntity) &&
propertyValue.ContainsKey(SqlExpression))
{
ruleFilter = new SqlFilter(propertyValue[SqlExpression] as string);
}
if (filter.Name == string.Format(NodeNameFormat, Namespace, CorrelationFilterEntity))
{
ruleFilter = new CorrelationFilter(propertyValue[Correlationid] as string);
}
if (ruleFilter != null)
{
SetPropertyValue(propertyDictionary,
propertyValue,
ruleFilter);
}
return(ruleFilter);
}
public async Task AddCorrelationFilter(
string propertyName,
string propertyValue)
{
var customerPropertyFilter = new CorrelationFilter();
customerPropertyFilter.Properties.Add(propertyName, propertyValue);
await this.subscriptionClient.AddRuleAsync(new RuleDescription
{
Filter = customerPropertyFilter,
Name = $"{propertyName}Filter"
});
}
public static void Register()
{
var container = GlobalConfiguration.Configuration.DependencyResolver;
var topicFactory = (ITopicFactory)container.GetService(typeof(ITopicFactory));
topicFactory.CreateTopicAsync(Settings.ServiceBusRequestTopicName).Wait();
topicFactory.CreateTopicAsync(Settings.ServiceBusResponseTopicName).Wait();
topicFactory.CreateSubscriptionAsync(Settings.ServiceBusRequestTopicName, Settings.ServiceBusRequestSubscriptionName).Wait();
// Create a subscription that uses a correlation filter for this specific machine instance by machine name.
var requestSubscriptionName = string.Format(Settings.ServiceBusResponseSubscriptionNameFormat, Environment.MachineName);
var requestSubscriptionFilter = new CorrelationFilter(Environment.MachineName);
topicFactory.CreateSubscriptionAsync(Settings.ServiceBusResponseTopicName, requestSubscriptionName, requestSubscriptionFilter).Wait();
}
public async Task SendMessage(string topicName, object message, CorrelationFilter filter)
{
try
{
var sbsm = new ServiceBusSendMessageTopic(new ServiceBusTopic().GetTopic(topicName));
await sbsm.SendMessagesAsync(message, filter);
}
catch (Exception ex)
{
Trace.TraceInformation($"Erro: {ex.Message}");
Console.WriteLine(ex);
throw;
}
}
public static Filter GetFilter(AmqpFilterCodec amqpFilter)
{
Filter filter;
switch (amqpFilter.DescriptorCode)
{
case AmqpSqlFilterCodec.Code:
var amqpSqlFilter = (AmqpSqlFilterCodec)amqpFilter;
filter = new SqlFilter(amqpSqlFilter.Expression);
break;
case AmqpTrueFilterCodec.Code:
filter = new TrueFilter();
break;
case AmqpFalseFilterCodec.Code:
filter = new FalseFilter();
break;
case AmqpCorrelationFilterCodec.Code:
var amqpCorrelationFilter = (AmqpCorrelationFilterCodec)amqpFilter;
var correlationFilter = new CorrelationFilter
{
CorrelationId = amqpCorrelationFilter.CorrelationId,
MessageId = amqpCorrelationFilter.MessageId,
To = amqpCorrelationFilter.To,
ReplyTo = amqpCorrelationFilter.ReplyTo,
Label = amqpCorrelationFilter.Label,
SessionId = amqpCorrelationFilter.SessionId,
ReplyToSessionId = amqpCorrelationFilter.ReplyToSessionId,
ContentType = amqpCorrelationFilter.ContentType
};
foreach (var property in amqpCorrelationFilter.Properties)
{
correlationFilter.Properties.Add(property.Key.Key.ToString(), property.Value);
}
filter = correlationFilter;
break;
default:
throw new NotSupportedException($"Unknown filter descriptor code: {amqpFilter.DescriptorCode}");
}
return(filter);
}
private void NotifyTraveler(TripDTO trip, string travelerUserId, string updateType)
{
// TODO: Exercise 2: Task 3a: Connect to the service bus namespace
// Create the topic if it does not exist already
string connectionString =
WebConfigurationManager.AppSettings["Microsoft.ServiceBus.ConnectionString"];
string topicName =
WebConfigurationManager.AppSettings["Microsoft.ServiceBus.TopicName"];
var namespaceManager =
NamespaceManager.CreateFromConnectionString(connectionString);
// TODO: Exercise 2: Task 3b: Each client requires a different subscription so they
// will only get their own updates. Create a variable for the subscription name
// and set its value to the id of the client that created the order
string travelerSubscriptionName = travelerUserId;
// TODO: Exercise 2: Task 3c: Each subsription is for a different client,
// create a filter that looks for a message sent for the specific client
CorrelationFilter travelerFilter = new CorrelationFilter(travelerSubscriptionName);
// TODO: Exercise 2: Task 3d: Verify the subscription exists, and create it if it doesn't
if (!namespaceManager.SubscriptionExists(topicName, travelerSubscriptionName))
{
namespaceManager.CreateSubscription(topicName, travelerSubscriptionName, travelerFilter);
}
// TODO: Exercise 2: Task 3e: Connect to the topic
TopicClient Client = TopicClient.CreateFromConnectionString(connectionString, topicName);
// TODO: Exercise 2: Task 3f: Create the brokered message
BrokeredMessage message = new BrokeredMessage(trip);
// TODO: Exercise 2: Task 3g: Set the ClientId property so the message will be delivered
// to the required subscription, and set the UpdateType property to reflect the
// reason this message was sent to the client
// Set additional custom app-specific property
message.CorrelationId = travelerSubscriptionName;
message.Properties["UpdateType"] = updateType;
// TODO: Exercise 2: Task 3h: Send the message to the topic
Client.Send(message);
}
static async Task Main(string[] args)
{
ManagementClient m_ManagementClient = new ManagementClient("your connection string goes here");
string topicPath = "demotopic";
string subscriptionName = "orderSubscription";
// create the filter
var filter = new CorrelationFilter();
filter.Properties["State"] = "USA";
var rule = new RuleDescription("Demo", filter);
var subscriptionDescription = new SubscriptionDescription(topicPath, subscriptionName);
await m_ManagementClient.CreateSubscriptionAsync(subscriptionDescription, rule);
Console.WriteLine("Hello World!");
}
internal static RuleDescription CreateSubscriptionRule(Priority?priority)
{
RuleDescription rule = null;
if (priority.HasValue && (priority != Priority.Default))
{
string priorityStr = priority.Value.ToString();
//var filter = new SqlFilter($"Priority = '{priorityStr}'");
var correlationFilter = new CorrelationFilter();
correlationFilter.Properties["Priority"] = priorityStr;
rule = new RuleDescription()
{
Name = $"Priority-{priorityStr}",
Filter = correlationFilter
};
}
return(rule);
}
private static async Task ConfigureServiceBusAsync()
{
var mgmtClient = new ManagementClient(ServiceBusConnectionString);
// Create our topic
if (!await mgmtClient.TopicExistsAsync(TopicName))
{
await mgmtClient.CreateTopicAsync(new TopicDescription(TopicName) { EnableBatchedOperations = true });
}
// Create the subscription we need
if (!await mgmtClient.SubscriptionExistsAsync(TopicName, StatusSubscription))
{
await mgmtClient.CreateSubscriptionAsync(new SubscriptionDescription(TopicName, StatusSubscription) { RequiresSession = true, MaxDeliveryCount = 3 });
await statusSubscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
var filter = new CorrelationFilter
{
Label = "Status"
};
await statusSubscriptionClient.AddRuleAsync(new RuleDescription(StatusSubscription, filter));
}
}
public async Task <string> CreateSubscription(string Destinatary)
{
string subscription = Guid.NewGuid().ToString();
SubscriptionDescription subscriptionDescription = new SubscriptionDescription(_Topic, subscription)
{
AutoDeleteOnIdle = TimeSpan.FromHours(1),
DefaultMessageTimeToLive = TimeSpan.FromMinutes(5),
LockDuration = TimeSpan.FromSeconds(30),
MaxDeliveryCount = 50
};
Filter filter = new CorrelationFilter()
{
To = Destinatary
};
RuleDescription ruleDescription = new RuleDescription("ToFilter", filter);
ManagementClient managementClient = new ManagementClient(_ManagementConnectionString);
await managementClient.CreateSubscriptionAsync(subscriptionDescription, ruleDescription);
return(subscription);
}
private static async Task ReadMessage(string topicName, string correlationId)
{
string subscriptionName = "ReplySubscription";
var subscriptionClient = new SubscriptionClient(_connectionString, topicName, subscriptionName);
var rules = await subscriptionClient.GetRulesAsync();
if (rules.Any(a => a.Name == "OnlyToMe"))
{
await subscriptionClient.RemoveRuleAsync("OnlyToMe");
}
if (rules.Any(a => a.Name == RuleDescription.DefaultRuleName))
{
await subscriptionClient.RemoveRuleAsync(RuleDescription.DefaultRuleName);
}
var filter = new CorrelationFilter();
filter.To = "MyUniqueClientName";
var ruleDescription = new RuleDescription("OnlyToMe", filter);
await subscriptionClient.AddRuleAsync(ruleDescription);
var messageHandlerOptions = new MessageHandlerOptions(ExceptionHandler)
{
AutoComplete = false
};
subscriptionClient.RegisterMessageHandler(
(message, cancellationToken) => handleMessage(correlationId, subscriptionClient, message, cancellationToken),
messageHandlerOptions);
await _taskCompletionSource.Task;
await subscriptionClient.UnregisterMessageHandlerAsync(
new TimeSpan(0, 0, 20));
}
public async Task BasicRulesCrudTest()
{
var topicName = Guid.NewGuid().ToString("D").Substring(0, 8);
var subscriptionName = Guid.NewGuid().ToString("D").Substring(0, 8);
var client = new ManagementClient(new ServiceBusConnectionStringBuilder(TestUtility.NamespaceConnectionString));
try
{
await client.CreateTopicAsync(topicName);
await client.CreateSubscriptionAsync(
new SubscriptionDescription(topicName, subscriptionName),
new RuleDescription("rule0", new FalseFilter()));
var sqlFilter = new SqlFilter("stringValue = @stringParam AND intValue = @intParam AND longValue = @longParam AND dateValue = @dateParam AND timeSpanValue = @timeSpanParam");
sqlFilter.Parameters.Add("@stringParam", "string");
sqlFilter.Parameters.Add("@intParam", (int)1);
sqlFilter.Parameters.Add("@longParam", (long)12);
sqlFilter.Parameters.Add("@dateParam", DateTime.UtcNow);
sqlFilter.Parameters.Add("@timeSpanParam", TimeSpan.FromDays(1));
var rule1 = new RuleDescription
{
Name = "rule1",
Filter = sqlFilter,
Action = new SqlRuleAction("SET a='b'")
};
await client.CreateRuleAsync(topicName, subscriptionName, rule1);
var correlationFilter = new CorrelationFilter()
{
ContentType = "contentType",
CorrelationId = "correlationId",
Label = "label",
MessageId = "messageId",
ReplyTo = "replyTo",
ReplyToSessionId = "replyToSessionId",
SessionId = "sessionId",
To = "to"
};
correlationFilter.Properties.Add("customKey", "customValue");
var rule2 = new RuleDescription()
{
Name = "rule2",
Filter = correlationFilter,
Action = null
};
await client.CreateRuleAsync(topicName, subscriptionName, rule2);
var rules = await client.GetRulesAsync(topicName, subscriptionName);
Assert.True(rules.Count == 3);
Assert.Equal("rule0", rules[0].Name);
Assert.Equal(rule1, rules[1]);
Assert.Equal(rule2, rules[2]);
((CorrelationFilter)rule2.Filter).CorrelationId = "correlationIdModified";
var updatedRule2 = await client.UpdateRuleAsync(topicName, subscriptionName, rule2);
Assert.Equal(rule2, updatedRule2);
var defaultRule = await client.GetRuleAsync(topicName, subscriptionName, "rule0");
Assert.NotNull(defaultRule);
await client.DeleteRuleAsync(topicName, subscriptionName, "rule0");
await Assert.ThrowsAsync <MessagingEntityNotFoundException>(
async() =>
{
await client.GetRuleAsync(topicName, subscriptionName, "rule0");
});
await client.DeleteTopicAsync(topicName);
}
catch
{
await SafeDeleteTopic(client, topicName);
throw;
}
finally
{
await client.CloseAsync();
}
}
void btnCreateDelete_Click(object sender, EventArgs e)
{
try
{
if (serviceBusHelper == null || ruleWrapper?.SubscriptionDescription == null)
{
return;
}
if (btnCreateDelete.Text == RemoveText &&
!string.IsNullOrWhiteSpace(ruleWrapper.SubscriptionDescription?.Name) &&
!string.IsNullOrWhiteSpace(ruleWrapper.RuleDescription?.Name))
{
using (var deleteForm = new DeleteForm(ruleWrapper.RuleDescription.Name, RuleEntity.ToLower()))
{
if (deleteForm.ShowDialog() == DialogResult.OK)
{
serviceBusHelper.RemoveRule(ruleWrapper.SubscriptionDescription, ruleWrapper.RuleDescription);
}
}
return;
}
if (btnCreateDelete.Text != AddText)
{
return;
}
if (string.IsNullOrWhiteSpace(txtName.Text))
{
writeToLog(NameCannotBeNull);
return;
}
var ruleDescription = new RuleDescription(txtName.Text);
if (checkBoxIsCorrelationFilter.Checked)
{
var filter = new CorrelationFilter()
{
ContentType = (!string.IsNullOrWhiteSpace(txtCorrelationFilterContentType.Text) ? txtCorrelationFilterContentType.Text : null),
CorrelationId = (!string.IsNullOrWhiteSpace(txtCorrelationFilterCorrelationId.Text) ? txtCorrelationFilterCorrelationId.Text : null),
Label = (!string.IsNullOrWhiteSpace(txtCorrelationFilterLabel.Text) ? txtCorrelationFilterLabel.Text : null),
MessageId = (!string.IsNullOrWhiteSpace(txtCorrelationFilterMessageId.Text) ? txtCorrelationFilterMessageId.Text : null),
ReplyTo = (!string.IsNullOrWhiteSpace(txtCorrelationFilterReplyTo.Text) ? txtCorrelationFilterReplyTo.Text : null),
ReplyToSessionId = (!string.IsNullOrWhiteSpace(txtCorrelationFilterReplyToSessionId.Text) ? txtCorrelationFilterReplyToSessionId.Text : null),
SessionId = (!string.IsNullOrWhiteSpace(txtCorrelationFilterSessionId.Text) ? txtCorrelationFilterSessionId.Text : null),
To = (!string.IsNullOrWhiteSpace(txtCorrelationFilterTo.Text) ? txtCorrelationFilterTo.Text : null)
};
if (userPropertyBindingList != null)
{
foreach (var prop in userPropertyBindingList)
{
filter.Properties.Add(prop.Name, prop.Value);
}
}
ruleDescription.Filter = filter;
}
else
{
if (!string.IsNullOrWhiteSpace(txtFilterExpression.Text))
{
ruleDescription.Filter = new SqlFilter(txtFilterExpression.Text);
}
}
if (!string.IsNullOrWhiteSpace(txtSqlFilterAction.Text))
{
ruleDescription.Action = new SqlRuleAction(txtSqlFilterAction.Text);
}
ruleWrapper.RuleDescription = serviceBusHelper.AddRule(ruleWrapper.SubscriptionDescription, ruleDescription);
InitializeData();
}
catch (Exception ex)
{
HandleException(ex);
}
}
static void Main(string[] args)
{
var sb = new ServiceBusSendMessage();
// Enviando mensagem para a Fila
var produtos = new
{
Produto = "Nome do Produto",
Quantidade = 10
};
sb.SendMessage("fila-teste", produtos).GetAwaiter().GetResult();
// Recebendo as mensagens da fila
var sbrmq = new ServiceBusReceiveMessageQueue();
sbrmq.IniciaVerificacaoFila("fila-teste");
Console.WriteLine("Verificando Fila.\n\rPressione qualquer tecla para finalizar a aplicação.");
Console.ReadKey();
sbrmq.PararVerificacaoFila().GetAwaiter().GetResult();
// Enviando mensagem para o tópico
var dados = new
{
Campo1 = "Valor do Campo 1",
Campo2 = "Valor do Campo 2"
};
sb.SendMessage("topico-teste", dados, new CorrelationFilter()).GetAwaiter().GetResult();
CorrelationFilter filtroCliente = new CorrelationFilter
{
Label = "Cliente"
};
var cliente = new
{
Nome = "Nome do Cliente 1"
};
sb.SendMessage("atualizacao-cliente", cliente, filtroCliente).GetAwaiter().GetResult();
CorrelationFilter filtroEndereco = new CorrelationFilter
{
Label = "Endereco"
};
var endereco = new
{
Rua = "Nome da rua",
Numero = 10,
Bairro = "Nome do Bairro",
Cidade = "Nome da Cidade"
};
sb.SendMessage("atualizacao-cliente", endereco, filtroEndereco).GetAwaiter().GetResult();
//Recebendo mensagens do topico
var sbrmt = new ServiceBusReceiveMessageTopic();
sbrmt.IniciaVerificacaoFila("topico-teste", "assinatura-endereco");
Console.WriteLine("Verificando Fila.\n\rPressione qualquer tecla para finalizar a aplicação.");
Console.ReadKey();
sbrmt.PararVerificacaoFila().GetAwaiter().GetResult();
}
internal static ServiceBusRuleData DeserializeServiceBusRuleData(JsonElement element)
{
ResourceIdentifier id = default;
string name = default;
ResourceType type = default;
SystemData systemData = default;
Optional <FilterAction> action = default;
Optional <FilterType> filterType = default;
Optional <SqlFilter> sqlFilter = default;
Optional <CorrelationFilter> correlationFilter = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("id"))
{
id = new ResourceIdentifier(property.Value.GetString());
continue;
}
if (property.NameEquals("name"))
{
name = property.Value.GetString();
continue;
}
if (property.NameEquals("type"))
{
type = new ResourceType(property.Value.GetString());
continue;
}
if (property.NameEquals("systemData"))
{
systemData = JsonSerializer.Deserialize <SystemData>(property.Value.ToString());
continue;
}
if (property.NameEquals("properties"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
foreach (var property0 in property.Value.EnumerateObject())
{
if (property0.NameEquals("action"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
action = FilterAction.DeserializeFilterAction(property0.Value);
continue;
}
if (property0.NameEquals("filterType"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
filterType = property0.Value.GetString().ToFilterType();
continue;
}
if (property0.NameEquals("sqlFilter"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
sqlFilter = SqlFilter.DeserializeSqlFilter(property0.Value);
continue;
}
if (property0.NameEquals("correlationFilter"))
{
if (property0.Value.ValueKind == JsonValueKind.Null)
{
property0.ThrowNonNullablePropertyIsNull();
continue;
}
correlationFilter = CorrelationFilter.DeserializeCorrelationFilter(property0.Value);
continue;
}
}
continue;
}
}
return(new ServiceBusRuleData(id, name, type, systemData, action.Value, Optional.ToNullable(filterType), sqlFilter.Value, correlationFilter.Value));
}
