Is it possible to use a member instead of let for an F# Event?

Question

In this code, EventL uses a let binding and EventM (is an attempt to) use a member:

type MyType() =
   let EventL = new Event<_>()
   member this.EventM = new Event<_>()

   member this.AddHandlers() =
      Event.add (fun string1 -> printfn "EventL: %s" string1) EventL.Publish
      Event.add (fun string1 -> printfn "EventM: %s" string1) this.EventM.Publish

   member this.Trigger(message) =
      EventL.Trigger(message)
      this.EventM.Trigger(message)

let myMyType = MyType()
myMyType.AddHandlers()
myMyType.Trigger("Event arg.")

When run, this outputs only EventL: Event arg. while EventM 's handler is not called.

Am I making a silly mistake or missing some piece of logic regarding members?

Answer 1

Your EventM is a computed property that gets evaluated every time it's called. This results in different Event objects being created throughout the rest of your code (2 times, once in AddHandlers , next in Trigger ).

Checkout the member val syntax. That creates a backing field and still gives public accessibility.

The fixed version would be:

type MyType() =
    member val EventM = new Event<_>()

If you don't have a primary constructor then you will need to use val instead and assign it in your constructor:

type MyType =
    val EventM : Event<string>
    new () = { EventM = new Event<_>() }

Note that in this case, you will have to give the type argument to Event .