C# Language
timers

Syntaxis

• myTimer.Interval - stelt in hoe vaak de "Tick" -gebeurtenis wordt opgeroepen (in milliseconden)
• myTimer.Enabled - booleaanse waarde waarmee de timer wordt in- / uitgeschakeld
• myTimer.Start() - Start de timer.
• myTimer.Stop() - Stopt de timer.

Opmerkingen

Multithreaded Timers

System.Threading.Timer - Eenvoudigste multithreaded timer. Bevat twee methoden en een constructor.

Voorbeeld: een timer roept de DataWrite-methode aan, die na vijf seconden "multithread uitgevoerd ..." schrijft en daarna elke seconde totdat de gebruiker op Enter drukt:

using System;
using System.Threading;
class Program
{
  static void Main()
  {
    // First interval = 5000ms; subsequent intervals = 1000ms
    Timer timer = new Timer (DataWrite, "multithread executed...", 5000, 1000);
    Console.ReadLine();
    timer.Dispose(); // This both stops the timer and cleans up.
  }

  static void DataWrite (object data)
  {
    // This runs on a pooled thread
    Console.WriteLine (data); // Writes "multithread executed..."
  }
}

Opmerking: zal een aparte sectie plaatsen voor het verwijderen van multithreaded timers.

Change - Deze methode kan worden opgeroepen als u het timerinterval wilt wijzigen.

Timeout.Infinite - Als je maar één keer wilt vuren. Specificeer dit in het laatste argument van de constructor.

System.Timers - Een andere timerklasse aangeboden door .NET Framework. Het wikkelt de System.Threading.Timer .

Kenmerken:

• IComponent - Zodat het kan worden geplaatst in de componentenlade van Visual Studio Designer
• Interval in plaats van een Change
• Elapsed event in plaats van een callback delegate
• Enabled om de timer te starten en te stoppen ( default value = false )
• Start & Stop methoden voor het geval dat u in de war raakt door de eigenschap Enabled (hierboven)
• AutoReset - voor het aangeven van een terugkerende gebeurtenis ( default value = true )
• SynchronizingObject eigenschap met Invoke en BeginInvoke methoden voor het veilig aanroepen van methoden op WPF-elementen en Windows Forms-besturingselementen

Voorbeeld dat alle bovenstaande functies weergeeft:

using System;
using System.Timers; // Timers namespace rather than Threading
class SystemTimer
{
  static void Main()
  {
    Timer timer = new Timer(); // Doesn't require any args
    timer.Interval = 500;
    timer.Elapsed += timer_Elapsed; // Uses an event instead of a delegate
    timer.Start(); // Start the timer
    Console.ReadLine();
    timer.Stop(); // Stop the timer
    Console.ReadLine();
    timer.Start(); // Restart the timer
    Console.ReadLine();
    timer.Dispose(); // Permanently stop the timer
 }

 static void timer_Elapsed(object sender, EventArgs e)
 {
   Console.WriteLine ("Tick");
 }
}

Multithreaded timers - gebruik de thread pool om een paar threads meerdere timers te laten bedienen. Het betekent dat de callback-methode of de gebeurtenis Elapsed telkens wanneer deze wordt aangeroepen, op een andere thread kan worden geactiveerd.

Elapsed - deze gebeurtenis wordt altijd op tijd geactiveerd, ongeacht of de vorige Elapsed gebeurtenis is uitgevoerd. Daarom moeten callbacks of event-handlers thread-safe zijn. De nauwkeurigheid van multithreaded timers is afhankelijk van het besturingssysteem en ligt meestal tussen de 10 en 20 ms.

interop - wanneer je ooit een grotere nauwkeurigheid nodig hebt, gebruik dit en bel de Windows multimedia timer. Dit heeft een nauwkeurigheid tot 1 ms en is gedefinieerd in winmm.dll .

timeBeginPeriod - Bel dit eerst om het besturingssysteem te laten weten dat u een hoge nauwkeurigheid van de timing nodig hebt

timeSetEvent - noem dit na timeBeginPeriod om een multimediatimer te starten.

timeKillEvent - noem dit als u klaar bent, dit stopt de timer

timeEndPeriod - Bel dit om het besturingssysteem te laten weten dat u niet langer een hoge timing-nauwkeurigheid nodig hebt.

U kunt complete voorbeelden op internet vinden die de multimediatimer gebruiken door te zoeken naar de trefwoorden dllimport winmm.dll timesetevent .

Een instantie van een timer maken

Timers worden gebruikt om taken uit te voeren met specifieke tijdsintervallen (Doe X elke Y seconden) Hieronder ziet u een voorbeeld van het maken van een nieuw exemplaar van een timer.

OPMERKING : dit is van toepassing op timers die WinForms gebruiken. Als je WPF gebruikt, wil je misschien kijken naar DispatcherTimer

    using System.Windows.Forms; //Timers use the Windows.Forms namespace

    public partial class Form1 : Form
    {

        Timer myTimer = new Timer(); //create an instance of Timer named myTimer

    
        public Form1()
        {
            InitializeComponent();
        }

    }

De gebeurtenishandler "Tick" toewijzen aan een timer

Alle acties die in een timer worden uitgevoerd, worden afgehandeld in de gebeurtenis "Tick".

public partial class Form1 : Form
{

    Timer myTimer = new Timer();

    
    public Form1()
    {
        InitializeComponent();

        myTimer.Tick += myTimer_Tick; //assign the event handler named "myTimer_Tick"
    }

    private void myTimer_Tick(object sender, EventArgs e)
    {
        // Perform your actions here.
    }
}

Voorbeeld: een timer gebruiken om een eenvoudige aftelling uit te voeren.

    public partial class Form1 : Form
    {

    Timer myTimer = new Timer();
    int timeLeft = 10;
    
        public Form1()
        {
            InitializeComponent();

            //set properties for the Timer
            myTimer.Interval = 1000;
            myTimer.Enabled = true;

            //Set the event handler for the timer, named "myTimer_Tick"
            myTimer.Tick += myTimer_Tick;

            //Start the timer as soon as the form is loaded
            myTimer.Start();

            //Show the time set in the "timeLeft" variable
            lblCountDown.Text = timeLeft.ToString();

        }

        private void myTimer_Tick(object sender, EventArgs e)
        {
            //perform these actions at the interval set in the properties.
            lblCountDown.Text = timeLeft.ToString();
            timeLeft -= 1;

            if (timeLeft < 0)
            {
                myTimer.Stop();
            }
        }
    }

Resulteert in...

Enzovoorts...