Initial Commit ...

Models/XChannel.cs

@@ -0,0 +1,224 @@
+using System;
+using RabbitMQ.Client;
+using RabbitMQ.Client.Events;
+using xCommons.Extensions;
+using xEventService.Configuration;
+using xEventService.Extensions;
+using xExceptions.Constants;
+
+namespace xEventService.Models {
+    public class XChannel {
+        //
+        public IModel Channel { get; protected set; }
+        public string QueueName { get; protected set; }
+        public string ExchangeName { get; protected set; }
+        public IConnection Connection { get; protected set; }
+
+        //
+        #region Constructors ...
+        public XChannel (
+            string exchangeName = null,
+            IConnection connection = null,
+            IModel channel = null,
+            EventingBasicConsumer consumer = null
+        ) {
+            //
+            // Validate Connection ...
+            if (connection.IsNull ()) {
+                XException.InvalidArgs.Throw ();
+            }
+            Connection = connection;
+
+            //
+            // Validate Channel ...
+            if (channel.IsNull ()) {
+                channel = connection.CreateModel ();
+            }
+            Channel = channel;
+
+            //
+            // Check Queue Name and it's Declaration ...
+            if (!exchangeName.IsNullOrEmpty ()) {
+                //
+                ExchangeName = exchangeName;
+            }
+        }
+
+        public XChannel (
+            XEventServiceConfiguration configuration,
+            bool dispatchConsumersAsync = true,
+            string exchangeName = null
+        ) {
+            //
+            // Generate Factory ...
+            var factory = configuration.GetConnectionFactory ();
+            if (dispatchConsumersAsync) {
+                factory.DispatchConsumersAsync = true;
+            }
+
+            //
+            // Create Cahnnel ...
+            Connection = factory.CreateConnection ();
+            Channel = Connection.CreateModel ();
+
+            //
+            // Check Exchange Declaration if provided ...
+            if (!exchangeName.IsNullOrEmpty ()) {
+                //
+                ExchangeName = exchangeName;
+                var exchangeArgs = configuration.GetExchangeArgs (ExchangeName);
+
+                //
+                // Declaring Exchange ...
+                Channel.ExchangeDeclare (
+                    exchange: exchangeName,
+                    type: exchangeArgs.Type,
+                    durable: exchangeArgs.Durable,
+                    autoDelete: exchangeArgs.AutoDelete
+                );
+
+                //
+                // Create a Queue ...
+                var queueName = $"{exchangeName}[{Guid.NewGuid().ToString().GetDigits()}]";
+                var queueArgs = configuration.GetQueueArgs (queueName);
+                QueueName = queueName;
+                Channel.QueueDeclare (
+                    queue: queueName,
+                    durable: queueArgs.Durable,
+                    exclusive: queueArgs.Exclusive,
+                    autoDelete: queueArgs.AutoDelete
+                );
+
+                //
+                // Bind Queue to Exchange ...
+                Channel.QueueBind (
+                    queue: queueName,
+                    exchange: exchangeName,
+                    routingKey: ""
+                );
+            }
+        }
+        #endregion
+
+        //
+        #region Actions ...
+        /// <summary>
+        /// Close Channel ...
+        /// </summary>
+        public void CloseChannel () {
+            //
+            // Check Channel Exists ...
+            if (!this.Channel.IsNull ()) {
+                //
+                // Close Channel if it's Open ...
+                if (this.Channel.IsOpen) {
+                    this.Channel.Close ();
+                }
+
+                //
+                this.Channel.Dispose ();
+                this.Channel = null;
+            }
+        }
+
+        /// <summary>
+        /// Close Connection ...
+        /// </summary>
+        public void CloseConnection () {
+            //
+            // Check Connection Exists ...
+            if (!this.Connection.IsNull ()) {
+                //
+                // Close Connection if it's Open ...
+                if (this.Connection.IsOpen) {
+                    this.Connection.Close ();
+                }
+
+                //
+                this.Connection.Dispose ();
+                this.Connection = null;
+            }
+        }
+
+        /// <summary>
+        /// Publish a Message through Channel on Declare Queue ...
+        /// </summary>
+        /// <param name="message"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        public bool Publish<T> (T message) {
+            //
+            // Validate Args ...
+            if (this.Connection.IsNull () ||
+                !this.Connection.IsOpen ||
+                this.Channel.IsNull () ||
+                !this.Channel.IsOpen) {
+                //
+                Console.WriteLine ($"XEventService Exception: Publish Failed ...");
+
+                //
+                XException.InvalidArgs.Throw ();
+            }
+
+            //
+            // Check Publish Method ...
+            //
+            // Check Exchange Name ...
+            if (this.ExchangeName.IsNullOrEmpty ()) {
+                //
+                Console.WriteLine ($"XEventService Exception: Publish Failed, Invalid Exchange Name {ExchangeName} ...");
+
+                //
+                XException.InvalidArgs.Throw ();
+            }
+
+            //
+            try {
+                //
+                // Publish Message through Channel to Declared Queue ...
+                var body = message.ToBody ();
+                this.Channel.BasicPublish (
+                    exchange: ExchangeName,
+                    routingKey: "",
+                    basicProperties : null,
+                    body : body
+                );
+
+                //
+                return true;
+            } catch (Exception ex) {
+                //
+                Console.WriteLine ($"XEventService Exception: Publish Failed, {ex.Message} ...");
+
+                //
+                return false;
+            }
+        }
+
+        public void Consume (EventingBasicConsumer consumer) {
+            Channel.BasicConsume (
+                queue: QueueName,
+                autoAck: true,
+                consumer: consumer
+            );
+        }
+
+        public void ConsumeAsync (AsyncEventingBasicConsumer consumer) {
+            Channel.BasicConsume (
+                queue: QueueName,
+                autoAck: true,
+                consumer: consumer
+            );
+        }
+
+        /// <summary>
+        /// Dispose XChannel ...
+        /// </summary>
+        public void Dispose () {
+            //
+            this.CloseChannel ();
+            this.CloseConnection ();
+        }
+        #endregion        
+    }
+}

Models/XEvent.cs

@@ -0,0 +1,5 @@
+using xEventService.Base;
+
+namespace xEventService.Models {
+    public class XEvent : XBaseEvent { }
+}