ScheduleLib

    • Release
    • Open Source

    SSL ist deaktiviert! Aktivieren Sie SSL für diese Sitzung, um eine sichere Verbindung herzustellen.

      ScheduleLib

      Name des Programms:
      ScheduleLib 0.0.1.0

      Beschreibung:
      Mit dieser Library kann man (zur Zeit) Code zeitgesteuert oder per Interval ausführen.
      Vielleicht ist diese für jemanden nützlich um Updates, Reorg, etc. zeitgesteuert ausführen zu können

      Benutzung:
      Beispielprojekt angehängt

      zusätzlich hier der Code:
      Spoiler anzeigen

      VB.NET-Quellcode

      1. Imports ScheduleLib.Scheduler
      2. Public Class Form1
      3. Private WithEvents Scheduler As ScheduleLib.Scheduler
      4. Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
      5. Scheduler = New ScheduleLib.Scheduler(CDate("31.12.2012 23:59:59") ' Mit Datum/Uhrzeit initialisieren
      6. AddHandler Scheduler.Tick, AddressOf ScheduleTick
      7. AddHandler Scheduler.Changed, AddressOf ScheduleChanged
      8. End Sub
      9. Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click
      10. Scheduler = New ScheduleLib.Scheduler(60000) 'Interval alle 60 Sekunden
      11. AddHandler Scheduler.Tick, AddressOf ScheduleTick
      12. AddHandler Scheduler.Changed, AddressOf ScheduleChanged
      13. End Sub
      14. Private Sub Button3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button3.Click
      15. If Scheduler IsNot Nothing Then
      16. Scheduler.ChangeDate(CDate(("31.01.2012 23:59:59")) ' Datum/Uhrzeit neu setzen
      17. End If
      18. End Sub
      19. Private Sub Button4_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button4.Click
      20. If Scheduler IsNot Nothing Then
      21. Scheduler.ChangeDate(120000) ' Interval auf 2 Minuten setzen
      22. End If
      23. End Sub
      24. Private Sub ScheduleTick() 'Handles Scheduler.Tick
      25. ' Tick Event wenn Datum/Zeit oder Interval erreicht
      26. MessageBox.Show("Erreicht")
      27. End Sub
      28. Private Sub ScheduleChanged() 'Handles Scheduler.Changed
      29. ' Change Event wenn das Datum/Zeit oder Interval verändert wurde
      30. MessageBox.Show("Zeit geändert")
      31. End Sub
      32. End Class


      Screenshot(s):
      keiner, da dll

      Verwendete Programmiersprache:
      Visual Basic .NET (IDE: VB 2008 Prof.)

      Systemanforderungen:
      .NET Framework 2.0

      Lizenz/Weitergabe:
      Freeware, Open Source (siehe unten)
      einkompelieren erlaubt, nicht zwingend eine Namesnennung erforderlich wäre jedoch nett

      Falls jemanden noch was einfällt die Lib zu erweitern bitte einfach schreiben.
      Wie oben bereits erwähnt ist es nichts großes aber vielleicht kanns jemand brauchen.

      lg

      EDIT: Anbei der Code der Lib:

      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.ComponentModel;
      3. using System.Threading;
      4. namespace ScheduleLib
      5. {
      6. /// <summary>
      7. /// Klasse welches ein Event zu einer gewissen Zeit oder zum festgelegten Interval ausgibt
      8. /// </summary>
      9. /// <remarks></remarks>
      10. public class Scheduler
      11. {
      12. // Main-Timer
      13. private System.Threading.Timer _MainTimer;
      14. // Callback des Timers
      15. private TimerCallback _CallBack;
      16. /// <summary>
      17. /// Event das benachrichtigt sobald Interval oder Due "tickt"
      18. /// </summary>
      19. /// <remarks></remarks>
      20. public event EventHandler TimeDifferenz;
      21. /// <summary>
      22. /// Ändert den nächsten Zeitpunkt
      23. /// </summary>
      24. /// <param name="nextDate">Nächstes Datum + Uhrzeit</param>
      25. /// <remarks></remarks>
      26. public void ChangeDate(DateTime nextDate)
      27. {
      28. var now = DateTime.Now;
      29. if(!(nextDate < now))
      30. {
      31. // Unterschied zw. den Zeiträumen
      32. var ts = new TimeSpan(nextDate.Ticks - now.Ticks);
      33. // Millisekunden in Long
      34. long dueSet = Convert.ToInt64(ts.TotalMilliseconds);
      35. _MainTimer.Change(dueSet, Timeout.Infinite);
      36. }
      37. }
      38. /// <summary>
      39. /// Ändert den Interval
      40. /// </summary>
      41. /// <param name="interval">Interval in ms</param>
      42. /// <remarks></remarks>
      43. public void ChangeDate(long interval)
      44. {
      45. _MainTimer.Change(Timeout.Infinite, interval);
      46. }
      47. /// <summary>
      48. /// Tick des Timers. Controls invoken und Event rauspulvern
      49. /// </summary>
      50. /// <param name="stateInfo"></param>
      51. /// <remarks></remarks>
      52. private void MainTimer_Tick(object stateInfo)
      53. {
      54. foreach(Delegate d in TimeDifferenz.GetInvocationList())
      55. {
      56. dynamic T = (ISynchronizeInvoke)d.Target;
      57. if(T != null && T.InvokeRequired)
      58. T.BeginInvoke(TimeDifferenz, null);
      59. else
      60. d.DynamicInvoke(null);
      61. }
      62. }
      63. /// <summary>
      64. /// Initialisiert den Scheduler anhand des nächstes Zeitpunktes
      65. /// </summary>
      66. /// <param name="nextDate">Nächster Zeitpunkt</param>
      67. /// <remarks></remarks>
      68. public Scheduler(DateTime nextDate)
      69. {
      70. _CallBack += MainTimer_Tick;
      71. var now = DateTime.Now;
      72. if(!(nextDate < now))
      73. {
      74. // Unterschied zw. den Zeiträumen
      75. var ts = new TimeSpan(nextDate.Ticks - now.Ticks);
      76. // Millisekunden in Long
      77. long dueSet = Convert.ToInt64(ts.TotalMilliseconds);
      78. _MainTimer = new Timer(_CallBack, 0, dueSet, Timeout.Infinite);
      79. }
      80. else
      81. _MainTimer = new Timer(_CallBack, 0, Convert.ToInt64(Timeout.Infinite), Convert.ToInt64(Timeout.Infinite));
      82. }
      83. /// <summary>
      84. /// Initialisiert den Scheduler anhand eines angegeben Intervals
      85. /// </summary>
      86. /// <param name="interval">Interval in ms</param>
      87. /// <remarks></remarks>
      88. public Scheduler(long interval)
      89. {
      90. _MainTimer = new Timer(_CallBack, 0, Timeout.Infinite, interval);
      91. }
      92. }
      93. }
      Dateien
      ScheduleLib 0.0.1.0
      Kleine Lib zum Anlaufen von Code zu bestimmten Zeiten

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „fichz“ ()