apply sorting ...

Configuration/XEventServiceConfiguration.cs

@@ -1,7 +1,5 @@
-using System.Collections.Generic;
-using RabbitMQ.Client;
-using xEventService.Constants;
 using xEventService.Models;
+using xEventService.Constants;
 
 namespace xEventService.Configuration
 {
@@ -25,7 +23,13 @@ namespace xEventService.Configuration
         /// Allowed Message Broker ...
         /// </summary>
         public XEventBroker Broker { get; set; } = XEventBroker.None;
-
+        
+        /// <summary>
+        /// ZeroMQ Specific Options ...
+        /// Only used when Broker is XZeroMQ ...
+        /// </summary>
+        public XZeroMQOptions ZeroMQ { get; set; } = new XZeroMQOptions();        
+        
         /// <summary>
         /// RabbitMQ Specific Options ...
         /// Only used when Broker is XRabbitMQ ...

Constants/XEventBroker.cs

@@ -7,13 +7,16 @@ namespace xEventService.Constants
     /// </summary>
     public enum XEventBroker
     {
-        [StringValue("None")]
+        [StringValue(XEventServiceConstants.None)]
         None,
 
-        [StringValue("XKafka")]
+        [StringValue(XEventServiceConstants.XKafka)]
         XKafka,
 
-        [StringValue("XRabbitMQ")]
+        [StringValue(XEventServiceConstants.XZeroMQ)]
-        XRabbitMQ        
+        XZeroMQ,
+
+        [StringValue(XEventServiceConstants.XRabbitMQ)]
+        XRabbitMQ,
     }
 }

Constants/XEventServiceConstants.cs

@@ -8,10 +8,18 @@ namespace xEventService.Constants
 
         //
         // Defaults ...
-        public const string XDefaultTopic = "XSaherelm";  
+        public const string XDefaultTopic = "XSaherelm";
-        public const string XDefaultConsumerGroup = "XSaherElmGroup";  
+        public const string XDefaultConsumerGroup = "XSaherElmGroup";
 
         //
-        public const string XWildcard = "*";    
+        public const string None = "None";
+        public const string XKafka = "XKafka";
+        public const string PubSub = "PubSub";
+        public const string XZeroMQ = "XZeroMQ";
+        public const string PushPull = "PushPull";
+        public const string XRabbitMQ = "XRabbitMQ";
+
+        //
+        public const string XWildcard = "*";
     }
 }

Constants/XZeroMQPattern.cs

@@ -0,0 +1,16 @@
+using xExceptions.Attributes;
+
+namespace xEventService.Constants
+{
+    public enum XZeroMQPattern
+    {
+        [StringValue(XEventServiceConstants.None)]
+        None,
+
+        [StringValue(XEventServiceConstants.PubSub)]
+        PubSub,
+
+        [StringValue(XEventServiceConstants.PushPull)]
+        PushPull
+    }
+}

DI/XDIHelperExtension.cs

@@ -1,11 +1,11 @@
 using System;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
 using xCommons.Extensions;
-using xEventService.Configuration;
+using xExceptions.Constants;
 using xEventService.Constants;
 using xEventService.Extensions;
