/// <summary>
        /// Main entry point
        /// </summary>
        /// <param name="args">Command line arguments</param>
        /// <returns>Application result</returns>
        [STAThread]
        static int Main(string[] args)
        {
            Logger.Info(MethodInfo.GetCurrentMethod(), "Started Worker Queue V" + Assembly.GetExecutingAssembly().GetName().Version.ToString());
            Console.WriteLine("eRoom Business Reports Worker Queue V" + Assembly.GetExecutingAssembly().GetName().Version.ToString());

            // Prevent that this application can be started multiple times
            Logger.Debug(MethodInfo.GetCurrentMethod(), "Aquire application mutex state");
            Mutex singleInstanceMutex = null;
            try
            {
                singleInstanceMutex = Mutex.OpenExisting("EBRWorkerQueue");

                // application is already open
                Logger.Warn(MethodInfo.GetCurrentMethod(), "Application already opened, Exiting!");
                return ReturnCodes.ApplicationAlreadyOpened;
            }
            catch
            {
                // Mutex dont exists, create one
                Logger.Debug(MethodInfo.GetCurrentMethod(), "Create new application mutex");
                singleInstanceMutex = new Mutex(true, "EBRWorkerQueue");
            }

            // Get parameters
            Logger.Debug(MethodInfo.GetCurrentMethod(), String.Format("Parse arguments: {0}", ToString(args)));
            bool compabilityParam = HasArgument(args, "compability");

            // Print arguments
            Logger.Info(MethodInfo.GetCurrentMethod(), String.Format("Compability mode active: {0}", compabilityParam));

            // Run Queue Application
            int res = ReturnCodes.Success; // By default its successfully.
            try
            {
                // Init worker queue / eRoom application is created internally
                Logger.Debug(MethodInfo.GetCurrentMethod(), "Run worker queue");
                using (EBRWorkerQueue workerQueue = new EBRWorkerQueue())
                {
                    // Set compability parameter
                    workerQueue.Compability = compabilityParam;

                    // Run worker queue
                    res = workerQueue.Run();
                    Logger.Debug(MethodInfo.GetCurrentMethod(), "Finished worker queue, result: " + res.ToString());
                }
            }
            catch (Exception ex)
            {
                Logger.Error(MethodInfo.GetCurrentMethod(), "Unhandled exception while running worker queue!", ex);
            }
            finally
            {
                // Release mutex
                if (singleInstanceMutex != null)
                {
                    Logger.Debug(MethodInfo.GetCurrentMethod(), "Release application mutex");
                    singleInstanceMutex.ReleaseMutex();
                }
            }
            Logger.Info(MethodInfo.GetCurrentMethod(), "Finished Worker Queue with result: " + res.ToString());
            return res;
        }

        /// <summary>
        /// Runs the worker queue:
        ///   1.) Compability process (Only if mode is enabled)
        ///   2.) Clear memory job list
        ///   3.) Add jobs to memory job list
        ///   4.) Process jobs (Refresh all reports)
        /// </summary>
        /// <returns>Application result code</returns>
        public int Run()
        {
            Logger.Enter(MethodInfo.GetCurrentMethod());

            Logger.Debug(MethodInfo.GetCurrentMethod(), "Check application object...");
            if (!HasApplication)
            {
                Logger.Error(MethodInfo.GetCurrentMethod(), "Check application object failed!");
                return ReturnCodes.ApplicationObjectIsMissing;
            }
            else
                Logger.Debug(MethodInfo.GetCurrentMethod(), "Check application object ok");

            // Compability process (Only if mode is enabled)
            if (bCompability)
            {
                Logger.Debug(MethodInfo.GetCurrentMethod(), "Run compability process");
                CompabilityProcess();
                Logger.Debug(MethodInfo.GetCurrentMethod(), "Finished compability process");
            }

            // Clear memory job list
            Logger.Debug(MethodInfo.GetCurrentMethod(), "Clear memory job list");
            aJobs.Clear();

            // Start worker queue
            Logger.Debug(MethodInfo.GetCurrentMethod(), "Add jobs");
            AddJobs();
            Logger.Debug(MethodInfo.GetCurrentMethod(), "Finished adding jobs");

            // Process worker queue jobs
            Logger.Debug(MethodInfo.GetCurrentMethod(), "Run reports");
            ProcessJobs();
            Logger.Debug(MethodInfo.GetCurrentMethod(), "Finished reports");

            // Return
            int res = ReturnCodes.Success;
            Logger.Leave(MethodInfo.GetCurrentMethod(), res);
            return res;
        }

int Addition(int a, int b)
{
  Log.Enter(a, b);

  Log.Debug("Initialize result with zero");
  int res = 0;

  Log.Info(String.Format("Calculate {0} and {1}", a, b));
  try
  {
    res = a+b;
    Log.Debug(String.Format("Calculation from {0} and {1} succeeded.", a, b));
  }
  catch (Exception ex)
  {
    Log.Error(String.Format("Failed calculating {0} and {1}!", a, b), ex);
  }
  Log.Leave(res);
  return res;
}

int Addition(int a, int b)
{
  int res = 0;
  Log::FunctionScopeEnter FunctionScopeDebugMessage(res,a, b);//generate enter message with init values and parameter(result,parameterlist)

  try
  {
    res = a+b;
  }
  catch (Exception ex)
  {
    Log.Error(String.Format("Failed calculating {0} + {1}!", a, b), ex);
  }
  return res;
}//FunctionScopeDebugMessage will bedesrtoyed and print all values again with leave message

        public enum LogLevel
        {
            Off = -1,
            Fatal = 0,
            Error = 1,
            Warning = 2,
            Info = 3,
            Debug = 4
        }