/// <summary>
        /// Executes the Service Object method and returns any data.
        /// </summary>
        /// <param name="inputs">A Property[] array containing all the allowed input properties.</param>
        /// <param name="required">A RequiredProperties collection containing the required properties.</param>
        /// <param name="returns">A Property[] array containing all the allowed return properties.</param>
        /// <param name="methodType">A MethoType indicating what type of Service Object method was called.</param>
        /// <param name="serviceObject">A ServiceObject containing populated properties for use with the method call.</param>
        public void Execute(Property[] inputs, RequiredProperties required, Property[] returns, MethodType methodType, ServiceObject serviceObject)
        {
            //serviceObject.Properties.InitResultTable();
            //Utilities.ServiceUtilities serviceUtils = new Utilities.ServiceUtilities(serviceBroker);
            //TokenProvider tp = serviceUtils.GetTokenProvider();
            //Uri uri = serviceUtils.GetServiceUri();

            #region Queue

            #region Load Queue

            if (serviceObject.Methods[0].Name.Equals("loadqueue"))
            {
                ASBQueue Queue = new ASBQueue(serviceBroker);
                Queue.LoadQueue(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Load Queue

            #region List Queues

            if (serviceObject.Methods[0].Name.Equals("listqueues"))
            {
                ASBQueue Queue = new ASBQueue(serviceBroker);
                Queue.ListQueues(inputs, required, returns, methodType, serviceObject);
            }
            #endregion List Queues

            #region Create Queue

            if (serviceObject.Methods[0].Name.Equals("createqueue") || serviceObject.Methods[0].Name.Equals("createqueuefulldetails"))
            {
                ASBQueue Queue = new ASBQueue(serviceBroker);
                Queue.CreateQueues(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Create Queue

            #region Delete Queue

            if (serviceObject.Methods[0].Name.Equals("deletequeue"))
            {
                ASBQueue Queue = new ASBQueue(serviceBroker);
                Queue.DeleteQueues(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Delete Queue


            #endregion Queue

            #region Topic

            #region Load Topic
            if (serviceObject.Methods[0].Name.Equals("loadtopic"))
            {
                ASBTopic Topic = new ASBTopic(serviceBroker);
                Topic.LoadTopic(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Load Topic

            #region List Topics

            if (serviceObject.Methods[0].Name.Equals("listtopics"))
            {
                ASBTopic Topic = new ASBTopic(serviceBroker);
                Topic.ListTopics(inputs, required, returns, methodType, serviceObject);
            }
            #endregion List Topic

            #endregion Topic

            #region Subscription

            #region Load Subscription

            if (serviceObject.Methods[0].Name.Equals("loadsubscription"))
            {
                ASBSubscription Subscription = new ASBSubscription(serviceBroker);
                Subscription.LoadSubscription(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Load Subscription

            #region List Subscriptions

            if (serviceObject.Methods[0].Name.Equals("listsubscriptions"))
            {
                ASBSubscription Subscription = new ASBSubscription(serviceBroker);
                Subscription.ListSubscriptions(inputs, required, returns, methodType, serviceObject);
            }
            #endregion List Subscriptions

            #endregion Subscription


            #region Event Hub

            #region Send Event Hub Message

            if (serviceObject.Methods[0].Name.Equals("sendeventhubmessage"))
            {
                ASBEventHub EventHub = new ASBEventHub(serviceBroker);
                EventHub.SendEventHubMessage(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Send Event Hub Message

            #region Load Event Hub

            if (serviceObject.Methods[0].Name.Equals("loadeventhub"))
            {
                ASBEventHub EventHub = new ASBEventHub(serviceBroker);
                EventHub.LoadEventHub(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Load Event Hub

            #region List Event Hub

            if (serviceObject.Methods[0].Name.Equals("listeventhubs"))
            {
                ASBEventHub EventHub = new ASBEventHub(serviceBroker);
                EventHub.ListEventHubs(inputs, required, returns, methodType, serviceObject);
            }
            #endregion List Event Hub

            #region Create Event Hub

            if (serviceObject.Methods[0].Name.Equals("createeventhub") || serviceObject.Methods[0].Name.Equals("createeventhubfulldetails"))
            {
                ASBEventHub EventHub = new ASBEventHub(serviceBroker);
                EventHub.CreateEventHubs(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Create Event Hub

            #region Delete Event Hub

            if (serviceObject.Methods[0].Name.Equals("deleteeventhub"))
            {
                ASBEventHub EventHub = new ASBEventHub(serviceBroker);
                EventHub.DeleteEventHubs(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Delete Event Hub


            #endregion Event Hub


            #region Send Message

            if (serviceObject.Methods[0].Name.Equals("sendmessage", StringComparison.OrdinalIgnoreCase) || serviceObject.Methods[0].Name.Equals("sendmessageasstring", StringComparison.OrdinalIgnoreCase))
            {
                ASBMessage Message = new ASBMessage(serviceBroker);
                Message.SendMessage(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Send Message

            #region Receive Message

            // receive message from queue
            // message will be completed and removed from queue
            if (serviceObject.Methods[0].Name.Equals("receivemessage") || serviceObject.Methods[0].Name.Equals("peeklockmessage") || serviceObject.Methods[0].Name.Equals("receivepeeklockmessage"))
            {
                ASBMessage Message = new ASBMessage(serviceBroker);
                Message.ReceiveMessage(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Receive Message

            #region Deadletter Message
            if (serviceObject.Methods[0].Name.Equals("deadlettermessage"))
            {
                ASBMessage Message = new ASBMessage(serviceBroker);
                Message.DeadLetterMessage(inputs, required, returns, methodType, serviceObject);
            }
            #endregion Deadletter Message


            #region Abandon Message

            if (serviceObject.Methods[0].Name.Equals("abandonmessage"))
            {
                ASBMessage Message = new ASBMessage(serviceBroker);
                Message.AbandonMessage(inputs, required, returns, methodType, serviceObject);
            }

            #endregion Abandon Message


            #region Receive Session Message
            if (serviceObject.Methods[0].Name.Equals("receivesessionmessage"))
            {
                ASBMessage Message = new ASBMessage(serviceBroker);
                Message.ReceiveSessionMessage(inputs, required, returns, methodType, serviceObject);
            }
            #endregion Receive Session Message


            #region Receive Session Messages

            #endregion Receive Session Messages
        }