-using xExceptions.Constants;
+using xEventService.Configuration;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace xEventService.DI
 {
@@ -16,7 +16,7 @@ namespace xEventService.DI
         /// </summary>
         /// <param name="source"></param>
         /// <returns></returns>
-        public static XEventServiceConfiguration GetXEventServiceConfigurations(
+        public static XEventServiceConfiguration GetXEventServiceConfiguration(
             this IConfiguration source
         )
         {
@@ -34,14 +34,14 @@ namespace xEventService.DI
         /// </summary>
         /// <param name="services"></param>
         /// <param name="configuration"></param>
-        public static void AddXEventServiceConfigurations(
+        public static void AddXEventServiceConfiguration(
             this IServiceCollection services,
             IConfiguration configuration
         )
         {
             //
-            var config = configuration.GetXEventServiceConfigurations();
+            var config = configuration.GetXEventServiceConfiguration();
-            services.AddXEventServiceConfigurations(config);
+            services.AddXEventServiceConfiguration(config);
         }
 
         /// <summary>
@@ -49,14 +49,20 @@ namespace xEventService.DI
         /// </summary>
         /// <param name="services"></param>
         /// <param name="configuration"></param>
-        public static void AddXEventServiceConfigurations(
+        public static void AddXEventServiceConfiguration(
             this IServiceCollection services,
             XEventServiceConfiguration configuration
         )
         {
             //
             // Validate ...
-            if (!configuration.IsValid())
+            var isValid = configuration.IsValid() &&
+                (configuration.Broker == XEventBroker.XKafka ||
+                (configuration.Broker == XEventBroker.XZeroMQ &&
+                configuration.ZeroMQ.IsValid()) ||
+                (configuration.Broker == XEventBroker.XRabbitMQ &&
+                configuration.RabbitMQ.IsValid()));
+            if (!isValid)
             {
                 //
                 Log("Registration Failed, due Invalid Configuration ...");

Extensions/XEventServiceExtensions.cs

@@ -1,9 +1,9 @@
 using System.Linq;
 using xCommons.Extensions;
-using xEventService.Configuration;
-using xEventService.Constants;
 using xEventService.Models;
 using xExceptions.Constants;
+using xEventService.Constants;
+using xEventService.Configuration;
 
 namespace xEventService.Extensions
 {
@@ -71,7 +71,7 @@ namespace xEventService.Extensions
             var result =
                 !source.IsNullOrDefault() &&
                 !source.Exchange.IsNullOrEmpty() &&
-                !source.ExchangeType.IsValid();
+                source.ExchangeType.IsValid();
 
             //
             return result;
@@ -110,7 +110,37 @@ namespace xEventService.Extensions
             //
             return result;
         }
-        
+
+        /// <summary>
+        /// Validate ZeroMQ Pattern ...
+        /// </summary>
+        /// <param name="source"></param>
+        /// <returns></returns>
+        public static bool IsValid(this XZeroMQPattern source)
+        {
+            //
+            var result = source != XZeroMQPattern.None;
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Validate ZeroMQ Options ...
+        /// </summary>
+        /// <param name="source"></param>
+        /// <returns></returns>
+        public static bool IsValid(this XZeroMQOptions source)
+        {
+            //
+            var result =
+                !source.IsNullOrDefault() &&
+                source.Pattern.IsValid();
+
+            //
+            return result;
+        }
+
         /// <summary>
         /// Validate an Array is Wildcard passed or not ...
         /// </summary>
@@ -122,9 +152,9 @@ namespace xEventService.Extensions
             var result =
                 source is not null &&
                 source.Length == 1 &&
-                source.Any(s => 
+                source.Any(s =>
                     s == XEventServiceConstants.XWildcard);
-            
+
             //
             return result;
         }
@@ -145,6 +175,101 @@ namespace xEventService.Extensions
             return result;
         }
 
+        /// <summary>
+        /// Validate Sender ...
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="allowedSenders"></param>
+        /// <returns></returns>
+        public static bool IsValidSender(
+            this XEventMessage source,
+            string[] allowedSenders
+        )
+        {
+            //
+            // Validate Source and Collection ...
+            var result =
+                source.IsValid() &&
+                allowedSenders
+                    .IsAllowedCollection();
+            if (!result)
+            {
+                return result;
+            }
+
+            //
+            // Validate Sender ...
+            result =
+                allowedSenders.IsAllowedWildcard() ||
+                allowedSenders.Any(x =>
+                    x.Equals(
+                        source.Sender,
+                        System.StringComparison.InvariantCultureIgnoreCase));
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Validate Action ...
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="allowedActions"></param>
+        /// <returns></returns>
+        public static bool IsValidAction(
+            this XEventMessage source,
+            string[] allowedActions
+        )
+        {
+            //
+            // Validate Source and Collection ...
+            var result =
+                source.IsValid() &&
+                allowedActions
+                    .IsAllowedCollection();
+            if (!result)
+            {
+                return result;
+            }
+
+            //
+            // Validate Action ...
+            result =
+                allowedActions.IsAllowedWildcard() ||
+                allowedActions.Any(x =>
+                    x.Equals(
+                        source.Action,
+                        System.StringComparison.InvariantCultureIgnoreCase));
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Completely Validate a Message, based on providing:
+        /// - Allowed Actions
+        /// - Allowed Senders
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="allowedSenders"></param>
+        /// <param name="allowedActions"></param>
+        /// <returns></returns>
+        public static bool IsValid(
+            this XEventMessage source,
+            string[] allowedSenders,
+            string[] allowedActions
+        )
+        {
+            //
+            var result =
+                source.IsValid() &&
+                source.IsValidAction(allowedActions) &&
+                source.IsValidSender(allowedSenders);
+
+            //
+            return result;
+        }
+
         /// <summary>
         /// Parse Url and Extract Host address ...
         /// </summary>

Interfaces/IXEventServiceProvider.cs

@@ -0,0 +1,5 @@
+namespace xEventService.Interfaces
+{
+    public interface IXEventServiceProvider : IXProducerServiceBase
+    { }
+}

Interfaces/IXKafkaProducerService.cs

@@ -1,38 +1,8 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using xEventService.Constants;
-using xEventService.Models;
-
 namespace xEventService.Interfaces
 {
     /// <summary>
     /// a Service for Produce Kafka Messages ...
     /// </summary>
-    public interface IXKafkaProducerService : IDisposable
+    public interface IXKafkaProducerService : IXProducerServiceBase
-    {
+    { }
-        /// <summary>
-        /// Sending Message ...
-        /// </summary>
-        /// <param name="request">an Instance of <see cref="XEventRequest"/> to Provides Kafka Messaging requirement ...</param>
-        /// <param name="cancellationToken"></param>
-        /// <returns></returns>
-        Task<bool> SendMessageAsync(
-            XEventRequest request,
-            CancellationToken cancellationToken = default
-        );
-
-        /// <summary>
-        /// Sending a Message ...
-        /// </summary>
-        /// <param name="message">an Instance of <see cref="XEventMessage"/> to Provides Kafka Messaging requirement ...</param>
-        /// <param name="topic">Topic for Sending Message ...</param>
-        /// <param name="cancellationToken"></param>
-        /// <returns></returns>
-        Task<bool> SendMessageAsync(
-            XEventMessage message,
-            string topic = XEventServiceConstants.XDefaultTopic,
-            CancellationToken cancellationToken = default
-        );
-    }
 }

Interfaces/IXProducerServiceBase.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Threading;
+using xEventService.Models;
+using System.Threading.Tasks;
+using xEventService.Constants;
+
+namespace xEventService.Interfaces
+{
+    public interface IXProducerServiceBase : IDisposable
+    {
+        /// <summary>
+        /// Sending Message ...
+        /// </summary>
+        /// <param name="request">an Instance of <see cref="XEventRequest"/> to Provides Kafka Messaging requirement ...</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<bool> SendMessageAsync(
+            XEventRequest request,
+            CancellationToken cancellationToken = default
+        );
+
+        /// <summary>
+        /// Sending a Message ...
+        /// </summary>
+        /// <param name="message">an Instance of <see cref="XEventMessage"/> to Provides Kafka Messaging requirement ...</param>
+        /// <param name="topic">Topic for Sending Message ...</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        Task<bool> SendMessageAsync(
+            XEventMessage message,
+            string topic = XEventServiceConstants.XDefaultTopic,
+            CancellationToken cancellationToken = default
+        );
+    }
+}

Interfaces/IXRabbitMQProducerService.cs

@@ -1,29 +1,14 @@
-using System;
 using System.Threading;
-using System.Threading.Tasks;
 using xEventService.Models;
+using System.Threading.Tasks;
 
 namespace xEventService.Interfaces
 {
     /// <summary>
     /// RabbitMQ Producer Service Implementation ...
     /// </summary>    
-    public interface IXRabbitMQProducerService : IDisposable
+    public interface IXRabbitMQProducerService : IXProducerServiceBase
     {
-        /// <summary>
-        /// Sending Message with Full Request Descriptor ...
-        /// </summary>
-        /// <param name="request">
-        /// an Instance of <see cref="XEventRequest"/>.
-        /// Topic is used as Exchange Name ...
-        /// </param>
-        /// <param name="cancellationToken"></param>
-        /// <returns></returns>
-        Task<bool> SendMessageAsync(
-            XEventRequest request,
-            CancellationToken cancellationToken = default
-        );
-
         /// <summary>
         /// Sending a Message to Default Exchange ...
         /// </summary>
@@ -43,6 +28,6 @@ namespace xEventService.Interfaces
             string exchange = null,
             string routingKey = null,
             CancellationToken cancellationToken = default
-        );        
+        );
     }
 }

Interfaces/IXZeroMQProducerService.cs

@@ -0,0 +1,5 @@
+namespace xEventService.Interfaces
+{
+    public interface IXZeroMQProducerService : IXProducerServiceBase
+    { }
+}

Models/XEventMessage.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Collections.Generic;
 using Newtonsoft.Json;
+using System.Collections.Generic;
 
 namespace xEventService.Models
 {

Models/XRabbitMQOptions.cs

@@ -1,4 +1,3 @@
-using RabbitMQ.Client;
 using xEventService.Constants;
 
 namespace xEventService.Models

Models/XZeroMQOptions.cs

@@ -0,0 +1,28 @@
+using xEventService.Constants;
+
+namespace xEventService.Models
+{
+    public class XZeroMQOptions
+    {
+        /// <summary>
+        /// Socket Pattern (PubSub, PushPull) ...
+        /// </summary>
+        public XZeroMQPattern Pattern { get; set; } = XZeroMQPattern.PubSub;
+
+        /// <summary>
+        /// Bind or Connect ...
+        /// True for Server (Bind), False for Client (Connect) ...
+        /// </summary>
+        public bool IsServer { get; set; } = false;
+
+        /// <summary>
+        /// High Water Mark for Sending ...
+        /// </summary>
+        public int SendHighWaterMark { get; set; } = 1000;
+
+        /// <summary>
+        /// High Water Mark for Receiving ...
+        /// </summary>
+        public int ReceiveHighWaterMark { get; set; } = 1000;
+    }
+}

Providers/XBaseEventConsumerBackgroundService.cs

@@ -0,0 +1,65 @@
+using System;
+using xCommons.Providers;
+using xCommons.Extensions;
+using xExceptions.Constants;
+using xEventService.Constants;
+using xEventService.Extensions;
+using xEventService.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace xEventService.Providers
+{
+    /// <summary>
+    /// Base Event Consumer Service ...
+    /// </summary>
+    public abstract class XBaseEventConsumerBackgroundService : XResumableBackgroundService
+    {
+        /// <summary>
+        /// Consumed Topic Messages ...
+        /// </summary>
+        protected readonly string topic;
+
+        /// <summary>
+        /// Allowed Senders ...
+        /// </summary>
+        protected readonly string[] allowedSenders;
+
+        /// <summary>
+        /// Allowed Actions ...
+        /// </summary>
+        protected readonly string[] allowedActions;
+
+        /// <summary>
+        /// Configuration ...
+        /// </summary>
+        protected readonly XEventServiceConfiguration configuration;
+
+        protected XBaseEventConsumerBackgroundService(
+            string[] allowedActions,
+            string[] allowedSenders,
+            IServiceProvider serviceProvider,
+            XEventServiceConfiguration configuration,
+            ILogger<XResumableBackgroundService> logger,
+            string topic = XEventServiceConstants.XDefaultTopic
+        ) : base(serviceProvider, logger)
+        {
+            //
+            // Validate Actions ...
+            if (!allowedActions
+                .IsAllowedCollection() ||
+                !allowedSenders
+                .IsAllowedCollection() ||
+                !configuration.IsValid()
+            )
+            {
+                XException.InvalidArgs.Throw();
+            }
+
+            //
+            this.topic = topic;
+            this.configuration = configuration;
+            this.allowedActions = allowedActions;
+            this.allowedSenders = allowedSenders;
+        }
+    }
+}

Providers/XBaseEventProducerService.cs

@@ -0,0 +1,31 @@
+using xCommons.Extensions;
+using xExceptions.Constants;
+using xEventService.Extensions;
+using xEventService.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace xEventService.Providers
+{
+    public abstract class XBaseEventProducerService
+    {
+        protected readonly XEventServiceConfiguration configuration;
+        protected readonly ILogger<XBaseEventProducerService> logger;
+
+        protected XBaseEventProducerService(
+            XEventServiceConfiguration configuration,
+            ILogger<XBaseEventProducerService> logger
+        )
+        {
+            //
+            this.logger = logger;
+            this.configuration = configuration;
+
+            //
+            // Validate Configurations ...
+            if (!configuration.IsValid())
+            {
+                XException.InvalidConfiguration.Throw();
+            }
+        }        
+    }
+}

Providers/XEventServiceProvider.cs

@@ -0,0 +1,159 @@
+using System.Threading;
+using xCommons.Extensions;
+using xEventService.Models;
+using xExceptions.Constants;
+using System.Threading.Tasks;
+using xEventService.Constants;
+using xEventService.Extensions;
+using xEventService.Interfaces;
+using xEventService.Configuration;
+
+namespace xEventService.Providers
+{
+    public class XEventServiceProvider : IXEventServiceProvider
+    {
+        //
+        private readonly XEventServiceConfiguration configuration;
+        private readonly IXKafkaProducerService kafkaProducerService;
+        private readonly IXZeroMQProducerService zeroMQProducerService;
+        private readonly IXRabbitMQProducerService rabbitMQProducerService;
+
+        public XEventServiceProvider(
+            XEventServiceConfiguration configuration,
+            IXKafkaProducerService kafkaProducerService = null,
+            IXZeroMQProducerService zeroMQProducerService = null,
+            IXRabbitMQProducerService rabbitMQProducerService = null
+        )
+        {
+            //
+            this.configuration = configuration;
+            this.kafkaProducerService = kafkaProducerService;
+            this.zeroMQProducerService = zeroMQProducerService;
+            this.rabbitMQProducerService = rabbitMQProducerService;
+
+            //
+            // Validate ...
+            var isValid = configuration.IsValid() &&
+                configuration.Broker == XEventBroker.XKafka
+                ? kafkaProducerService != null
+                : configuration.Broker == XEventBroker.XZeroMQ
+                ? zeroMQProducerService != null
+                : configuration.Broker == XEventBroker.XRabbitMQ
+                ? rabbitMQProducerService != null
+                : false;
+            if (!isValid)
+            {
+                XException.InvalidConfiguration.Throw();
+            }
+        }
+
+        /// <summary>
+        /// Send Message to Broker Using XEventRequest instance ...
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<bool> SendMessageAsync(
+            XEventRequest request,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            // Validate ...
+            if (!request.IsValid())
+            {
+                XException.InvalidArgs.Throw();
+            }
+
+            //
+            var result = await SendMessageAsync(
+                topic: request.Topic,
+                message: request.Message,
+                cancellationToken: cancellationToken
+            );
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Send Message to Broker Using XMessage instance ...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="topic"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<bool> SendMessageAsync(
+            XEventMessage message,
+            string topic = XEventServiceConstants.XDefaultTopic,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            // Validate Args ...
+            if (!message.IsValid())
+            {
+                XException.InvalidArgs.Throw();
+            }
+
+            //
+            var result = false;
+            switch (configuration.Broker)
+            {
+                //
+                case XEventBroker.XKafka:
+                    result = await kafkaProducerService.SendMessageAsync(
+                        topic: topic,
+                        message: message,
+                        cancellationToken: cancellationToken
+                    );
+                    break;
+
+                //
+                case XEventBroker.XZeroMQ:
+                    result = await zeroMQProducerService.SendMessageAsync(
+                        topic: topic,
+                        message: message,
+                        cancellationToken: cancellationToken
+                    );
+                    break;
+
+                //
+                case XEventBroker.XRabbitMQ:
+                    result = await rabbitMQProducerService.SendMessageAsync(
+                        topic: topic,
+                        message: message,
+                        cancellationToken: cancellationToken
+                    );
+                    break;
+            }
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Dispose ...
+        /// </summary>
+        public void Dispose()
+        {
+            //
+            if (kafkaProducerService != null)
+            {
+                kafkaProducerService.Dispose();
+            }
+
+            //
+            if (zeroMQProducerService != null)
+            {
+                zeroMQProducerService.Dispose();
+            }
+
+            //
+            if (rabbitMQProducerService != null)
+            {
+                rabbitMQProducerService.Dispose();
+            }
+        }
+    }
+}

Providers/XKafkaConsumerServiceBase.cs

@@ -1,81 +1,49 @@
 using System;
-using System.Threading;
-using System.Threading.Tasks;
 using Confluent.Kafka;
-using Microsoft.Extensions.Hosting;
+using System.Threading;
-using Microsoft.Extensions.Logging;
 using xCommons.Extensions;
-using xEventService.Configuration;
+using xEventService.Models;
+using xExceptions.Constants;
+using System.Threading.Tasks;
 using xEventService.Constants;
 using xEventService.Extensions;
-using xExceptions.Constants;
+using xEventService.Configuration;
+using Microsoft.Extensions.Logging;
 
 namespace xEventService.Providers
 {
     /// <summary>
     /// an Abstract Kafka Consumer Service ...
     /// </summary>
-    public abstract class XKafkaConsumerServiceBase : BackgroundService
+    public abstract class XKafkaConsumerServiceBase : XBaseEventConsumerBackgroundService
     {
-        /// <summary>
-        /// Consumed Topic Messages ...
-        /// </summary>
-        protected readonly string topic;
-
-        /// <summary>
-        /// Check is Paused ...
-        /// </summary>
-        private bool paused = false;
-
-        /// <summary>
-        /// Allowed Senders ...
-        /// </summary>
-        public readonly string[] allowedSenders;
-
-        /// <summary>
-        /// Allowed Actions ...
-        /// </summary>
-        public readonly string[] allowedActions;
-
         /// <summary>
         /// Kafka Consumer Class ...
         /// </summary>
         protected readonly IConsumer<Ignore, string> consumer;
 
-        protected readonly XEventServiceConfiguration configuration;
-
-        protected readonly ILogger<XKafkaConsumerServiceBase> logger;
-
         protected XKafkaConsumerServiceBase(
             string[] allowedActions,
             string[] allowedSenders,
+            IServiceProvider serviceProvider,
             XEventServiceConfiguration configuration,
             ILogger<XKafkaConsumerServiceBase> logger,
             string topic = XEventServiceConstants.XDefaultTopic
+        ) : base(
+            topic: topic,
+            logger: logger,
+            configuration: configuration,
+            allowedActions: allowedActions,
+            allowedSenders: allowedSenders,
+            serviceProvider: serviceProvider
         )
         {
             //
-            this.topic = topic;
+            // Validating Configuration ...
-            this.logger = logger;
+            if (configuration.Broker != XEventBroker.XKafka)
-            this.configuration = configuration;
-
-            //
-            // Validate Actions ...
-            if (!allowedActions
-                .IsAllowedCollection())
             {
-                XException.InvalidArgs.Throw();
+                XException.InvalidConfiguration.Throw();
             }
-            this.allowedActions = [.. allowedActions];
-
-            //
-            // Validate Senders ...
-            if (!allowedSenders
-                .IsAllowedCollection())
-            {
-                XException.InvalidArgs.Throw();
-            }
-            this.allowedSenders = [.. allowedSenders];
 
             //
             // Prepare Kafka Consumer Configuration ...
@@ -89,45 +57,6 @@ namespace xEventService.Providers
             consumer = new ConsumerBuilder<Ignore, string>(config).Build();
         }
 
-
-        /// <summary>
-        /// Pause Consuming ...
-        /// </summary>
-        /// <returns></returns>
-        public bool Pause()
-        {
-            //
-            var result = !paused;
-            if (!result)
-            {
-                return result;
-            }
-
-            //
-            paused = true;
-            result = paused;
-            return result;
-        }
-
-        /// <summary>
-        /// Resume Consuming ...
-        /// </summary>
-        /// <returns></returns>
-        public bool Resume()
-        {
-            //
-            var result = paused;
-            if (!result)
-            {
-                return result;
-            }
-
-            //
-            paused = false;
-            result = !paused;
-            return result;
-        }
-
         /// <summary>
         /// Default Action Execution for Background Services ...
         /// </summary>
@@ -142,103 +71,70 @@ namespace xEventService.Providers
             await Task.Yield();
             using var cts = new CancellationTokenSource();
 
+            //
             // Subscribe to Topic ...
             consumer.Subscribe(topic);
+            logger.LogInformation($"Kafka Cosume Topic: {topic} ...");
 
+            //
             // Consuming ...
             while (!cancellationToken.IsCancellationRequested)
             {
                 try
                 {
+                    //
                     // Consuming Topic ...
-                    await consumer.Consume(async (consumeResult, cancellationToken) =>
+                    var consumeResult = consumer.Consume(cancellationToken);
+                    if (!consumeResult.IsNullOrDefault() &&
+                        !consumeResult.Message.IsNullOrDefault()
+                    )
                     {
-                        // Check Pausing ...
+                        //
-                        if (!paused)
+                        var message = consumeResult
+                            .Message
+                            .Value
+                            .FromJSON<XEventMessage>();
+                        if (message.IsValid(
+                            allowedSenders: allowedSenders,
+                            allowedActions: allowedActions)
+                        )
                         {
-                            // Logging Message Recieved ...
+                            //
-                            if (enableLogging)
+                            await DoWorkAsync(
-                            {
+                                payload: message,
-                                // Encrypt Message ...
+                                cancellationToken: cancellationToken
-                                var expirationOffset = DateTimeOffset.UtcNow
-                                    .AddMinutes(encryptionLifetimeInMinute);
-                                var encryptedMessage = cryptographyService.Encrypt(
-                                    text: consumeResult?.Message.Value ?? string.Empty,
-                                    expirationOffset: expirationOffset
-                                );
-                                logger
-                                    .LogInformation(
-                                        "Consume Recieved Message from Kafka Topic: {Topic}, Offset: {Offset}, Partition: {Partition}, Message: {Message}",
-                                        topic,
-                                        consumeResult?.Offset,
-                                        consumeResult?.Partition,
-                                        encryptedMessage
-                                );
-                            }
-
-                            // Produce Message Model ...
-                            var model = consumeResult
-                                .FillConsumeResult()
-                                    ?? throw RpkKafkaExceptionHelper
-                                        .GetInvalidKafkaConsumeResultException();
-
-                            // Check Sender and Actions Owning ...
-                            var isOwned = model.IsOwned(
-                                allowedActions,
-                                allowedSenders
                             );
-                            if (isOwned)
-                            {
-                                // Notify Extended Classes for Consume Message ...
-                                await ConsumeAsync(
-                                    model,
-                                    cancellationToken
-                                );
-                            }
-
-                            // Commit Offset after Consuming ...
-                            consumer?.Commit(consumeResult);
                         }
-                    },
+                    }
-                    cts.Token);
                 }
                 catch (ConsumeException ex)
                 {
-                    // Log Exception ...
+                    //
-                    if (enableLogging)
+                    logger.LogError($"Kafka Consumer Result Parsing Error: {ex.Message} ...");
-                    {
-                        logger.LogError(
-                            ex,
-                            "Kafka Message Consume Failed: {Error}",
-                            ex.Error.Reason
-                        );
-                    }
                     await Task.Delay(1000, cancellationToken);
                 }
                 catch (Exception ex)
                 {
-                    // Log Exception ...
+                    //
-                    if (enableLogging)
+                    logger.LogError($"Kafka Consumer Result Parsing Error: {ex.Message} ...");
-                    {
-                        logger.LogError(
-                            ex,
-                            "Exception: {Exc}",
-                            ex.Message
-                        );
-                    }
                     await Task.Delay(1000, cancellationToken);
                 }
             }
-        }        
+        }
 
         /// <summary>
-        /// Dispose Implementation ...
+        /// Dispose Object ...
         /// </summary>
         public override void Dispose()
         {
             //
-            consumer.Close();
+            if (consumer != null)
-            consumer.Dispose();
+            {
+                consumer.Close();
+                consumer.Dispose();
+            }
+
+            //
             GC.SuppressFinalize(this);
             base.Dispose();
         }

Providers/XKafkaProducerService.cs

@@ -1,33 +1,27 @@
+using System;
+using Confluent.Kafka;
+using System.Threading;
 using xCommons.Extensions;
+using xEventService.Models;
 using xExceptions.Constants;
+using System.Threading.Tasks;
+using xEventService.Constants;
 using xEventService.Extensions;
 using xEventService.Interfaces;
 using xEventService.Configuration;
-using xEventService.Models;
-using Confluent.Kafka;
 using Microsoft.Extensions.Logging;
-using System.Threading.Tasks;
-using System.Threading;
-using xEventService.Constants;
-using System;
 
 namespace xEventService.Providers
 {
-    public class XKafkaProducerService : IXKafkaProducerService
+    public class XKafkaProducerService : XBaseEventProducerService, IXKafkaProducerService
     {
         private readonly IProducer<Null, string> producer;
-        private readonly ILogger<XKafkaProducerService> logger;
-        private readonly XEventServiceConfiguration configuration;
 
         public XKafkaProducerService(
             ILogger<XKafkaProducerService> logger,
             XEventServiceConfiguration configuration
-        )
+        ) : base(configuration, logger)
         {
-            //
-            this.logger = logger;
-            this.configuration = configuration;
-
             //
             // Validate Configurations ...
             if (!configuration.IsValid() ||
@@ -69,8 +63,8 @@ namespace xEventService.Providers
 
             //
             result = await SendMessageAsync(
-                message: request.Message,
                 topic: request.Topic,
+                message: request.Message,
                 cancellationToken: cancellationToken
             );
 
@@ -115,10 +109,12 @@ namespace xEventService.Providers
                 );
 
                 //
-                result = true;
+                result = !response.IsNullOrDefault();
             }
-            catch
+            catch (Exception ex)
             {
+                //
+                logger.LogError($"Kafka Produce Error: {ex.Message} ...");
                 result = false;
             }
 
@@ -132,7 +128,12 @@ namespace xEventService.Providers
         public void Dispose()
         {
             //
-            producer.Dispose();
+            if (producer != null)
+            {
+                producer.Dispose();
+            }
+
+            //
             GC.SuppressFinalize(this);
         }
     }

Providers/XRabbitMQConsumerServiceBase.cs

@@ -1,50 +1,277 @@
 using System;
-using System.Collections.Generic;
+using System.Text;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
 using RabbitMQ.Client;
+using System.Threading;
 using xCommons.Extensions;
-using xEventService.Configuration;
+using xEventService.Models;
-using xEventService.Extensions;
 using xExceptions.Constants;
+using System.Threading.Tasks;
+using RabbitMQ.Client.Events;
+using xEventService.Constants;
+using xEventService.Extensions;
+using xEventService.Configuration;
+using Microsoft.Extensions.Logging;
 
 namespace xEventService.Providers
 {
     /// <summary>
     /// an Abstract Kafka Consumer Service ...
     /// </summary>
-    public class XRabbitMQConsumerServiceBase : BackgroundService
+    public abstract class XRabbitMQConsumerServiceBase : XBaseEventConsumerBackgroundService
     {
-        protected readonly IModel channel;
+        //
-        protected readonly IConnection connection;
+        protected IModel channel;
-        protected readonly XEventServiceConfiguration configuration;
+        protected IConnection connection;
-        protected readonly ILogger<XRabbitMQConsumerServiceBase> logger;
+        protected AsyncEventingBasicConsumer consumer;
 
-        public XRabbitMQConsumerServiceBase(
+        protected XRabbitMQConsumerServiceBase(
+            string[] allowedActions,
+            string[] allowedSenders,
+            IServiceProvider serviceProvider,
             XEventServiceConfiguration configuration,
-            ILogger<XRabbitMQConsumerServiceBase> logger
+            ILogger<XRabbitMQConsumerServiceBase> logger,
+            string topic = XEventServiceConstants.XDefaultTopic
+        ) : base(
+            topic: topic,
+            logger: logger,
+            configuration: configuration,
+            allowedActions: allowedActions,
+            allowedSenders: allowedSenders,
+            serviceProvider: serviceProvider
         )
         {
             //
-            this.logger = logger;
+            // Validating Configuration ...
-            this.configuration = configuration;
+            if (!configuration.RabbitMQ.IsValid() ||
-
+                configuration.Broker != XEventBroker.XRabbitMQ
-            //
-            // Validate ...
-            if (!configuration.IsValid() ||
-                !configuration.RabbitMQ.IsValid() ||
-                configuration.Broker != Constants.XEventBroker.XRabbitMQ
             )
             {
                 XException.InvalidConfiguration.Throw();
             }
+
+            //
+            SetupConnection();
+            DeclareTopology(topic);
+            consumer = new AsyncEventingBasicConsumer(channel);
         }
-    
+
-        public abstract Task HandleMessageAsync(
+        /// <summary>
-            XEventMessage message,
+        /// Default Action Execution for Background Services ...
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        protected override async Task ExecuteAsync(
             CancellationToken cancellationToken = default
-        );    
+        )
+        {
+            //
+            // For Fix Blocking Synchronous ...
+            await Task.Yield();
+            using var cts = new CancellationTokenSource();
+            logger.LogInformation($"RabbitMQ Cosume Topic: {topic} ...");
+
+            //
+            // Subscribe to Topic ...
+            consumer.Received += async (model, ea) =>
+            {
+                //
+                try
+                {
+                    //
+                    var body = ea.Body.ToArray();
+                    var json = Encoding.UTF8.GetString(body);
+                    var message = json.FromJSON<XEventMessage>();
+                    if (!message.IsNullOrDefault() &&
+                        message.IsValid(
+                        allowedSenders: allowedSenders,
+                        allowedActions: allowedActions)
+                    )
+                    {
+                        //
+                        await DoWorkAsync(
+                            payload: message,
+                            cancellationToken: cancellationToken
+                        );
+                    }
+
+                    //
+                    if (configuration.RabbitMQ.ManualAck)
+                    {
+                        //
+                        channel.BasicAck(
+                            multiple: false,
+                            deliveryTag: ea.DeliveryTag
+                        );
+                    }
+                }
+                catch (Exception ex)
+                {
+                    //
+                    logger.LogError($"RabbitMQ Cosume Error: {ex.Message} ...");
+                    if (configuration.RabbitMQ.ManualAck)
+                    {
+                        //
+                        channel.BasicNack(
+                            requeue: true,
+                            multiple: false,
+                            deliveryTag: ea.DeliveryTag
+                        );
+                    }
+                }
+            };
+
+            //
+            consumer.Shutdown += (model, ea) =>
+            {
+                return Task.CompletedTask;
+            };
+
+            //
+            channel.BasicQos(
+                prefetchSize: 0,
+                global: false,
+                prefetchCount: configuration.RabbitMQ.PrefetchCount
+            );
+
+            //
+            channel.BasicConsume(
+                queue: GetQueueName(),
+                consumer: consumer,
+                autoAck: !configuration.RabbitMQ.ManualAck
+            );
+
+            //
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                await Task.Delay(1000, cancellationToken);
+            }
+        }
+
+        /// <summary>
+        /// Overriding Stop Action ...
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public override async Task StopAsync(CancellationToken cancellationToken)
+        {
+            //
+            if (channel != null)
+            {
+                //
+                channel.Close();
+                channel.Dispose();
+            }
+
+            //
+            if (connection != null)
+            {
+                //
+                connection.Close();
+                connection.Dispose();
+            }
+
+            //
+            await base.StopAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// Dispose Implementation ...
+        /// </summary>
+        public override void Dispose()
+        {
+            //
+            if (channel != null)
+            {
+                channel.Dispose();
+            }
+
+            //
+            if (connection != null)
+            {
+                connection.Dispose();
+            }
+
+            //
+            GC.SuppressFinalize(this);
+            base.Dispose();
+        }
+
+        //
+        #region Private ...
+        private string GetQueueName()
+        {
+            //
+            var result = string.Empty;
+            if (!configuration.RabbitMQ.Queue.IsNullOrEmpty())
+            {
+                result = configuration.RabbitMQ.Queue;
+            }
+
+            //
+            if (result.IsNullOrEmpty())
+            {
+                //
+                var exchangeName = topic ?? configuration.RabbitMQ.Exchange;
+                var digits = Guid.NewGuid().ToString().GetDigits();
+                result = $"{exchangeName}[{digits}]";
+            }
+
+            //
+            return result;
+        }
+
+        private void SetupConnection()
+        {
+            var factory = new ConnectionFactory
+            {
+                DispatchConsumersAsync = true,
+                Port = configuration.GetRabbitMQPort(),
+                HostName = configuration.GetRabbitMQHost(),
+                UserName = configuration.RabbitMQ.Username,
+                Password = configuration.RabbitMQ.Password,
+                NetworkRecoveryInterval = TimeSpan.FromSeconds(
+                    configuration.RabbitMQ.NetworkRecoveryIntervalSeconds
+                ),
+                VirtualHost = configuration.RabbitMQ.VirtualHost,
+                AutomaticRecoveryEnabled = configuration.RabbitMQ.AutomaticRecoveryEnabled,
+            };
+
+            //
+            connection = factory.CreateConnection();
+            channel = connection.CreateModel();
+        }
+
+        private void DeclareTopology(string topic)
+        {
+            //
+            channel.ExchangeDeclare(
+                arguments: null,
+                exchange: topic ?? configuration.RabbitMQ.Exchange,
+                durable: configuration.RabbitMQ.ExchangeDurable,
+                autoDelete: configuration.RabbitMQ.ExchangeAutoDelete,
+                type: configuration.RabbitMQ.ExchangeType.GetStringValue()
+            );
+
+            //
+            var queueName = GetQueueName();
+
+            //
+            channel.QueueDeclare(
+                arguments: null,
+                queue: queueName,
+                durable: configuration.RabbitMQ.QueueDurable,
+                exclusive: configuration.RabbitMQ.QueueExclusive,
+                autoDelete: configuration.RabbitMQ.QueueAutoDelete
+            );
+
+            //
+            channel.QueueBind(
+                arguments: null,
+                queue: queueName,
+                exchange: topic ?? configuration.RabbitMQ.Exchange,
+                routingKey: configuration.RabbitMQ.RoutingKey
+            );
+        }
+        #endregion
     }
 }

Providers/XRabbitMQProducerService.cs

@@ -1,39 +1,33 @@
 using System;
 using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
 using RabbitMQ.Client;
+using System.Threading;
 using xCommons.Extensions;
-using xEventService.Configuration;
+using xEventService.Models;
+using xExceptions.Constants;
+using System.Threading.Tasks;
 using xEventService.Constants;
 using xEventService.Extensions;
 using xEventService.Interfaces;
-using xEventService.Models;
+using xEventService.Configuration;
-using xExceptions.Constants;
+using Microsoft.Extensions.Logging;
 
 namespace xEventService.Providers
 {
     /// <summary>
     /// RabbitMQ Producer Service Implementation ...
     /// </summary>
-    public class XRabbitMQProducerService : IXRabbitMQProducerService
+    public class XRabbitMQProducerService : XBaseEventProducerService, IXRabbitMQProducerService
     {
         private IModel channel;
         private IConnection connection;
         private readonly object connectionLock = new();
-        private readonly ILogger<XRabbitMQProducerService> logger;
-        private readonly XEventServiceConfiguration configuration;
 
         public XRabbitMQProducerService(
             ILogger<XRabbitMQProducerService> logger,
             XEventServiceConfiguration configuration
-        )
+        ) : base(configuration, logger)
         {
-            //
-            this.logger = logger;
-            this.configuration = configuration;
-
             //
             // Validate Configurations ...
             if (!configuration.IsValid() ||
@@ -52,6 +46,9 @@ namespace xEventService.Providers
         /// <summary>
         /// Sending Message with Full Request Descriptor ...
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
         public async Task<bool> SendMessageAsync(
             XEventRequest request,
             CancellationToken cancellationToken = default
@@ -77,9 +74,41 @@ namespace xEventService.Providers
             return result;
         }
 
+        /// <summary>
+        /// Sending a Message to Topic ...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="topic"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<bool> SendMessageAsync(
+            XEventMessage message,
+            string topic = XEventServiceConstants.XDefaultTopic,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            var result = await SendMessageAsync(
+                request: new XEventRequest
+                {
+                    Topic = topic,
+                    Message = message
+                },
+                cancellationToken: cancellationToken
+            );
+
+            //
+            return result;
+        }
+
         /// <summary>
         /// Sending a Message to Exchange ...
         /// </summary>
+        /// <param name="message"></param>
+        /// <param name="exchange"></param>
+        /// <param name="routingKey"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
         public async Task<bool> SendMessageAsync(
             XEventMessage message,
             string exchange = null,
@@ -114,7 +143,7 @@ namespace xEventService.Providers
             {
                 //
                 // Ensure Connection is Alive ...
-                await EnsureChannelAsync(cancellationToken);
+                EnsureChannel();
 
                 //
                 // Serialize Message ...
@@ -152,8 +181,10 @@ namespace xEventService.Providers
                 //
                 result = true;
             }
-            catch
+            catch (Exception ex)
             {
+                //
+                logger.LogError($"RabbitMQ Produce Error: {ex.Message} ...");
                 result = false;
             }
 
@@ -170,14 +201,22 @@ namespace xEventService.Providers
             try
             {
                 //
-                channel.Close();
+                if (channel != null)
-                channel.Dispose();
+                {
-                channel = null;
+                    //
+                    channel.Close();
+                    channel.Dispose();
+                    channel = null;
+                }
 
                 //
-                connection.Close();
+                if (connection != null)
-                connection.Dispose();
+                {
-                connection = null;
+                    //
+                    connection.Close();
+                    connection.Dispose();
+                    connection = null;
+                }
             }
             catch
             { }
@@ -228,29 +267,10 @@ namespace xEventService.Providers
             return result;
         }
 
-        /// <summary>
-        /// Ensure Connection Established ...
-        /// </summary>
-        public async Task<bool> EnsureConnectionAsync()
-        {
-            //
-            try
-            {
-                await EnsureChannelAsync();
-                return true;
-            }
-            catch
-            {
-                return false;
-            }
-        }
-
         /// <summary>
         /// Ensure Channel is Open and Exchange/Queue Declared ...
         /// </summary>
-        private async Task EnsureChannelAsync(
+        private void EnsureChannel()
-            CancellationToken cancellationToken = default
-        )
         {
             //
             if (IsConnected())
@@ -289,9 +309,6 @@ namespace xEventService.Providers
                     type: configuration.RabbitMQ.ExchangeType.GetStringValue()
                 );
             }
-
-            //
-            await Task.CompletedTask;
         }
         #endregion
     }

Providers/XZeroMQConsumerServiceBase.cs

@@ -0,0 +1,206 @@
+using NetMQ;
+using System;
+using System.Text;
+using NetMQ.Sockets;
+using System.Threading;
+using xCommons.Extensions;
+using xEventService.Models;
+using xExceptions.Constants;
+using System.Threading.Tasks;
+using xEventService.Constants;
+using xEventService.Extensions;
+using xEventService.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace xEventService.Providers
+{
+    /// <summary>
+    /// an Abstract ZeroMQ Consumer Service ...
+    /// </summary>
+    public abstract class XZeroMQConsumerServiceBase : XBaseEventConsumerBackgroundService
+    {
+        //
+        private NetMQSocket socket;
+
+        protected XZeroMQConsumerServiceBase(
+            string[] allowedActions,
+            string[] allowedSenders,
+            IServiceProvider serviceProvider,
+            XEventServiceConfiguration configuration,
+            ILogger<XZeroMQConsumerServiceBase> logger,
+            string topic = XEventServiceConstants.XDefaultTopic
+        ) : base(
+            topic: topic,
+            logger: logger,
+            configuration: configuration,
+            allowedActions: allowedActions,
+            allowedSenders: allowedSenders,
+            serviceProvider: serviceProvider
+        )
+        {
+            //
+            // Validating Configuration ...
+            if (!configuration.ZeroMQ.IsValid() ||
+                configuration.Broker != XEventBroker.XZeroMQ)
+            {
+                XException.InvalidConfiguration.Throw();
+            }
+
+            //
+            // Initialize ...
+            InitializeSocket();
+        }
+
+        /// <summary>
+        /// Default Action Execution for Background Services ...
+        /// </summary>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        protected override async Task ExecuteAsync(
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            await Task.Yield();
+            logger.LogInformation($"ZeroMQ Cosume Topic: {topic} ...");
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                //
+                try
+                {
+                    //
+                    string receivedTopic = string.Empty;
+                    byte[] body = null;
+
+                    //
+                    if (configuration.ZeroMQ.Pattern == XZeroMQPattern.PubSub)
+                    {
+                        //
+                        if (socket.TryReceiveFrameString(TimeSpan.FromMilliseconds(100), out receivedTopic))
+                        {
+                            // 
+                            if (socket.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(100), out body))
+                            {
+                                // Process
+                            }
+                            else
+                            {
+                                logger.LogError($"ZeroMQ Cosume Error ...");
+                            }
+                        }
+                    }
+                    else
+                    {
+                        if (socket.TryReceiveFrameBytes(TimeSpan.FromMilliseconds(100), out body))
+                        {
+                            // Process
+                        }
+                        else
+                        {
+                            logger.LogError($"ZeroMQ Cosume Error ...");
+                        }
+                    }
+
+                    //
+                    if (body != null && body.Length > 0)
+                    {
+                        //
+                        var json = Encoding.UTF8.GetString(body);
+                        var message = json.FromJSON<XEventMessage>();
+                        if (!message.IsNullOrDefault() &&
+                            message.IsValid(
+                            allowedSenders: allowedSenders,
+                            allowedActions: allowedActions)
+                        )
+                        {
+                            //
+                            await DoWorkAsync(
+                                payload: message,
+                                cancellationToken: cancellationToken
+                            );
+                        }
+                    }
+                    else
+                    {
+                        await Task.Delay(10, cancellationToken);
+                    }
+                }
+                catch (Exception ex)
+                {
+                    //
+                    logger.LogError($"ZeroMQ Cosume Error: {ex.Message} ...");
+                    await Task.Delay(1000, cancellationToken);
+                }
+            }
+        }
+
+        public override async Task StopAsync(CancellationToken cancellationToken)
+        {
+            //
+            if (socket != null)
+            {
+                socket.Close();
+            }
+
+            //
+            await base.StopAsync(cancellationToken);
+        }
+
+        /// <summary>
+        /// Dispose Object ...
+        /// </summary>
+        public override void Dispose()
+        {
+            //
+            if (socket != null)
+            {
+                socket.Dispose();
+            }
+
+            //
+            GC.SuppressFinalize(this);
+            base.Dispose();
+        }
+
+        //
+        #region Private ...
+        private void InitializeSocket()
+        {
+            //
+            if (configuration.ZeroMQ.Pattern == XZeroMQPattern.PubSub)
+            {
+                //
+                socket = new SubscriberSocket();
+                socket.Options.ReceiveHighWatermark = configuration.ZeroMQ.ReceiveHighWaterMark;
+
+                //  
+                // Subscribe to specific topic or all
+                if (topic.IsNullOrEmpty() || topic == XEventServiceConstants.XWildcard)
+                {
+                    ((SubscriberSocket)socket).SubscribeToAnyTopic();
+                }
+                else
+                {
+                    ((SubscriberSocket)socket).Subscribe(topic);
+                }
+            }
+            else
+            {
+                //
+                socket = new PullSocket();
+                socket.Options.ReceiveHighWatermark = configuration.ZeroMQ.ReceiveHighWaterMark;
+            }
+
+            //
+            if (configuration.ZeroMQ.IsServer)
+            {
+                socket.Bind(configuration.Url);
+            }
+            else
+            {
+                socket.Connect(configuration.Url);
+            }
+        }
+        #endregion
+    }
+}

Providers/XZeroMQProducerService.cs

@@ -0,0 +1,198 @@
+using NetMQ;
+using System;
+using System.Text;
+using NetMQ.Sockets;
+using System.Threading;
+using xCommons.Extensions;
+using xEventService.Models;
+using xExceptions.Constants;
+using System.Threading.Tasks;
+using xEventService.Constants;
+using xEventService.Extensions;
+using xEventService.Interfaces;
+using xEventService.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace xEventService.Providers
+{
+    public class XZeroMQProducerService : XBaseEventProducerService, IXZeroMQProducerService
+    {
+        //
+        private NetMQSocket socket;
+        private readonly object socketLock = new();
+
+        public XZeroMQProducerService(
+            XEventServiceConfiguration configuration,
+            ILogger<XZeroMQProducerService> logger
+        ) : base(configuration, logger)
+        {
+            //
+            // Validate Configurations ...
+            if (!configuration.IsValid() ||
+                !configuration.ZeroMQ.IsValid() ||
+                configuration.Broker != XEventBroker.XZeroMQ
+            )
+            {
+                XException.InvalidConfiguration.Throw();
+            }
+
+            //
+            InitializeSocket();
+        }
+
+        /// <summary>
+        /// Sending Message with Full Request Descriptor ...
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<bool> SendMessageAsync(
+            XEventRequest request,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            var result = request.IsValid();
+            if (!result)
+            {
+                XException.InvalidArgs.Throw();
+            }
+
+            //
+            result = await SendMessageAsync(
+                message: request.Message,
+                topic: request.Topic,
+                cancellationToken: cancellationToken
+            );
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Sending a Message to Topic ...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <param name="topic"></param>
+        /// <param name="cancellationToken"></param>
+        /// <returns></returns>
+        public async Task<bool> SendMessageAsync(
+            XEventMessage message,
+            string topic = XEventServiceConstants.XDefaultTopic,
+            CancellationToken cancellationToken = default
+        )
+        {
+            //
+            var result = message.IsValid();
+            if (!result)
+            {
+                XException.InvalidArgs.Throw();
+            }
+
+            //
+            // Normalize Topic ...
+            if (topic.IsNullOrEmpty())
+            {
+                topic = XEventServiceConstants.XDefaultTopic;
+            }
+
+            //
+            try
+            {
+                //
+                var json = message.ToJSON(camelCase: true);
+                var body = Encoding.UTF8.GetBytes(json);
+                await Task.Run(() =>
+                {
+                    //
+                    lock (socketLock)
+                    {
+                        //
+                        if (configuration.ZeroMQ.Pattern == XZeroMQPattern.PubSub)
+                        {
+                            socket.SendMoreFrame(topic).SendFrame(body);
+                        }
+                        else
+                        {
+                            socket.SendFrame(body);
+                        }
+                    }
+                }, cancellationToken);
+
+                //
+                result = true;
+            }
+            catch (Exception)
+            {
+                result = false;
+            }
+
+            //
+            return result;
+        }
+
+        /// <summary>
+        /// Dispose Object ...
+        /// </summary>
+        public void Dispose()
+        {
+            //
+            try
+            {
+                //
+                lock (socketLock)
+                {
+                    //
+                    if (socket != null)
+                    {
+                        //
+                        socket.Close();
+                        socket.Dispose();
+                        socket = null;
+                    }
+                }
+            }
+            catch { }
+
+            //
+            GC.SuppressFinalize(this);
+        }
+
+        //
+        #region Private ...
+        /// <summary>
+        /// Initialize Socket ...
+        /// </summary>
+        private void InitializeSocket()
+        {
+            //
+            lock (socketLock)
+            {
+                //
+                if (configuration.ZeroMQ.Pattern == XZeroMQPattern.PubSub)
+                {
+                    //
+                    socket = new PublisherSocket();
+                    socket.Options.SendHighWatermark = configuration.ZeroMQ.SendHighWaterMark;
+                }
+                else
+                {
+                    //
+                    socket = new PushSocket();
+                    socket.Options.SendHighWatermark = configuration.ZeroMQ.SendHighWaterMark;
+                }
+
+                //
+                if (configuration.ZeroMQ.IsServer)
+                {
+                    socket.Bind(configuration.Url);
+                }
+                else
+                {
+                    socket.Connect(configuration.Url);
+                }
+            }
+        }
+        #endregion
+    }
+}

xEventService.csproj

@@ -35,15 +35,16 @@
 
   <!-- Dependencies -->
   <ItemGroup>
+    <PackageReference Include="NetMQ" Version="4.0.4.3" />
     <PackageReference Include="RabbitMQ.Client" Version="6.2.2" />
     <PackageReference Include="Confluent.Kafka" Version="2.14.2" />
   </ItemGroup>
 
   <!-- For XML Documentation Support -->
   <PropertyGroup>
-    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <NoWarn>$(NoWarn);1591</NoWarn>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
   </PropertyGroup>
 
 </Project>