Devprime | Documentation – Native implementations of RabbitMQ

Settings: Add an exchange on RabbitMQ

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
exchangeName (string): Name of the exchange. This is the exchange’s unique identifier on RabbitMQ.
exchangeType (ExchangeType): Type of the exchange, which can be one of the following:
- Direct: Routes messages to queues that have an exact routing key.
- Fanout: Routes messages to all queues connected to the exchange.
- Topic: Routes messages to queues based on routing key patterns.
- Headers: Routes messages based on message headers.
customProperties (CustomExchangeProperties, optional): Additional properties for configuring the exchange. The class CustomExchangeProperties allows you to specify:
- Durable (bool): Defines whether the exchange should be durable. The default is true.
- AutoDelete (bool): Defines whether the exchange should be automatically deleted when there are no queues connected. The default is false.
- Arguments (IDictionary<string, object>): Additional arguments for exchange-specific configuration. It can be null if there are no additional arguments.

Return

bool: Returns true if the exchange is successfully created; otherwise, returns false.

Here are examples of how to use the AddExchangeRabbitMQ method with and without custom properties:

**1. Creating a Direct exchange without custom properties:

// Criação de uma exchange do tipo Direct
var exchangeName = "myExchangeName";
var success = Dp.Stream.AddExchangeRabbitMQ(exchangeName,ExchangeType.Direct,null);
if (success)
{
    Console.WriteLine("Exchange criada com sucesso.");
}
else
{
    Console.WriteLine("Falha ao criar a exchange.");
}

**2. Creating a Topic exchange with custom properties:

var exchangeName = "myExchangeName";
var properties = new CustomExchangeProperties
    {
        Durable = true, // Explicitly durable
        AutoDelete = false, // Do not auto-delete
        Arguments = new Dictionary<string, object>
        {
            { "x-message-ttl", 60000 }, // Message time-to-live in milliseconds
            { "x-max-length", 1000 }    // Maximum number of messages in the queue
        }
    };
var success = Dp.Stream.AddExchangeRabbitMQ(exchangeName, ExchangeType.Direct, properties);

Considerations

Make sure that the exchangeName is unique within RabbitMQ to avoid conflicts.
Choose the appropriate exchangeType based on your message routing strategy.
Use CustomExchangeProperties to configure advanced behaviors such as durability, auto-delete, and specific arguments.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.

Settings: Add a queue in RabbitMQ

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string, optional): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
queueName (string): Name of the queue. This is the unique identifier of the queue in RabbitMQ.
customProperties (CustomQueueProperties, optional): Custom properties for the queue, such as Time-to-Live (TTL) settings, persistence, and other queue-specific characteristics.

Return

bool: Returns true if the queue is successfully created; otherwise, returns false.

Here’s an example of how to use the AddQueueRabbitMQ method in your application:

Creating a queue without using the properties

The CustomQueueProperties parameter is optional and used only for customization

// The CustomQueueProperties parameter is optional and used only for customization
var queueName = "myQueueName";
bool success = Dp.Stream.AddQueueRabbitMQ(queueName, null);
if (success)
    {
    Console.WriteLine("Fila criada com sucesso.");
    }
    else
    {
    Console.WriteLine("Falha ao criar a fila.");
    }

Creating a queue with the proprities and null argument

var customProperties = new CustomQueueProperties
{
    Durable = true,
    Exclusive = false,
    AutoDelete = false,
    Arguments = null
};
Dp.Stream.AddQueueRabbitMQ("queue-with-properties", customProperties);

Creating a queue with the properties and argument setting TTL

// This parameter is optional and used only for customization
// Creation of a queue with custom properties
var customProperties = new CustomQueueProperties
{
    Durable = true,
    Exclusive = false,
    AutoDelete = false,
    Arguments = new Dictionary<string, object>
    {
        { "x-message-ttl", 600000 } // TTL
    }
};
Dp.Stream.AddQueueRabbitMQ("queue-with-properties", customProperties);

Considerations

Make sure that the queueName is unique within RabbitMQ to avoid conflicts.
Use custom properties to configure the queue according to the specific needs of your application.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.

