protected virtual async Task ExecuteMessageHandlerAsync(
            EventArgs messageEventArgs,
            ReceivedItemHandlerAsyncDelegate receivedItemHandlerAsyncDelegateFunc,
            bool automaticFinalizationEnabled = true
            )
        {
            messageEventArgs.AssertNotNull(nameof(messageEventArgs));
            receivedItemHandlerAsyncDelegateFunc.AssertNotNull(nameof(receivedItemHandlerAsyncDelegateFunc));

            AzureServiceBusReceivedItem <TUniqueIdentifier, TPayload> azureServiceBusReceivedItem = null;

            //FIRST attempt to convert the Message into an AzureServiceBus Received Item....
            try
            {
                //Initialize the MessageHandler facade for processing the Azure Service Bus message...
                azureServiceBusReceivedItem = await CreateReceivedItemAsync(
                    messageEventArgs,
                    //Force Dead-lettering if there is any issue with initialization!
                    true
                    ).AssertNotNull(nameof(azureServiceBusReceivedItem));
            }
            catch (Exception exc)
            {
                var messageException = new Exception("The message could not be correctly initialized due to unexpected exception." +
                                                     " It must be Dead lettered to prevent blocking of the Service Bus as it will never be" +
                                                     " processed successfully.", exc);

                this.Options.ErrorHandlerCallback?.Invoke(messageException);
            }

            //IF the Received Item is successfully initialized then process it!
            if (azureServiceBusReceivedItem != null)
            {
                try
                {
                    //Execute the delegate to handle/process the published item...
                    await receivedItemHandlerAsyncDelegateFunc(azureServiceBusReceivedItem).ConfigureAwait(false);

                    //If necessary, we need to Finalize the item with Azure Service Bus (Complete/Abandon) based on the Status returned on the item!
                    if (automaticFinalizationEnabled && !azureServiceBusReceivedItem.IsStatusFinalized)
                    {
                        await azureServiceBusReceivedItem.SendFinalizedStatusToAzureServiceBusAsync().ConfigureAwait(false);
                    }
                }
                catch (Exception exc)
                {
                    this.Options.ErrorHandlerCallback?.Invoke(exc);

                    //Always attempt to Reject/Abandon the message if any unhandled exceptions are thrown...
                    if (!azureServiceBusReceivedItem.IsStatusFinalized)
                    {
                        //Finalize the status as set by the Delegate function if it's not already Finalized!
                        //NOTE: We ALWAYS do this even if autoMessageFinalizationEnabled is false to prevent BLOCKING and risk of Infinite Loops...
                        await azureServiceBusReceivedItem.SendFinalizedStatusToAzureServiceBusAsync().ConfigureAwait(false);
                    }
                }
            }
        }
        protected virtual async Task StartReceivingInternalAsync(
            ReceivedItemHandlerAsyncDelegate receivedItemHandlerAsyncDelegateFunc,
            bool autoMessageFinalizationEnabled = true,
            CancellationToken cancellationToken = default
            )
        {
            //Ensure we are set to have started Processing...
            this.IsProcessing = true;

            //Validate handler and other references...
            receivedItemHandlerAsyncDelegateFunc.AssertNotNull(nameof(receivedItemHandlerAsyncDelegateFunc));

            //Complete full Handler Initialization with provided options, etc...
            //NOTE: IF FIFO Processing is enabled we use Azure Session Processor; otherwise default Processor is used.
            if (Options.FifoEnforcedReceivingEnabled)
            {
                if (this.ServiceBusSessionProcessor == null)
                {
                    this.ServiceBusSessionProcessor = GetAzureServiceBusSessionProcessor();

                    this.ServiceBusSessionProcessor.ProcessMessageAsync += async(messageEventArgs) =>
                    {
                        await ExecuteMessageHandlerAsync(
                            //Note: We Must use the MessageSession as the Client for processing messages with the Locked Session!
                            messageEventArgs,
                            receivedItemHandlerAsyncDelegateFunc,
                            autoMessageFinalizationEnabled
                            ).ConfigureAwait(false);
                    };

                    //Wire up the Error/Exception Handler...
                    this.ServiceBusSessionProcessor.ProcessErrorAsync += ExceptionReceivedHandlerAsync;
                }

                //Kick off processing!!!
                if (!this.ServiceBusSessionProcessor.IsProcessing)
                {
                    await this.ServiceBusSessionProcessor.StartProcessingAsync(cancellationToken);
                }
            }
            else
            {
                if (this.ServiceBusProcessor == null)
                {
                    this.ServiceBusProcessor = GetAzureServiceBusProcessor();

                    //Wire up the Handler...
                    this.ServiceBusProcessor.ProcessMessageAsync += async(messageEventArgs) =>
                    {
                        await ExecuteMessageHandlerAsync(
                            messageEventArgs,
                            receivedItemHandlerAsyncDelegateFunc,
                            autoMessageFinalizationEnabled
                            ).ConfigureAwait(false);
                    };

                    //Wire up the Error/Exception Handler...
                    this.ServiceBusProcessor.ProcessErrorAsync += ExceptionReceivedHandlerAsync;
                }

                //Kick off processing!!!
                if (!this.ServiceBusProcessor.IsProcessing)
                {
                    await this.ServiceBusProcessor.StartProcessingAsync(cancellationToken);
                }
            }
        }