C#

DateTime nextCheck = DateTime.Now.AddSeconds( t );

while (true)
{
    if (DateTime.Now > nextCheck)
    {
          nextCheck.AddSeconds( t );
          do the thing...
    }
    else { Thread.Sleep( nextCheck - DateTime.Now ); }
}

Quake2Player wrote:

while (true)
{
if (DateTime.Now > nextCheck)

private object syncRoot = new object();
private bool isDisposed = false;

~Output()
{
    Dispose(false);
}

public override void Close()
{
    Dispose();
}

public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
    //   I'm assuming your code needs to be thread safe, so place the clean up code inside a lock.
    lock(syncRoot)
    {
        if(!isDisposed)
        {
            if(disposing)
            {
                //  Clean up managed resources here.
            }
            
            //  Clean up unmanaged resources here
        }

        isDisposed = true;
    }
}

public static class MIDIDeviceManager
{
    private static List<MIDIOutput> activeOutputs = new List<MIDIOutput>();
    private static List<MIDIInput> activeInputs = new List<MIDIInput>();

    private static UInt32 availableMidiOutputCount;
    private static UInt32 availableMidiInputCount;

    public static UInt32 AvailableMIDIOutputCount
    {
        get
        {
            if (availableMidiOutputCount == 0)
                availableMidiOutputCount = InteropFunctions.midiOutGetNumDevs();
            return availableMidiOutputCount;
        }
    }
    public static UInt32 AvailableMIDIInputCount
    {
        get
        {
            if (availableMidiInputCount == 0)
                availableMidiInputCount = InteropFunctions.midiInGetNumDevs();
            return availableMidiInputCount;
        }
    }

    public static IList<MIDIOutput> ActiveOutputs
    {
        get { return activeOutputs.AsReadOnly(); }
    }
    public static IList<MIDIInput> ActiveInputs
    {
        get { return activeInputs.AsReadOnly(); }
    }

    public static MIDIOutput GetMIDIOutput(UInt32 id)
    {
        if (id < availableMidiOutputCount)
        {
            MIDIOutput result = null;
            foreach (MIDIOutput midiOutput in activeOutputs)
            {
                if (midiOutput.ID == id)
                {
                    result = midiOutput;
                    break;
                }
            }
            if (result == null)
            {
                result = new MIDIOutput(id);
                activeOutputs.Add(result);
            }
            return result;
        }
        throw new ArgumentOutOfRangeException(
            "id", "ID out of range. Check MIDIOutputCount for available range.");
    }
    public static MIDIInput GetMIDIInput(UInt32 id)
    {
        if (id < availableMidiInputCount)
        {
            MIDIInput result = null;
            foreach (MIDIInput midiInput in activeInputs)
            {
                if (midiInput.ID == id)
                {
                    result = midiInput;
                    break;
                }
            }
            if (result == null)
            {
                result = new MIDIInput(id);
                activeInputs.Add(result);
            }
            return result;
        }
        throw new ArgumentOutOfRangeException(
            "id", "ID out of range. Check MIDIInputCount for available range.");
    }

    internal static void RemoveDevice(MIDIDevice device)
    {
        switch (device.DeviceType)
        {
            case DeviceTypes.Input:
                activeInputs.Remove((MIDIInput)device);
                break;
            default: // Output
                activeOutputs.Remove((MIDIOutput)device);
                break;
        }
    }
}

public abstract class MIDIDevice : IDisposable
{
    private object syncRoot = new object();
    private bool isDisposed = false;

    public MIDIDevice(UInt32 id)
    {
        ID = id;
    }

    ~MIDIDevice()
    {
        Dispose(false);
    }

    public UInt32 ID { get; private set; }
    public string Name { get; internal set; }

    public abstract DeviceTypes DeviceType { get; }

    public void Close()
    {
        // ...
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    protected virtual void Dispose(bool disposing)
    {
        lock (syncRoot)
        {
            if (!isDisposed)
            {
                if (disposing)
                {
                    Close();
                    MIDIDeviceManager.RemoveDevice(this);
                }
            }
            isDisposed = true;
        }
    }
}

public class MIDIOutput : MIDIDevice
{
    internal MIDIOutput(UInt32 id) : base(id) { }

    public override DeviceTypes DeviceType
    {
        get { return DeviceTypes.Output; }
    }
}

public class MIDIInput : MIDIDevice
{
    internal MIDIInput(UInt32 id) : base(id) { }

    public override DeviceTypes DeviceType
    {
        get { return DeviceTypes.Input; }
    }
}

public enum DeviceTypes
{
    Output = 0,
    Input = 1,
}