Settings: Adds link between an exchange and queue in RabbitMQ

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string, optional): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
exchangeName (string): Name of the exchange to which the queue will be linked.
exchangeType (ExchangeType): Type of the exchange. It can be:
- Direct: Routes messages to queues with an exact routing key.
- Fanout: Routes messages to all queues connected to the exchange.
- Topic: Routes messages to queues based on routing key patterns.
- Headers: Routes messages based on message headers.
queueName (string): Name of the queue that will be linked to the exchange.
routingKey (string): Routing key used to direct messages from the exchange to the queue.
arguments (IDictionary<string, object>, optional): Additional arguments for the connection, such as specific filters or configuration parameters.

Return

bool: Returns true if the link between the exchange and the queue is successfully created; otherwise, returns false.

Here’s an example of how to use the AddBindingExchangeQueueRabbitMQ method in your application:

1. Performing an Exchange Direct Bind without using an argument

var exchangeName = "myExchangeName";
var queueName= "myQueueName";
var routingKey = "myQueueName";
bool success = Dp.Stream.AddBindingExchangeQueueRabbitMQ(exchangeName,
ExchangeType.Direct, queueName, routingKey, null);
    if (success)
    {
        Console.WriteLine("Bind realizado com successo.");
    }
    else
    {
        Console.WriteLine("Falha ao criar Bind.");
    }

2. Binding Exchange Fanout

var exchangeName = "myExchangeName";
var queueName = "myQueueName";
var routingKey = ""; // Not using in fanout
bool success = Dp.Stream.AddBindingExchangeQueueRabbitMQ(exchangeName,
ExchangeType.Fanout, queueName, routingKey, null);

3. Binding an Exchange Topic

var exchangeName = "myExchangeName";
var queueName = "myQueueName";
var routingKey = "topic.routing.key"; // Important parameter in Exchange Topic
bool success = Dp.Stream.AddBindingExchangeQueueRabbitMQ(exchangeName,
ExchangeType.Topic, queueName, routingKey, null);

4. Binding Exchange Headers Using Arguments

var exchangeName = "myExchangeName";
var queueName = "myQueueName";
var routingKey = string.Empty; // Not using in Headers
var arguments = new Dictionary<string, object>
    {
        { "headerKey1", "headerValue1" },
        { "headerKey2", "headerValue2" }
    };
bool success = Dp.Stream.AddBindingExchangeQueueRabbitMQ(exchangeName,
ExchangeType.Headers, queueName, routingKey, arguments);

Considerations

Make sure that exchangeName and queueName are correctly configured and exist in RabbitMQ.
Adjust the routingKey and arguments as needed for your message routing strategy.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.

Settings: Subscribe to a queue in RabbitMQ

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string, optional): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
exchangeName (string): Name of the exchange from which the queue will receive messages.
exchangeType (ExchangeType): Type of the exchange. It can be:
- Direct: Routes messages to queues with an exact routing key.
- Fanout: Routes messages to all queues connected to the exchange.
- Topic: Routes messages to queues based on routing key patterns.
- Headers: Routes messages based on message headers.
queueName (string): Name of the queue that will be signed to receive messages from the exchange.

Return

List<(bool Ready, string Queue)>: Returns a list of tuples where each tuple contains:
- Ready (bool): Indicates whether the signature was successfully created.
- Queue (string): Name of the queue that was signed.

Here is an example of how to use the AddSubscribeRabbitMQ method in your application:

Adding the subscription to a Queue

var exchangeName = "myExchangeName";
var queueName = "myQueueName";
var success = Dp.Stream.AddSubscribeRabbitMQ(exchangeName, ExchangeType.Direct, queueName);
  if (success)
  {
      Console.WriteLine("Assinatura criada com sucesso.");
  }
  else
  {
      Console.WriteLine("Falha ao criar a assinatura.");
  }

Considerations

Make sure that exchangeName and queueName are correctly configured and exist in RabbitMQ.
The exchange type (exchangeType) must match the routing strategy you want to implement.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.

Settings: Remove a queue from RabbitMQ

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string, optional): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
queueName (string): Name of the queue that will be removed. This is the unique identifier of the queue in RabbitMQ.

Return

bool: Returns true if the queue is successfully removed; otherwise, returns false.

Here is an example of how to use the RemoveQueueRabbitMQ method in your application:

Removing a Queue

// Removing a queue
var queueName = "myQueueName";
bool success = Dp.Stream.RemoveQueueRabbitMQ(queueName);
    if (success)
    {
        Console.WriteLine("Queue removed successfully.");
    }
    else
    {
        Console.WriteLine("Failed to remove the queue.");
    }

