Programarea bazată pe evenimente este o paradigmă de programare în care fluxul de execuție al unui program este determinat de evenimente cum ar fi acțiunile utilizatorilor (clicuri de mouse, apăsări de taste), ieșirile senzorilor sau mesajele altor programe, etc.
Deoarece C# este de asemenea un limbaj de programare bazat pe evenimente, astăzi vom învăța despre evenimente. Evenimentele sunt un concept destul de complex, care poate pune în dificultate chiar și pe programatorii avansați; ele sunt de fapt compuse din evenimente, operatori de evenimente (event handlers) și delegați (delegates), dar pentru nivelul nostru de începători vom învăța doar conceptele de bază al evenimentelor.
La nivelul cel mai de bază, evenimentele sunt mesaje care semnalează că s-a întâmplat ceva. De exemplu, când faceți clic pe un buton, o anumită acțiune este executată. Cu alte cuvinte, programul a primit un eveniment de clic, semnalând că un clic al mouse-ului a avut loc undeva în programul nostru și că o anumită acțiune trebuie executată pentru acel eveniment. Pe scurt, evenimentele sunt mesaje către computer, anunțând că anumite acțiuni au avut loc.
Operatorii de evenimente pe de altă parte, sunt bucățile de cod care ar trebui să fie executate atunci când un anumit eveniment se petrece, și arată aproape ca și metodele normale, însă cu tipuri de parametri necunoscuți. Semnăturile metodele operatorilor de evenimente au aceleași semnături cu evenimentele în sine.
Dar, destul cu vorbitul. Să vedem ce înseamnă practic evenimentele și cum ne pot fi ele utile. Am spus într-o lecție anterioară, controalele vizuale au proprietăți, metode și evenimente. Evenimentele de control ne ajută să interacționăm cu controalele vizuale ale interfețelor noastre.
Să luăm același exemplu de buton pe care l-am folosit în lecția noastră anterioară. Am avut acest cod XAML:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
<Window x:Class="BunaLumeWPF.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:BunaLumeWPF" mc:Ignorable="d" Title="MainWindow" Height="350" Width="525" WindowStartupLocation="CenterScreen"> <Grid x:Name="myContainer"> <Button Content="Click!" Margin="189,195,253,104" Background="#FF530909" BorderBrush="#FFFF00B9" Foreground="White"/> </Grid> </Window> |
Când selectăm butonul în editorul vizual, putem vedea acum o listă de evenimente disponibile pentru controlul selectat, aflată tot în panoul Proprietăți din Visual Studio. Cu toate acestea, trebuie să faceți clic mai întâi pe pictograma care arată ca un fulger:
După cum puteți vedea, când selectați un control, panoul Proprietăți vă va permite să comutați între proprietățile și evenimentele de control. Puteți vedea de asemeni și o listă uriașă de evenimente care sunt disponibile pentru butonul nostru, cel mai important dintre acestea fiind, evident, evenimentul Click, care va fi declanșat atunci când faceți clic pe buton. Deoarece pentru asta sunt făcute butoanele, pentru a da clic pe ele :)).
Deci, acum știm unde se află evenimentele butonului nostru. Dar cum specificăm o bucată de cod care ar trebui să fie executată atunci când se declanșează un anumit eveniment? Am explicat mai devreme cel care se ocupă de acest lucru se numește operator de evenimente și mai spuneam și că operatorii de evenimente arata ca și metodele normale, cu singura diferență că au niște parametri mai ciudați. Deci, cum specificăm un operator de evenimente? Scriem noi înșine metoda? Din fericire, nu. Visual Studio este suficient de complex pentru a automatiza acest lucru pentru noi. Tot ce trebuie să facem este să executăm dublu clic în interiorul câmpului de text al unui anumit eveniment, iar Visual Studio va crea automat metoda de operare a evenimentului
Când am făcut dublu clic pe caseta de text a evenimentului Click din lista de evenimente, Visual Studio a creat automat o metodă de operare a evenimentelor, numită Button_Click. Cu toate acestea, dacă vrem să oferim un nume personalizat metodei noastre de gestionare a evenimentului, putem să-i tastăm manual numele:
Dacă vom verifica acum codurile noastre XAML, vom observa atributele butonului au fost ușor modificate:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
<Window x:Class="BunaLumeWPF.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:BunaLumeWPF" mc:Ignorable="d" Title="MainWindow" Height="350" Width="525" WindowStartupLocation="CenterScreen"> <Grid x:Name="myContainer"> <Button Content="Click!" Margin="189,195,253,104" Background="#FF530909" BorderBrush="#FFFF00B9" Foreground="White" Click="OnButtonClick"/> </Grid> </Window> |
Aceasta înseamnă că putem seta manual evenimente controalelor noastre direct în codurile XAML, la fel cum le putem seta proprietățile. Cu toate acestea, trebuie să atribuim o metodă a cărei semnătură este validă pentru semnătura evenimentului specificat. Cu alte cuvinte, parametrii metodei specificate trebuie să se potrivească parametrilor evenimentului. Nu putem specifica orice metodă ca operator de evenimente. Aceasta deoarece atunci când un control declanșează un eveniment, acesta trimite, de obicei, câteva informații suplimentare împreună cu evenimentul, cum ar fi cine a generat evenimentul și proprietățile acelui eveniment. Să aruncăm o privire la operatorul de eveniment generat pentru evenimentul Click al butonului nostru:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
using System.Windows; namespace BunaLumeWPF { public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void OnButtonClick(object sender, RoutedEventArgs e) { } } } |
Observăm că numele funcției este numele pe care l-am specificat când am creat evenimentul și mai observăm și că metoda noastră are doi parametri: object sender și RoutedEventArgs e.
Primul parametru este un tip de obiect, așa cum am explicat într-o lecție anterioară că object este părintele tuturor celorlalte tipuri din .NET. Acesta va indica întotdeauna expeditorul (de aici numele său în engleză, sender) evenimentului sau controlul care a generat evenimentul. Deoarece butonul nostru nu are nume, cum știm cine a generat evenimentul clic? Poate că vrem să schimbăm textul unui buton când efectuăm clic pe el, și avem mai mult de un buton. Cum îi spunem programului pe care buton a fost efectuat clic și a generat evenimentul Click, pentru a putea schimba textul?
Deoarece obiectul expeditor va fi întotdeauna obiectul care a generat evenimentul, putem folosi evident acest parametru sender pentru a spune cine a generat evenimentul. Cu toate acestea, nu este atât de simplu. Am spus deja că object este tipul părinte al tuturor tipurilor în .NET. Aceasta înseamnă că un obiect POATE fi un buton, dar poate fi ȘI altceva. Acest lucru înseamnă că pentru a evita orice confuzie și eroare, trebuie să convertim obiectul expeditor înapoi în tipul care a generat evenimentul, în cazul nostru, înapoi la tipul Button:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
using System.Windows; namespace BunaLumeWPF { public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void OnButtonClick(object sender, RoutedEventArgs e) { ((Button)sender).Content = "Continut Nou"; } } } |
Mai întâi, am convertit obiectul expeditor în tipul Button. Acest lucru ne va oferi un obiect Button, căruia îi putem accesa proprietățile de control, cum ar fi Content, Size, etc. Cu toate acestea, acest lucru poate cauza excepții care ne pot bloca programul, în cazul în care convertim obiectul expeditor la un tip invalid, cum ar fi de exemplu float. Deoarece atât butonul cât și float derivă din tipul de object, compilatorul C# ne permite să convertim expeditorul în float. Cu toate acestea, deoarece expeditorul nu este, evident, un float, acest lucru va genera o eroare. Pentru a evita astfel de pericole, putem folosi operatorul as:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
using System.Windows; namespace BunaLumeWPF { public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void OnButtonClick(object sender, RoutedEventArgs e) { (sender as Button).Content = "Continut Nou"; } } } |
În plus, putem verifica în mod specific dacă un obiect expeditor este de un anumit tip, folosind operatorul is:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
using System.Windows; namespace BunaLumeWPF { public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void OnButtonClick(object sender, RoutedEventArgs e) { if (sender is Button) { (sender as Button).Content = "Continut Nou"; } } } } |
Când facem clic pe butonul nostru, codul de mai sus verifică dacă expeditorul evenimentului este de tip buton și dacă da, va schimba textul acestuia.
Am spus că al doilea parametru, e, este de fapt evenimentul în sine și putem avea acces la parametrii suplimentari pe care îl poartă. Pentru a ilustra mai bine acest lucru, să adăugăm un alt control ferestrei noastre. Glisați și plasați un TextBox din panoul de instrumente peste fereastră, în Visual Designer, sau creați un TextBox în codurile XAML. După aceea, faceți dublu clic pe evenimentul KeyUp din panoul Evenimente, așa cum am arătat deja. XAML ar trebui să arate aproximativ în felul următor:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
<Window x:Class="BunaLumeWPF.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" xmlns:local="clr-namespace:BunaLumeWPF" mc:Ignorable="d" Title="MainWindow" Height="350" Width="525" WindowStartupLocation="CenterScreen"> <Grid x:Name="myContainer"> <Button Content="Click!" Margin="189,195,253,104" Background="#FF530909" BorderBrush="#FFFF00B9" Foreground="White" Click="OnButtonClick"/> <TextBox HorizontalAlignment="Left" Height="23" Margin="145,120,0,0" TextWrapping="Wrap" Text="TextBox" VerticalAlignment="Top" Width="120" KeyUp="TextBox_KeyUp"/> </Grid> </Window> |
Evenimentul KeyUp este evenimentul care este declanșat când apăsăm și eliberăm o tastă, în timp ce controlul este focalizat. Să spunem că vrem să știm când utilizatorul apasă tasta Enter în caseta noastră de text. Din moment ce tocmai am aflat că putem folosi evenimentul KeyUp pentru a ști când utilizatorul tastează în TextBox-ul nostru, tot ce trebuie să facem este să adăugăm o bucată de cod în operatorul de eveniment KeyUp al TextBox-ului, care ne va spune când a fost apăsată tasta Enter. Singurul lucru dificil este acela că… nu știm ce taste vor apăsa utilizatorii. De unde știm dacă vor apăsa Space, Backspace sau Enter? Din fericire pentru noi, putem afla acest lucru. Am spus că parametrul e este evenimentul însuși, alături de toți parametrii săi. În cazul unui TextBox, unul dintre parametrii evenimentului KeyUp este… ei bine, tasta care a generat evenimentul KeyUp. Puteți să vă întrebați: „Dar, nu este expeditorul? Nu ar trebui expeditorul să indice tasta care a fost apăsată?” „Nu este tasta cea care a generat evenimentul?” Ei bine, nu! TextBox-ul este expeditorul, cel care generează evenimentul, tasta apăsată este doar un parametru al evenimentului.
Să accesăm proprietatea care ne va da tasta apăsată:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
using System.Windows; using System.Windows.Input; namespace BunaLumeWPF { public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void TextBox_KeyUp(object sender, KeyEventArgs e) { MessageBox.Show(e.Key.ToString()); } } } |
Deci, putem folosi proprietatea Key a parametrului e pentru a afla ce tastă a fost apăsată. Putem chiar folosi acest lucru în interiorul unei verificări if:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
using System.Windows; using System.Windows.Input; namespace BunaLumeWPF { public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } private void TextBox_KeyUp(object sender, KeyEventArgs e) { if (e.Key == Key.Enter) { MessageBox.Show("Tasta Enter a fost apasata!"); } } } } |
Când veți apăsa tasta Enter în timp ce TextBox-ul este focalizat, va apărea o casetă de dialog care va afișa un text.
Veți folosi rar expeditorul și parametrul e ai evenimentelor, cu toate acestea, ar trebui să știți de existența lor. În orice caz, veți folosi evenimente de control de nenumărate ori. În lecțiile viitoare, voi enumera evenimentele cele mai frecvent utilizate ale fiecărui control.
Tags: controale, evenimente, GUI, interfață grafică cu utilizatorul, XAML
