C# Events / Time Based Code Execution

Question

What is the right way to execute a Time based event in C# Console App.

Example Code:

namespace ServerTools
{
public class SaveWorld
{
    public static int DelayBetweenWorldSaves = 15;
    public static bool IsEnabled = false;
    public static Thread th;
    public static bool IsRunning = false;

    public static void Init()
    {
        if (IsEnabled && !IsRunning)
        {
            IsRunning = true;
            StartSave();
        }
    }

    private static void StartSave()
    {
        th = new Thread(new ThreadStart(Save));
        th.IsBackground = true;
        th.Start();
    }

    private static void Save()
    {
        while (IsEnabled)
        {
            int _playerCount = ConnectionManager.Instance.ClientCount();
            if (_playerCount > 0)
            {
                List<ClientInfo> _cInfoList = ConnectionManager.Instance.GetClients();
                ClientInfo _cInfo = _cInfoList.RandomObject();
                SdtdConsole.Instance.ExecuteSync("saveworld", _cInfo);
                Log.Out("[SERVERTOOLS] World Saved.");
            }
            Thread.Sleep(60000 * DelayBetweenWorldSaves);
        }
    }
}
}

They used Threading for this here. But isn't it a lot better to use the timers Event?

        public class Timer1
    {
        private static System.Timers.Timer aTimer;

        public static void Main()
        {
            // Normally, the timer is declared at the class level, 
            // so that it stays in scope as long as it is needed. 
            // If the timer is declared in a long-running method,   
            // KeepAlive must be used to prevent the JIT compiler  
            // from allowing aggressive garbage collection to occur  
            // before the method ends. You can experiment with this 
            // by commenting out the class-level declaration and  
            // uncommenting the declaration below; then uncomment 
            // the GC.KeepAlive(aTimer) at the end of the method. 
            //System.Timers.Timer aTimer; 

            // Create a timer with a ten second interval.
            aTimer = new System.Timers.Timer(10000);

            // Hook up the Elapsed event for the timer.
            aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);

            // Set the Interval to 2 seconds (2000 milliseconds).
            aTimer.Interval = 2000;
            aTimer.Enabled = true;

            Console.WriteLine("Press the Enter key to exit the program.");
            Console.ReadLine();

            // If the timer is declared in a long-running method, use 
            // KeepAlive to prevent garbage collection from occurring 
            // before the method ends. 
            //GC.KeepAlive(aTimer);
        }

        // Specify what you want to happen when the Elapsed event is  
        // raised. 
        private static void OnTimedEvent(object source, ElapsedEventArgs e)
        {
            Console.WriteLine("The Elapsed event was raised at {0}", e.SignalTime);
        }
    }

    /* This code example produces output similar to the following:

    Press the Enter key to exit the program.
    The Elapsed event was raised at 5/20/2007 8:42:27 PM
    The Elapsed event was raised at 5/20/2007 8:42:29 PM
    The Elapsed event was raised at 5/20/2007 8:42:31 PM
    ...
     */

I want to learn it the right way.

Also what would be the way to go if you would have to run different function on different times. Like some event runs 30 Sec the other 90 sec? Is there also something in Net which lets you execute Net Function like a Cronjob?

Thank you