Considerations

Make sure that queueName is correctly configured and exists in RabbitMQ before attempting to remove it.
After removal, all messages in the queue will be lost and cannot be recovered.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.

Settings: Remove an exchange from RabbitMQ

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string, optional): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
exchangeName (string): Name of the exchange that will be removed. This is the exchange’s unique identifier on RabbitMQ.

Return

bool: Returns true if the exchange is successfully removed; otherwise, returns false.

Here’s an example of how to use the RemoveExchangeRabbitMQ method in your application:

Removing an Exchange

// Removing an exchange
var exchangeName = "myExchangeName";
bool success = Dp.Stream.RemoveExchangeRabbitMQ(exchangeName);
    if (success)
    {
        Console.WriteLine("Exchange removed successfully.");
    }
    else
    {
        Console.WriteLine("Failed to remove the exchange.");
    }

Considerations

Make sure that exchangeName is correctly configured and exists in RabbitMQ before attempting to remove it.
After the removal, all queues linked to the exchange will be affected and will no longer receive messages from the removed exchange.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.

Settings: Cancels a subscription in a queue

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string, optional): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
queueName (string): Name of the queue whose signature will be removed. This is the unique identifier of the queue in RabbitMQ.

Return

bool: Returns true if the signature is successfully removed; otherwise, returns false.

Here’s an example of how to use the RemoveSubscribeRabbitMQ method in your application:

Removing the Signature from a Queue

// Cancelling a queue subscription
var queueName = "myQueueName";
bool success = Dp.Stream.RemoveSubscribeRabbitMQ(queueName);
    if (success)
    {
        Console.WriteLine("Subscription removed successfully.");
    }
    else
    {
        Console.WriteLine("Failed to remove the subscription.");
    }

Considerations

Ensure that queueName is correctly configured and exists in RabbitMQ before attempting to remove the signature.
After the subscription is canceled, the queue will no longer receive messages from the exchange it was subscribed to.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.

Settings: Publishing a message to an exchange or queue in RabbitMQ

Mon, 01 Jan 0001 00:00:00 +0000

Parameters

alias (string, optional): Optional parameter with the name of the Stream Alias as defined in the Stream Adapter configuration. The default value is “Stream1”.
exchangeName (string): Name of the exchange to which the message will be published.
exchangeType (ExchangeType?, optional): Type of the exchange. It can be:
- Direct: Routes messages to queues with an exact routing key.
- Fanout: Routes messages to all queues connected to the exchange.
- Topic: Routes messages to queues based on routing key patterns.
- Headers: Routes messages based on message headers.

If not specified, the default is used as per the exchange configuration.

routingKey (string): Routing key used to direct messages from the exchange to the associated queues.
eventMessage (BasicEvent): Event message that will be published on the exchange.
customProperties (CustomMessageProperties, optional): Custom properties for the message, such as Time-to-Live (TTL), persistence, and other specific characteristics.

Return

void: This method does not return a value. It performs the publication of the message to the specified exchange.

Here are examples of how to use the PublishRabbitMQ method in your application:

1. Direct Publish to Queue Without Using Exchange
In this scenario, it is not necessary to inform an exchange

var routingKey = "myQqueueName";
var eventName = "OrderCreated";
var eventData = new
    {
        Message = "Demonstration"
    };
Dp.Stream.PublishRabbitMQ(null, null, routingKey, eventName, eventData, null);

2. Publishing using Exchange Direct without CustomMessageProperties
To configure this scenario, you need to associate the Exchange “myExchangeName” of type Direct with the “myQueueName” queue.

var exchangeName = "myExchangeName";
var routingKey = "myQueueName";
var eventName = "OrderCreated";
var eventData = new
{
    Message = "Demonstration"
};

Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Direct,
    routingKey, eventName, eventData, null);

3. Publishing using Exchange Direct using TTL

To configure this scenario, you need to associate the Exchange “myExchangeName” of type Direct with the “myQueueName” queue. We used CustomMessageProperties to set the persistence parameters and expiration time (TTL). The published event will have a set time to expire.

var exchangeName = "myExchangeName";
var routingKey = "myQueueName";
var eventName = "OrderCreated";
var eventData = new
{
    Message = "Demonstration"
};

