public static void WriteEnabledDisabledFunctions(ConfigurationDto objConfiguration)
        {
            var allConfiguration = new ConfigurationManager().LoadInitialConfiguration();

            if (!object.ReferenceEquals(allConfiguration, null))
            {
                RegisterLogFacade(string.Format("ScriptRunner is: [{0}] \n",
                    allConfiguration.ScripRunnerSettings.IsEnabled ?
                    "Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
                    EnumNLogStruct.LogType.Info, true);

                RegisterLogFacade(string.Format("IIS Recycler is: [{0}] \n",
                    allConfiguration.IISRecyclerConfiguration.IsEnabled ?
                    "Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
                    EnumNLogStruct.LogType.Info, true);

                RegisterLogFacade(string.Format("IIS Restarter is: [{0}] \n",
                    allConfiguration.IISRestarterConfiguration.IsEnabled ?
                    "Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
                    EnumNLogStruct.LogType.Info, true);

                RegisterLogFacade(string.Format("Event Log Manager is: [{0}] \n",
                    allConfiguration.EventLogManager.IsEnabled ?
                    "Enabled" : "Disabled"), EnumNLogStruct.TypeOfRegister.All,
                    EnumNLogStruct.LogType.Info, true);

            }

        }
        /// <summary>
        /// Main Task Runner
        /// </summary>
        static void TaskRunner(ConfigurationDto objConfiguration)
        {

            IExecutionable objPlayer = null;

            if (!object.ReferenceEquals(objConfiguration, null))
            {   
                objPlayer = new CoreContainer().GetAnyInstance<IExecutionable>();

                if (!object.ReferenceEquals(objPlayer, null))
                {
                    LogAndConsoleTracker.RegisterLogFacade("Starting Executing features and functions that are enabled... \n",
                        transversal.dto.Enums.Nlog.EnumNLogStruct.TypeOfRegister.All,
                        transversal.dto.Enums.Nlog.EnumNLogStruct.LogType.Info, false);

                }   

            }


            
            


        }   
        public void ExecuteFeaturesThatAreEnabled(ConfigurationDto objConfiguration)
        {

        }
        public void ExecuteEventLogFunctions(ConfigurationDto objConfiguration)
        {

        }
        public void ExecuteIISRecyclerFunctions(ConfigurationDto objConfiguration)
        {

        }
        public void ExecuteScriptRunnerFunctions(ConfigurationDto objConfiguration)
        {

        }
        private static void RegisterNLogOnly(string message, ConfigurationDto objConfiguration, EnumNLogStruct.LogType typeOfLog)
        {
            var finalMessage = BuildLogInfoWithConfigurationInformation(objConfiguration, false);


            if (!object.ReferenceEquals(objConfiguration, null))
            {
                if (object.ReferenceEquals(objLogger, null))
                {
                    objLogger = new LogManagerContainer().GetAnyInstance<ILoggerConfigurable<Logger>>();
                }

                objLogger.RegisterLogWithCustomInfo(typeOfLog, new LogVo()
                {
                    CustomMessage = string.Concat(finalMessage, message),
                    CustomType    = typeOfLog
                });

            }
        }
        public static string BuildLogInfoWithConfigurationInformation(ConfigurationDto objConfiguration, bool WithAppendLine)
        {
            var objBuilder = default(StringBuilder);

            if (!object.ReferenceEquals(objConfiguration, null))
            {
                objBuilder = new StringBuilder();
                objBuilder.AppendFormat("Hostname: {0} ",
                    objConfiguration.ExecutionInformation.EnvironmentInfo.MachineHostName);

                if (WithAppendLine)
                { 
                    objBuilder.AppendLine() ;
                }
                

                objBuilder.AppendFormat("IPAddress: {0} ",
                    objConfiguration.ExecutionInformation.TrackingUsingInfo.IpAddress);
                if (WithAppendLine)
                {
                    objBuilder.AppendLine() ;
                }

                objBuilder.AppendFormat("SO: {0} ",
                    objConfiguration.ExecutionInformation.EnvironmentInfo.OperativeSystemVersion);
                if (WithAppendLine)
                {
                    objBuilder.AppendLine() ;
                }

                objBuilder.AppendFormat("UserName: {0} ",
                    objConfiguration.ExecutionInformation.TrackingUsingInfo.UserName);
                if (WithAppendLine)
                {
                    objBuilder.AppendLine() ;
                }

                objBuilder.AppendFormat("UserName from Domain: {0} ",
                    objConfiguration.ExecutionInformation.TrackingUsingInfo.UserDomainName);
                if (WithAppendLine)
                {
                    objBuilder.AppendLine() ;
                }

                objBuilder.AppendFormat("Process: {0} ",
                    objConfiguration.ExecutionInformation.TrackingUsingInfo.ProcesorCount);
                //Always will b e a new Line (separator) after the last log register 

            }

            return objBuilder?.ToString();
        }
        private static void RegisterConsoleLog(string message, ConfigurationDto objConfiguration, EnumNLogStruct.LogType typeOfLog)
        {
            if (!object.ReferenceEquals(objConfiguration, null))
            {
                var finalMessage = BuildLogInfoWithConfigurationInformation(objConfiguration, false);

                Console.WriteLine(string.Concat(finalMessage, message));
                
                 

            }
        }