Raise Event

[[gja]]

Hello There,

i just to ask some question regarding on how to raise an event in vb2003

this my code:

Public Class Form1
Public Event TimerStart()

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
RaiseEvent TimerStart
End Sub
End Class

this is my recieving class

Public Class Form2
Private WithEvents frm as Form1

Private Sub TimerReceiver()Handles frm.TimerStart
Messagebox.show("Testing")
End Sub
End Class

please give me suggestion if what im done wrong here..thanks!

[NickThissen]

I'm not really sure, but I think you need to declare your event 'As EventHandler'. I've always done it that way, but I'm not sure if it's absolutely required.

If you do that, then your method signature (of TimerReceiver) should also accept a sender As Object and a 'e' As EventArgs (in that order).

[cicatrix]

What concerns raising of events:

' A form code for testing
Public Class Form1
    Public Catcher As New CatcherClass
 
    Public Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Catcher.RaiseWithEvents()
        Catcher.RaiseWithoutWithEvents()
    End Sub
End Class
 
' Events example
'General systax:
 
' Declaring an event
Public Class SomeClass
    ' Our Event
    Public Event MyEvent() ' You can add parameters here
 
    ' This Sub is for test purposes
    ' It simply fires our event
    Sub SomeWork()
        RaiseEvent MyEvent()
    End Sub
End Class
 
' Catching an Event
' There are two ways you can assign an eventhandler to your event
' 1. Declare the class using WithEvents keyword
' 2. Use AddHandler statement
' This example covers both cases
 
Public Class CatcherClass
 
    ' Note tha we declare two instances of the same class 
    ' but using different declarations:
 
    'Declaration with 'WithEvents'
    Dim WithEvents mycls1 As New SomeClass
 
    ' Declaration without 'WithEvents'
    Dim mycls2 As New SomeClass
 
    ' Adding a handler for the declaration without Withevents
    ' (preferred way)
    Public Sub New()
        AddHandler mycls2.MyEvent, AddressOf WithoutWitheventsHandler
    End Sub
 
    ' For test purposes - raising an event
    ' Well we need something that will fire the event
    ' In a real life this can be any condition 
    Sub RaiseWithEvents()
        mycls1.SomeWork()
    End Sub
 
    Sub RaiseWithoutWithEvents()
        mycls2.SomeWork()
    End Sub
 
    Sub WithEventsHandler() Handles mycls1.MyEvent ' Note the Handles keyword
        MsgBox("Event handler for Withevents declaration.")
    End Sub
 
    Sub WithoutWitheventsHandler() ' Note the absense of the Handles keyword
        MsgBox("Event handler for declaration without Withevents.")
    End Sub
End Class

What concerns Timer:
Your code didn't have any timer object. In order for Timer to work you need:
1. Set the timer interval
2. Enable it

[NickThissen]

None of that is relevant to this thread I think. He is raising the event when a button is clicked, nothing to do with timers (except the name of the event). In the receiving class he's declaring the form WithEvents, and is using Handles correctly.

