Ekinlikler
Olaylar, işlev çağrılarını kullanıcı eylemleriyle ilişkilendirmenize olanak tanır ve GUI programlamada önemlidir. Olaylar, uygulamalarınız veya işletim sistemi tarafından da tetiklenebilir.
Olayları İşleme
Windows Forms veya Windows Presentation Foundation (WPF) gibi bir GUI kitaplığı kullandığınızda, uygulamanızdaki kodun çoğu kitaplık tarafından önceden tanımlanan olaylara yanıt olarak çalıştırılır. Bu önceden tanımlı olaylar, formlar ve denetimler gibi GUI sınıflarının üyeleridir. Aşağıdaki kodda gösterildiği gibi ilgili belirli adlandırılmış olaya (örneğin, Click sınıfın Form olayı) başvurarak ve yöntemini çağırarak Add , düğme tıklaması gibi önceden var olan bir olaya özel davranış ekleyebilirsiniz. Bunu F# Etkileşimli'den çalıştırırsanız çağrısının atını System.Windows.Forms.Application.Run(System.Windows.Forms.Form)atlarsınız.
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)
yönteminin Add türü şeklindedir ('a -> unit) -> unit. Bu nedenle, olay işleyici yöntemi genellikle olay bağımsız değişkenleri olan bir parametre alır ve döndürür unit. Önceki örnekte, olay işleyici lambda ifadesi olarak gösterilmiştir. Olay işleyicisi, aşağıdaki kod örneğinde olduğu gibi, bir işlev değeri de olabilir. Aşağıdaki kod örneğinde, olay türüne özgü bilgiler sağlayan olay işleyicisi parametrelerinin kullanımı gösterilmektedir. Bir MouseMove olay için, sistem işaretçinin X ve Y konumunu içeren bir System.Windows.Forms.MouseEventArgs nesnesi geçirir.
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ı, IEvent arabirimini uygulayan F# Olay türüyle temsil edilir. IEvent, diğer iki arabirimin ve IDelegateEvent'in işlevselliğini birleştiren bir arabirimdirSystem.IObservable<'T>. Bu nedenle, Eventdiğer dillerdeki temsilcilerin eşdeğer işlevlerine, ayrıca IObservableF# olaylarının olay filtrelemeyi desteklediği ve F# birinci sınıf işlevleri ve lambda ifadelerini olay işleyicileri olarak kullandığı anlamına gelir. Bu işlev Olay modülünde sağlanır.
Diğer tüm .NET Framework olayları gibi davranan bir sınıfta olay oluşturmak için sınıfına bir sınıfın let alanı olarak tanımlayan Event bir bağlama ekleyin. İstenen olay bağımsız değişkeni türünü tür bağımsız değişkeni olarak belirtebilir veya boş bırakarak derleyicinin uygun türü ortaya çıkarmasını sağlayabilirsiniz. Ayrıca, olay CLI olayı olarak sunan bir olay üyesi de tanımlamanız gerekir. Bu üye CLIEvent özniteliğine sahip olmalıdır. Bir özellik olarak bildirilir ve uygulaması yalnızca olayın Publish özelliğine yapılan bir çağrıdır. Sınıfınızın kullanıcıları, bir işleyici eklemek için yayımlanan olayın yöntemini kullanabilir Add . yöntemi için Add bağımsız değişken bir lambda ifadesi olabilir. Bağımsız değişkenleri işleyici işlevine geçirerek olayı yükseltmek için olayının özelliğini kullanabilirsiniz Trigger . Aşağıdaki kod örneği bunu gösterir. Bu örnekte, olay için gösterilen tür bağımsız değişkeni, lambda ifadesi için bağımsız değişkenleri temsil eden bir kayıt düzenidir.
open System.Collections.Generic
type MyClassWithCLIEvent() =
let event1 = new Event<string>()
[<CLIEvent>]
member this.Event1 = event1.Publish
member this.TestEvent(arg) =
event1.Trigger(arg)
let classWithEvent = new MyClassWithCLIEvent()
classWithEvent.Event1.Add(fun 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!
Modül tarafından Event sağlanan ek işlevler burada gösterilmiştir. Aşağıdaki kod örneği, bir olay ve tetikleyici yöntemi oluşturmak, lambda ifadeleri biçiminde iki olay işleyicisi eklemek ve ardından her iki lambda ifadesini yürütmek için olayı tetikleme işleminin temel kullanımını Event.create gösterir.
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 kodun çıktısı aşağıdaki gibidir.
Event occurred.
Given a value: Event occurred.
Olay Akışını İşleme
Event.add işlevini kullanarak yalnızca bir olay için olay işleyicisi eklemek yerine modüldeki Event işlevleri kullanarak olay akışlarını yüksek oranda özelleştirilmiş yollarla işleyebilirsiniz. Bunu yapmak için, bir dizi işlev çağrısında ilk değer olarak olayla birlikte iletme kanalını (|>) ve Event sonraki işlev çağrıları olarak modül işlevlerini kullanırsınız.
Aşağıdaki kod örneği, işleyicinin yalnızca belirli koşullarda çağrıldığı bir olayın nasıl ayarlanacağını 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) )
Gözlemlenebilir modülü, gözlemlenebilir nesneler üzerinde çalışan benzer işlevler içerir. Gözlemlenebilir nesneler olaylara benzer, fakat yalnızca, kendilerine abone olunuyorsa olaylara etkin olarak abone olurlar.
Bir Arabirim Olayı Uygulama
UI bileşenleri geliştirirken, genellikle varolan bir formdan veya denetimden devralan yeni bir form veya yeni bir denetim oluşturarak başlarsınız. Olaylar genellikle bir arabirimde tanımlanır ve bu o durumda, olayı gerçekleştirmek için arabirimi gerçekleştirmeniz gerekir. Arabirimi tek System.ComponentModel.INotifyPropertyChangedSystem.ComponentModel.INotifyPropertyChanged.PropertyChanged bir olayı tanımlar. Aşağıdaki kod, bu devralınan arabirimde tanımlanan olayın nasıl uygulanacağını göstermektedir:
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 {args.PropertyName} changed its value to {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)
Oluşturucuda olayı bağlamak istiyorsanız, kod biraz daha karmaşıktır çünkü aşağıdaki örnekte olduğu gibi olay kancası ek bir oluşturucudaki bir then blokta olmalıdır:
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 {args.PropertyName} changed its value to {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)
