Olayları (F#)

Makale
02/28/2013

Olaylar ve GUI programlamada önemli işlev çağrıları kullanıcı eylemleri ile ilişkilendirmek için etkinleştirebilirsiniz. Olaylar, uygulamalarınız tarafından veya işletim sistemi tarafından tetiklenebilir.

Olay işleme

Windows Forms ya da Windows sunu Foundation (wpf) gibi bir GUI kitaplığı kullandığınızda, uygulamanızdaki kodunu çoğunu önceden tanımlanmış olan olaylara yanıt olarak kitaplığı tarafından çalıştırılır. Önceden tanımlanmış Bu olaylar, formlar ve denetimler gibi GUI sınıfları üyeleridir. Önceden varolan bir olay için bir düğmeyi tıklatması gibi olay ilgi adlı özel başvurarak özel davranış ekleyebilirsiniz (örneğin, Click , olay Form sınıfı) ve çağırma Add yöntemi, aşağıdaki kodda gösterildiği gibi. Bu F# etkileşimli çalıştırırsanız, çağrı ihmal Run.

open System.Windows.Forms

let form = new Form(Text="F# Windows Form",
                    Visible = true,
                    TopMost = true)

form.Click.Add(fun evArgs -> System.Console.Beep())
Application.Run(form)

Tür Add yöntemi ('a -> unit) -> unit. Bu nedenle, olay işleyicisi yöntemi genellikle olay bağımsız bir parametre alır ve verir unit. Önceki örnek olay işleyicisi lambda ifade olarak gösterir. Olay işleyicisi, aşağıdaki kod örneğinde olduğu gibi bir işlevin değeri de olabilir. Aşağıdaki kod örneği, olay türüne özgü bilgiler sağlamak işleyicisi parametreleri de olay kullanımını göstermektedir. İçin bir MouseMove sistem olay, geçen bir MouseEventArgs içeren bir nesne, X ve Y işaretçinin konumuna.

open System.Windows.Forms

let Beep evArgs =
    System.Console.Beep( )  


let form = new Form(Text = "F# Windows Form",
                    Visible = true,
                    TopMost = true)

let MouseMoveEventHandler (evArgs : System.Windows.Forms.MouseEventArgs) =
    form.Text <- System.String.Format("{0},{1}", evArgs.X, evArgs.Y)

form.Click.Add(Beep)
form.MouseMove.Add(MouseMoveEventHandler)
Application.Run(form)

Özel olaylar oluşturma

F# olayları temsil edilir F# tarafından olay sınıf, hangi Implements IEvent arabirimi. IEventkendisini diğer iki arabirimi işlevselliği bir araya getiren bir arabirim olduğu IObservable<T> ve IDelegateEvent. Bu nedenle, Events sahip eşdeğer bir işlevselliği diğer dillerde temsilcilerin yanı sıra işlevlerin IObservable, yani F# olayları Olay Filtresi ve olay işleyicileri olarak F# birinci işlevleri ve lambda ifadeleri kullanarak destekler. Bu işlevsellik sağlanan Olay Modülü.

Bir olay gibi davranır, yalnızca bir sınıf üzerinde diğer oluşturmak için.net Framework olay, sınıfa bir let tanımlayan bağlama bir Event bir alana bir sınıf olarak. Tür bağımsız değişkeni olarak istenen olay bağımsız değişken türü belirtin veya boş bırakın ve uygun gerçekleştirip derleyici vardır. Ayrıca, olay CLI olay olarak sergiler bir olay üye tanımlamanız gerekir. Bu üye olması gerektiğini CLIEvent özniteliği. Bir özellik gibi bildirilmiş ve yalnızca bir çağrı uygulamasıdır Yayınla olayın özelliği. Sınıfınızın kullanıcılarının kullanarak Add yayınlanan olay işleyici eklemek için yöntem. Bağımsız değişken için Add yöntemi, lambda ifade olabilir. Kullanabileceğiniz Trigger olay işleyici işlevi bağımsız değişken ileterek olayı oluşturmak için özellik. Aşağıdaki kod örneği, bunu göstermektedir. Bu örnekte, olay inferred türü değişkeni lambda ifade bağımsız değişkenleri gösteren bir kayıt düzeni ' dir.

open System.Collections.Generic

type MyClassWithCLIEvent() =

    let event1 = new Event<_>()

    [<CLIEvent>]
    member this.Event1 = event1.Publish

    member this.TestEvent(arg) =
        event1.Trigger(this, arg)

let classWithEvent = new MyClassWithCLIEvent()
classWithEvent.Event1.Add(fun (sender, arg) -> 
        printfn "Event1 occurred! Object data: %s" arg)

classWithEvent.TestEvent("Hello World!")

System.Console.ReadLine() |> ignore

Çıktı aşağıdaki gibidir.

Event1 occurred! Object data: Hello World!

Tarafından sağlanan ek işlevler Event modülü burada gösterilmektedir. Aşağıdaki kod örneği, temel kullanılışını Event.create bir olay ve tetikleyici yöntemi oluşturmak için lambda ifadeleri formunda iki olay işleyicisi ekleyin ve sonra her iki lambda ifade çalıştırmak için olayı tetiklemek.

type MyType() =
    let myEvent = new Event<_>()

    member this.AddHandlers() =
       Event.add (fun string1 -> printfn "%s" string1) myEvent.Publish
       Event.add (fun string1 -> printfn "Given a value: %s" string1) myEvent.Publish

    member this.Trigger(message) =
       myEvent.Trigger(message)

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

Önceki kod çıktısı aşağıdaki gibidir.

Event occurred.
Given a value: Event occurred.

Olay akışlarını işleme

Yalnızca bir olay için bir olay işleyicisi kullanarak eklemek yerine Event.add işlevi, işlevlerini kullanabilirsiniz Event üst düzeyde özelleştirilmiş biçimlerde olayların işlem akışı modülü. Bunu yapmak için ileriye doğru kanal kullanın (|>) işlev çağrıları, bir dizi ilk değer olarak olayıyla birlikte ve Event modülü sonraki işlev çağrısı olarak işlev görür.

Aşağıdaki kod örneği, bir olay için işleyici yalnızca belirli koşullar altında adlandırılır nasıl gösterir.

let form = new Form(Text = "F# Windows Form",
                    Visible = true,
                    TopMost = true)
form.MouseMove
    |> Event.filter ( fun evArgs -> evArgs.X > 100 && evArgs.Y > 100)
    |> Event.add ( fun evArgs ->
        form.BackColor <- System.Drawing.Color.FromArgb(
            evArgs.X, evArgs.Y, evArgs.X ^^^ evArgs.Y) )

Observable modülü observable nesneler üzerinde çalışmaya benzer işlevleri içerir. Observable nesneleri olaylarına benzer, ancak bunlar kendilerini olunan, yalnızca etkin olarak olaylara abone.

Bir arabirim olayı uygulama

UI bileşenlerini geliştirdikçe, genellikle yeni bir form veya varolan form veya denetim devralan yeni bir denetim oluşturarak başlayın. Olaylar sık sık bir arabirimde tanımlanır ve bu durumda, olay uygulamak için arabirimini uygulamalıdır. INotifyPropertyChanged Arabirimi tanımlayan tek bir PropertyChanged olay. Aşağıdaki kod, devralınan bu arabirimde tanımlanan olay nasıl uygulandığını gösterir:

module CustomForm

open System.Windows.Forms
open System.ComponentModel

type AppForm() as this =
   inherit Form()

   // Define the propertyChanged event.
   let propertyChanged = Event<PropertyChangedEventHandler, PropertyChangedEventArgs>()
   let mutable underlyingValue = "text0"

   // Set up a click event to change the properties.
   do
      this.Click |> Event.add(fun evArgs -> this.Property1 <- "text2"
                                            this.Property2 <- "text3")

   // This property does not have the property-changed event set.
   member val Property1 : string = "text" with get, set

   // This property has the property-changed event set.
   member this.Property2
        with get() = underlyingValue
        and set(newValue) =
            underlyingValue <- newValue
            propertyChanged.Trigger(this, new PropertyChangedEventArgs("Property2"))

   // Expose the PropertyChanged event as a first class .NET event.
   [<CLIEvent>]
   member this.PropertyChanged = propertyChanged.Publish


   // Define the add and remove methods to implement this interface.
   interface INotifyPropertyChanged with
       member this.add_PropertyChanged(handler) = propertyChanged.Publish.AddHandler(handler)
       member this.remove_PropertyChanged(handler) = propertyChanged.Publish.RemoveHandler(handler)

   // This is the event-handler method.
   member this.OnPropertyChanged(args : PropertyChangedEventArgs) =
       let newProperty = this.GetType().GetProperty(args.PropertyName)
       let newValue = newProperty.GetValue(this :> obj) :?> string
       printfn "Property %s changed its value to %s" args.PropertyName newValue

// Create a form, hook up the event handler, and start the application.
let appForm = new AppForm()
let inpc = appForm :> INotifyPropertyChanged
inpc.PropertyChanged.Add(appForm.OnPropertyChanged)
Application.Run(appForm)

Yapıcısında olayı yukarı kanca istiyorsanız, tasarımcı olması gerektiği için kod biraz daha karmaşık bir then aşağıdaki örnekte olduğu gibi ek kurucusunda engelleyin:

module CustomForm

open System.Windows.Forms
open System.ComponentModel

// Create a private constructor with a dummy argument so that the public
// constructor can have no arguments.
type AppForm private (dummy) as this =
   inherit Form()

   // Define the propertyChanged event.
   let propertyChanged = Event<PropertyChangedEventHandler, PropertyChangedEventArgs>()
   let mutable underlyingValue = "text0"

   // Set up a click event to change the properties.
   do
      this.Click |> Event.add(fun evArgs -> this.Property1 <- "text2"
                                            this.Property2 <- "text3")
      

   // This property does not have the property changed event set.
   member val Property1 : string = "text" with get, set

   // This property has the property changed event set.
   member this.Property2
        with get() = underlyingValue
        and set(newValue) =
            underlyingValue <- newValue
            propertyChanged.Trigger(this, new PropertyChangedEventArgs("Property2"))

   [<CLIEvent>]
   member this.PropertyChanged = propertyChanged.Publish

   // Define the add and remove methods to implement this interface.
   interface INotifyPropertyChanged with
       member this.add_PropertyChanged(handler) = this.PropertyChanged.AddHandler(handler)
       member this.remove_PropertyChanged(handler) = this.PropertyChanged.RemoveHandler(handler)

   // This is the event handler method.
   member this.OnPropertyChanged(args : PropertyChangedEventArgs) =
       let newProperty = this.GetType().GetProperty(args.PropertyName)
       let newValue = newProperty.GetValue(this :> obj) :?> string
       printfn "Property %s changed its value to %s" args.PropertyName newValue

   new() as this =
        new AppForm(0)
          then
          let inpc = this :> INotifyPropertyChanged
          inpc.PropertyChanged.Add(this.OnPropertyChanged)
       

// Create a form, hook up the event handler, and start the application.
let appForm = new AppForm()
Application.Run(appForm)