var basicProperties = new CustomMessageProperties();
basicProperties.Persistent = true;
basicProperties.Expiration = 50000000; // TTL in milliseconds

Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Direct,
         routingKey, eventName, eventData, basicProperties);

4. Publishing using Exchange Fanout with two queues as the target

To configure this scenario, you need to associate the Exchange “myExchangeName” of type Fanout with the queues “myQueueName1” and “myQueueName2”. In this case, you do not need to specify the queue name in Publish. Exchange will automatically distribute the event to both queues.

var exchangeName = "myExchangeName";
var routingKey = ""; // This parameter is not used in Fanout
var eventName = "PaymentApproved";
var eventData = new
{
    Message = "Demonstration"
};

Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Fanout,
 routingKey, eventName, eventData, null);

5. Publishing using Exchange Topic with two queues as the target

To configure this scenario, you must associate the Exchange “myExchangeName” of type Topic with two queues:

Bind to the queue “myQueueName1” with the Routing Key: "quick.ecommerce.#"
Bind to the queue “myQueueName2” with the Routing Key: "#.logs"

In this example, we will make three posts, ranging from routingKey. The exchange will distribute the messages in such a way that one of them will be delivered to both queues, while the others will be delivered to only one of the queues.

var exchangeName = "myExchangeName";
var routingKey1 = "quick.ecommerce.logs"; // Destination: myQueue1 and myQueue2
var routingKey2 = "quick.ecommerce.approved"; // Destination: myQueue1
var routingKey3 = "quick.financial.logs"; // Destination: myQueue2
var eventName = "EcommerceEvents";
var eventData = new
{
    Message = "Demonstration"
};

// Publishing with routingKey 1 for distribution to myQueue1 and myQueue2
Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Topic,
 routingKey1, eventName, eventData, null);

// Publishing with routingKey 2 for distribution to myQueue1
Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Topic,
 routingKey2, eventName, eventData, null);

// Publishing with routingKey 3 for distribution to myQueue2
Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Topic,
 routingKey3, eventName, eventData, null);

6. Publishing using Exchange Headers with two queues as the target
To configure this scenario, you need to associate the Exchange “myExchangeName” of type Headers with two queues. The first bind will be to the queue “myQueueName1” using the following key/value arguments:

Arguments 1: { "format", "pdf" }
Arguments 2: { "type", "report" }
Arguments 3: { "x-match", "all" }

The second bind will also be for the queue “myQueueName2”, with the following arguments:

Arguments 1: { "format", "zip" }
Arguments 2: { "x-match", "any" }

It is important to note that Exchange type Headers does not use the Routing Key setting during bind.

In this example, we will perform three publications, varying the parameters of Arguments. The exchange will be responsible for distributing the messages, and at the end, one of the events will be directed to “myQueueName1” and the other two to “myQueueName2”.

var exchangeName = "myExchangeName";
var routingKey = ""; // This parameter is not used in the Headers Exchange
var eventName = "ComplianceApprove";
var eventData = new
{
    Message = "Demonstration"
};

// Publishing with Headers for distribution to myQueueName1
var properties1 = new CustomMessageProperties();
properties1.Arguments = new Dictionary<string, object> 
{ 
    { "format", "pdf" }, 
    { "type", "report" } 
};
Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Headers,
 routingKey, eventName, eventData, properties1);

// Publishing with Headers for distribution to myQueueName2
var properties2 = new CustomMessageProperties();
properties2.Arguments = new Dictionary<string, object> 
{ 
    { "format", "zip" } 
};
Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Headers,
 routingKey, eventName, eventData, properties2);

// Publishing with Headers for distribution to myQueueName2
var properties3 = new CustomMessageProperties();
properties3.Arguments = new Dictionary<string, object> 
{ 
    { "format", "zip" }, 
    { "type", "image" } 
};
Dp.Stream.PublishRabbitMQ(exchangeName, ExchangeType.Headers,
 routingKey, eventName, eventData, properties3);

Considerations

Make sure that exchangeName is correctly configured and exists in RabbitMQ before attempting to publish the message.
Adjust exchangeType and customProperties as needed for your message publishing and routing strategy.
Native implementations of RabbitMQ are specific to this platform and cater to particular use cases. If you migrate to another streaming platform, you’ll need to adjust your code to use Devprime’s standard methods or the new platform’s specific methods.