So as long as the form in variable 'frm' is actually being shown, and the button on there being clicked, then it should raise the event (assuming you don't need the 'As EventHandler' as I said in my first post).

[cicatrix]

None of that is relevant to this thread I think. He is raising the event when a button is clicked, nothing to do with timers (except the name of the event). In the receiving class he's declaring the form WithEvents, and is using Handles correctly.

So as long as the form in variable 'frm' is actually being shown, and the button on there being clicked, then it should raise the event (assuming you don't need the 'As EventHandler' as I said in my first post).

You don't.

But I still think that he has some issues with timers.

[[gja]]

Good Day Guys,

First, i would like to thank you all for your quick reply.

im very sorry for my confussing question..what i really want to do in here is...i want to Start the timer object at Class Form2..from Class Form1..and i think using event i can handle it..

[ForumAccount]

I'm not really sure, but I think you need to declare your event 'As EventHandler'. I've always done it that way, but I'm not sure if it's absolutely required.

Not required, but the event stub will argument-less. Probably not good practice... I would think Microsoft recommends that all events should at least have the standard EventHandler signature, dunno.

[[gja]]

What concerns raising of events:

' A form code for testing
Public Class Form1
    Public Catcher As New CatcherClass
 
    Public Sub Form1_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        Catcher.RaiseWithEvents()
        Catcher.RaiseWithoutWithEvents()
    End Sub
End Class
 
' Events example
'General systax:
 
' Declaring an event
Public Class SomeClass
    ' Our Event
    Public Event MyEvent() ' You can add parameters here
 
    ' This Sub is for test purposes
    ' It simply fires our event
    Sub SomeWork()
        RaiseEvent MyEvent()
    End Sub
End Class
 
' Catching an Event
' There are two ways you can assign an eventhandler to your event
' 1. Declare the class using WithEvents keyword
' 2. Use AddHandler statement
' This example covers both cases
 
Public Class CatcherClass
 
    ' Note tha we declare two instances of the same class 
    ' but using different declarations:
 
    'Declaration with 'WithEvents'
    Dim WithEvents mycls1 As New SomeClass
 
    ' Declaration without 'WithEvents'
    Dim mycls2 As New SomeClass
 
    ' Adding a handler for the declaration without Withevents
    ' (preferred way)
    Public Sub New()
        AddHandler mycls2.MyEvent, AddressOf WithoutWitheventsHandler
    End Sub
 
    ' For test purposes - raising an event
    ' Well we need something that will fire the event
    ' In a real life this can be any condition 
    Sub RaiseWithEvents()
        mycls1.SomeWork()
    End Sub
 
    Sub RaiseWithoutWithEvents()
        mycls2.SomeWork()
    End Sub
 
    Sub WithEventsHandler() Handles mycls1.MyEvent ' Note the Handles keyword
        MsgBox("Event handler for Withevents declaration.")
    End Sub
 
    Sub WithoutWitheventsHandler() ' Note the absense of the Handles keyword
        MsgBox("Event handler for declaration without Withevents.")
    End Sub
End Class

What concerns Timer:
Your code didn't have any timer object. In order for Timer to work you need:
1. Set the timer interval
2. Enable it

Thanks you very much!..this will be a great help.and additional information to me regarding raising an event..thank you guys.

[cicatrix]

Good Day Guys,

First, i would like to thank you all for your quick reply.

im very sorry for my confussing question..what i really want to do in here is...i want to Start the timer object at Class Form2..from Class Form1..and i think using event i can handle it..

You don't raise timer events yourself, it's timer's job.

There are three basic types of timers in .NET.

Here is a little demonstration of all. Read the comments.

• System.Windows.Forms.Timer
• System.Timers.Timer
• System.Threading.Timer

Public Class Form1
 
    
    Dim WinFormsTimer As Windows.Forms.Timer
    Dim TimersTimer As Timers.Timer
    Dim ThreadingTimer As Threading.Timer
 
    ' The purpose of this delegate will be exlained below
    Delegate Sub ChangeLabelCallback(ByVal [text] As String)
 
    ' We're going to need it for output
    Dim lbl As Label
 
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
 
        ' Adding our label
        lbl = New Label
        With lbl
            .Location = New Point(20, 20)
            .AutoSize = False
            .Size = New Size(Me.Width - 40, Me.Height - 40)
            .Font = New Font(Me.Font.FontFamily, 14, FontStyle.Bold, GraphicsUnit.Pixel)
        End With
        Me.Controls.Add(lbl)
 
 
        ' System.Windows.Forms.Timer
        ' *********************************************************
        ' A component timer.
        ' The simplest one. Compiled as a Windows.Forms.component
        ' and can be 'placed' on a form
        ' It's syncronous and starts disabled
        WinFormsTimer = New Windows.Forms.Timer()
        ' To enable it we must set the interval:
        WinFormsTimer.Interval = 1000 ' It will generate an event each second
        ' And we should also provide a handler to its Tick event
        AddHandler WinFormsTimer.Tick, AddressOf WinFormsTimerTickHandler
        ' To start the timer we should invoke its Start method:
        WinFormsTimer.Start()
 
 
 
        ' System.Timers.Timer
        ' *********************************************************
        ' The .NET Framework documentation refers to the System.Timers.Timer class 
        ' as a server-based timer that was designed and optimized for use in 
        ' multithreaded environments. Instances of this timer class can be safely 
        ' accessed from multiple threads. Unlike the System.Windows.Forms.Timer, 
        ' the System.Timers.Timer class will, by default, call your timer event handler 
        ' on a worker thread obtained from the common language runtime (CLR) thread pool. 
        ' This means that the code inside your Elapsed event handler must conform to a 
        ' golden rule of Win32 programming: an instance of a control should never be 
        ' accessed from any thread other than the thread that was used to instantiate it.
        ' The System.Timers.Timer class provides an easy way to deal with this dilemma — it
        ' exposes a public SynchronizingObject property. 
        ' Setting this property to an instance of a Windows Form (or a control on a Windows Form) 
        ' will ensure that the code in your Elapsed event handler runs on the same thread on 
        ' which the SynchronizingObject was instantiated.
        TimersTimer = New Timers.Timer
        TimersTimer.Interval = 3000 ' We want it to 'fire' each 3 second
        ' We need some event handler to perform periodical tasks (it has the Elapsed event)
        AddHandler TimersTimer.Elapsed, AddressOf TimersTimerElapsedHandler
        ' This class works in a thread-friendly manner
        ' We don't have to check whether we're in the working thread or not
        ' To do so we must tell the timer what object it has to be syncronous to.
        ' We do it this way:
        TimersTimer.SynchronizingObject = Me
        ' And of cours we have to start this timer
        ' (there is also Stop method)
        TimersTimer.Start()
 
        ' System.Threading.Timer
        ' *********************************************************
        ' Threading timer. The most precise timer available
        ' Since it is asyncronous it doesn't depend on the current 
        ' execution thread.
        ' To syncronize with the main workflow you can use
        ' a syncronization object which can report the
        ' state of an executing thread to the callback procedure
        ' Callback procedure is a procedure with a signature 
        ' identical to Threading.TimerCallBack delegate.
        ' You provide its address to the timer and it will be
        ' invoking it each time a timer event is generated.
        Dim SyncObject As New Object ' Specifies a syncronization object
        Dim Delay As Integer = 5000 ' Specifies a delay before the first callback is invoked
        Dim Interval As Integer = 5000 ' Specifies the time interval in milliseconds between each callback call
        ThreadingTimer = New Threading.Timer(AddressOf ThreadingTimerCallback, SyncObject, Delay, Interval)
 
 
    End Sub
 
 
    ' Handling of Timer events
    ' ***************************************************************** 
    ' This is our Winforms Timer Tick handler it is called each second.
    ' But it can 'miss' some ticks when our form class is busy with something
 
    Private Sub WinFormsTimerTickHandler(ByVal sender As Object, ByVal e As System.EventArgs)
        ' We'll get this handler invoked each second
        Static X As Integer
 
        ' We're going to change the title of our window each time this timer is fired
        X += 1
        lbl.Text = String.Format("Ticks {0}", X)
 
        Debug.WriteLine("Windows.Forms.Timer Tick")
    End Sub
 
    ' This is a handler for Timers.Timer
    ' It's generally more precise but still not as precise as Threading.Timer
    ' It is invoked every 3 seconds
    Private Sub TimersTimerElapsedHandler(ByVal sender As Object, ByVal e As System.Timers.ElapsedEventArgs)
        ' Since we provided the syncronization object we don't have to worry about
        ' cross-thread calls and thus we can access our form properties directly:
        lbl.Text = " Winforms Timer stopped with TimersTimer"
 
        ' We'll control winforms timer here. 
        ' Every three secodns we're going to turn it off 
        ' and after another three seconds - turn it on again.
        WinFormsTimer.Enabled = Not WinFormsTimer.Enabled
        Debug.WriteLine("Timer Elapsed event")
    End Sub
 
    ' This is the ThreadingTimer callback procedure
 
    ' It will be invoked each 5 seconds and receive a syncronization object 
    ' we passed in its initializer
    Private Sub ThreadingTimerCallback(ByVal state As Object)
        ' Note that the code here will be executed asyncronously in another thread
        ' Try to uncomment the following line and see what happens in 5 seconds:
        ' lbl.Text = "We don't care about cross-thread calls!"
 
        ' Spoiler: You'd get an exception.
        ' Instead, let's call ChangeLabel method (see below)
        ChangeLabel("We care about cross-thread calls!")
 
        Debug.WriteLine("Threading Timer event")
    End Sub
 
    ' The whole purpose of this sub is to change the label text
    Private Sub ChangeLabel(ByVal Text As String)
        ' To work safe we need to act thread-aware and
        ' check whether we're in the same thread:
        If lbl.InvokeRequired Then
            ' Apparently not, we're in the wrong thread
            ' so we need to marshal this call back to the UI thread 
            ' Do you remember that delegate in the beginning?
            ' We need it to invoke this very method once again,
            ' but in the right thread:
            Dim d As New ChangeLabelCallback(AddressOf ChangeLabel)
            Me.Invoke(d, New Object() {[Text]})
        Else
            ' Yes! We're in the right thread and can finally change the label text:
            lbl.Text = Text
        End If
    End Sub
 
 
End Class

[[gja]]

hello cicatrix,

Thanks for the examples.very nice sir.i study it right now and i got error with this line.

ThreadingTimer = New Threading.Timer(AddressOf ThreadingTimerCallback, SyncObject, Delay, Interval)

Error:

 Overload resolution failed because no accessible 'New' can be called without a narrowing conversion:
    'Public Sub New(callback As System.Threading.TimerCallback, state As Object, dueTime As Long, period As Long)': Argument matching parameter 'period' narrows from 'System.Object' to 'Long'.
    'Public Sub New(callback As System.Threading.TimerCallback, state As Object, dueTime As Integer, period As Integer)': Argument matching parameter 'period' narrows from 'System.Object' to 'Integer'.

how can fix this sir.

[cicatrix]

Hm, this is most strange because it's been compiled and successfully executed by me before posting.

But hey, which version of VS do you use?
It was done for VS2008 with Option Infer On
Try to change this line:

Dim Interval = 5000

to this:

Dim Interval As Integer = 5000

If this happens to be the case this is probably my fault not to anticipate that someone might have got earlier versions of VS.

Corrections made in the original post.

P.S. If it doesn't then ... well I dunno.
Try to initialize it with this line:

ThreadingTimer = New Threading.Timer(AddressOf ThreadingTimerCallback, SyncObject, 5000, 5000)

[[gja]]

Hi cicatrix,

sorry for not indicating the version of my Visual Studio..
btw,im using VS2003.i already test your updated code..and it works perfectly.

thank you very much for your effort.

i already rated this post as very helpful to me.

[pidyok]

You don't raise timer events yourself, it's timer's job.

There are three basic types of timers in .NET.

Here is a little demonstration of all. Read the comments.

• System.Windows.Forms.Timer
• System.Timers.Timer
• System.Threading.Timer

Public Class Form1
 
    
    Dim WinFormsTimer As Windows.Forms.Timer
    Dim TimersTimer As Timers.Timer
    Dim ThreadingTimer As Threading.Timer
 
    ' The purpose of this delegate will be exlained below
    Delegate Sub ChangeLabelCallback(ByVal [text] As String)
 
    ' We're going to need it for output
    Dim lbl As Label
 
    Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
 
        ' Adding our label
        lbl = New Label
        With lbl
            .Location = New Point(20, 20)
            .AutoSize = False
            .Size = New Size(Me.Width - 40, Me.Height - 40)
            .Font = New Font(Me.Font.FontFamily, 14, FontStyle.Bold, GraphicsUnit.Pixel)
        End With
        Me.Controls.Add(lbl)
 
 
        ' System.Windows.Forms.Timer
        ' *********************************************************
        ' A component timer.
        ' The simplest one. Compiled as a Windows.Forms.component
        ' and can be 'placed' on a form
        ' It's syncronous and starts disabled
        WinFormsTimer = New Windows.Forms.Timer()
        ' To enable it we must set the interval:
        WinFormsTimer.Interval = 1000 ' It will generate an event each second
        ' And we should also provide a handler to its Tick event
        AddHandler WinFormsTimer.Tick, AddressOf WinFormsTimerTickHandler
        ' To start the timer we should invoke its Start method:
        WinFormsTimer.Start()
 
 
 
        ' System.Timers.Timer
        ' *********************************************************
        ' The .NET Framework documentation refers to the System.Timers.Timer class 
        ' as a server-based timer that was designed and optimized for use in 
        ' multithreaded environments. Instances of this timer class can be safely 
        ' accessed from multiple threads. Unlike the System.Windows.Forms.Timer, 
        ' the System.Timers.Timer class will, by default, call your timer event handler 
        ' on a worker thread obtained from the common language runtime (CLR) thread pool. 
        ' This means that the code inside your Elapsed event handler must conform to a 
        ' golden rule of Win32 programming: an instance of a control should never be 
        ' accessed from any thread other than the thread that was used to instantiate it.
        ' The System.Timers.Timer class provides an easy way to deal with this dilemma — it
        ' exposes a public SynchronizingObject property. 
        ' Setting this property to an instance of a Windows Form (or a control on a Windows Form) 
        ' will ensure that the code in your Elapsed event handler runs on the same thread on 
        ' which the SynchronizingObject was instantiated.
        TimersTimer = New Timers.Timer
        TimersTimer.Interval = 3000 ' We want it to 'fire' each 3 second
        ' We need some event handler to perform periodical tasks (it has the Elapsed event)
        AddHandler TimersTimer.Elapsed, AddressOf TimersTimerElapsedHandler
        ' This class works in a thread-friendly manner
        ' We don't have to check whether we're in the working thread or not
        ' To do so we must tell the timer what object it has to be syncronous to.
        ' We do it this way:
        TimersTimer.SynchronizingObject = Me
        ' And of cours we have to start this timer
        ' (there is also Stop method)
        TimersTimer.Start()
 
        ' System.Threading.Timer
        ' *********************************************************
        ' Threading timer. The most precise timer available
        ' Since it is asyncronous it doesn't depend on the current 
        ' execution thread.
        ' To syncronize with the main workflow you can use
        ' a syncronization object which can report the
        ' state of an executing thread to the callback procedure
        ' Callback procedure is a procedure with a signature 
        ' identical to Threading.TimerCallBack delegate.
        ' You provide its address to the timer and it will be
        ' invoking it each time a timer event is generated.
        Dim SyncObject As New Object ' Specifies a syncronization object
        Dim Delay As Integer = 5000 ' Specifies a delay before the first callback is invoked
        Dim Interval As Integer = 5000 ' Specifies the time interval in milliseconds between each callback call
        ThreadingTimer = New Threading.Timer(AddressOf ThreadingTimerCallback, SyncObject, Delay, Interval)
 
 
    End Sub
 
 
    ' Handling of Timer events
    ' ***************************************************************** 
    ' This is our Winforms Timer Tick handler it is called each second.
    ' But it can 'miss' some ticks when our form class is busy with something
 
    Private Sub WinFormsTimerTickHandler(ByVal sender As Object, ByVal e As System.EventArgs)
        ' We'll get this handler invoked each second
        Static X As Integer
 
        ' We're going to change the title of our window each time this timer is fired
        X += 1
        lbl.Text = String.Format("Ticks {0}", X)
 
        Debug.WriteLine("Windows.Forms.Timer Tick")
    End Sub
 
    ' This is a handler for Timers.Timer
    ' It's generally more precise but still not as precise as Threading.Timer
    ' It is invoked every 3 seconds
    Private Sub TimersTimerElapsedHandler(ByVal sender As Object, ByVal e As System.Timers.ElapsedEventArgs)
        ' Since we provided the syncronization object we don't have to worry about
        ' cross-thread calls and thus we can access our form properties directly:
        lbl.Text = " Winforms Timer stopped with TimersTimer"
 
        ' We'll control winforms timer here. 
        ' Every three secodns we're going to turn it off 
        ' and after another three seconds - turn it on again.
        WinFormsTimer.Enabled = Not WinFormsTimer.Enabled
        Debug.WriteLine("Timer Elapsed event")
    End Sub
 
    ' This is the ThreadingTimer callback procedure
 
    ' It will be invoked each 5 seconds and receive a syncronization object 
    ' we passed in its initializer
    Private Sub ThreadingTimerCallback(ByVal state As Object)
        ' Note that the code here will be executed asyncronously in another thread
        ' Try to uncomment the following line and see what happens in 5 seconds:
        ' lbl.Text = "We don't care about cross-thread calls!"
 
        ' Spoiler: You'd get an exception.
        ' Instead, let's call ChangeLabel method (see below)
        ChangeLabel("We care about cross-thread calls!")
 
        Debug.WriteLine("Threading Timer event")
    End Sub
 
    ' The whole purpose of this sub is to change the label text
    Private Sub ChangeLabel(ByVal Text As String)
        ' To work safe we need to act thread-aware and
        ' check whether we're in the same thread:
        If lbl.InvokeRequired Then
            ' Apparently not, we're in the wrong thread
            ' so we need to marshal this call back to the UI thread 
            ' Do you remember that delegate in the beginning?
            ' We need it to invoke this very method once again,
            ' but in the right thread:
            Dim d As New ChangeLabelCallback(AddressOf ChangeLabel)
            Me.Invoke(d, New Object() {[Text]})
        Else
            ' Yes! We're in the right thread and can finally change the label text:
            lbl.Text = Text
        End If
    End Sub
 
 
End Class

dude, how do i stop the threaded timer??? thanks

[cicatrix]

dude, how do i stop the threaded timer??? thanks

You don't, check the documentation:
http://msdn.microsoft.com/en-us/libr...ing.timer.aspx

When a timer is no longer needed, use the Dispose method to free the resources held by the timer. Note that callbacks can occur after the Dispose method overload has been called, because the timer queues callbacks for execution by thread pool threads. You can use the Dispose(WaitHandle) method overload to wait until all callbacks have completed.