Events (X#X)

ივენტი ზოგადათ შეგვიძლია განვსაზღვროთ, როგორც დელეგატის პროპერთი, ანუ შეგვიძლია ვაკონტროლოთ ივენტისთვის დელეგატის გადაცემის პროცესი. როგორც დასახელება მიგვანიშნებს ივენტი რეაგირებს რაიმე წინასწარ განსაზღვრულ შემთხვევაზე მაგალითად: გრაფიკული ინტერფეისის დროს პროგრამაში მუდმივათ მიდის პარალელური სრიდი, იტერაციულად ურბენს ყველა კონტროლის ობიექტის ივენტს (buttons, textBoxs, comboBoxs და ა.შ.), ამ დროს თუ ჩვენი დაწერილი ფუნქცია და ჩადებულია მოცემული ობიექტის ივენტში და ამასთანავე მოხდა იმ კლავიშზე დაჭერა რომელშიც ფუნქცია გვაქვს ჩადებული, აღიძვრება ივენტი და მოახდენს ჩვენი ფუნქციის გაშვებას. Visial Studio -ში Form აპლიკაციებზე მიშაობისას ხშირ შემთხვევაში აღარც გვიწევს იმაზე ფიქრი თუ როგორ გადავცეთ ფუნქცია ძირითად სრიდს, კონკრეტული ობიექტზე კლიკის შემთხვევაში შესასრულებლათ, ამ ყველაფერს visual studio ავტომატურად აკეთებს.
ივენტის გამოყენების მთავარი უპირატესობა არის ის, რომ კლასი რომელიც ივენტს გამოსცემს (აღძრავს) არ ჭირდება რომ იცოდეს თუ რას მოიმოქმედებს მომხმარებელი. მარტივად, რომ ვთქვათ დელეგატ EventHandler-ის დახმარებით სასურველი ფუნქცია შეგვაქვს ივენტის აღმძვრელი ფუნქციის შიგნით, სადაც ფუნქცია წარმოდგენილია EventHandler ის ტიპის ივენტის სახით. თვითონ ივენტი არ ის დაფუძნებული  EventHandler დელეგატზე, რომელსაც პროგრამის მსვლელობის დროს მომხმარებელი უბრალოდ ამატებს. ივენტის გასაგებათ მოვიყვანოთ მარტივი მაგალითი.     სანამდე მოხდება მიმართვა B კლასზე რომ მიაწოდოს სიდიდეები და მეთოდები რაიმე A კლასს მანამდე ბევრი რამე შეიძლება მოხდეს.  მოვლენების თანმიმდევრობა შემდეგია. მაგალითად პროგრამის მუშაობის პერიოდში, კლასი შეიძლება შიცავდეს სიდიდეს რომელიც პროგრამის მსვლელობის დროს იცვლის მნიშვნელობას და თუ გვინდა რომ მოცემული ცვლილების შესაბამისად შესრულდეს სხვადასხვა სახის ფუნქცია საჭიროა გამოვიყენოთ event-ი. event-ი დელეგატისთვის იგივე დანიშნულებისაა როგორც პარამეტრისთვის პროპერთი.  ივენტი არის მოქმედება რომელიც რომელიც ხდება რომელიმე ობიექტზე და მასზე მოქმედებს ისე, როგორც კლასის მომხმარებელი გადაწყვეტს.

ივენტის გამოცხადება

ივენტი გამოცხადებული როგორც ფსევდო ცვლადი მაგრამ დელეგატზე დაფუძნებით. ამიტომ, ივენტის გამოცხადებისთვის, პირველრიგში საჭიროა გქონდეს დელეგატი, რომელის საფუძველზეც შეიქმნება ივენტი. ქვემოთ მოცემულია მაგალითი:

using System;

delegate void dlgSimple();

class Exercise
{
    public static void Welcome()
    {
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
    }
}

To actually declare an event, you use the event keyword with the following formula:

[attributes] [modifiers] event type declarator;
[attributes] [modifiers] event type member-name {accessor-declarations};

The attributes factor can be a normal C# attribute.

The modifier can be one or a combination of the following keywords: publicprivate,protectedinternalabstractnewoverridestaticvirtual, or extern.

The event keyword is required. It is followed by the name of the delegate that specifies its behavior. If the event is declared in the main class, it should be made static. Like everything in a program, an event must have a name. This would allow the clients to know what (particular) event occurred. Here is an example:

using System;

delegate void dlgSimple();

class Exercise
{
    public static event dlgSimple Simply;

    public static void Welcome()
    {
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
    }
}

After declaring the event, you must define a method that calls the event. Here is an example:

using System;

delegate void dlgSimple();

class Exercise
{
    public static event dlgSimple Simply;

    public static void Welcome()
    {
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
    }

    public static void SayHello() { Simply(); }
}

When the event occurs, its delegate would be invoked. This specification is also referred to as hooking up an event. As the event occurs (or fires), the method that implements the delegate runs. This provides complete functionality for the event and makes the event ready to be used. Before using an event, you must combine it to the method that implements it. This can be done by passing the name of the method to the appropriate delegate, as we learned when studying delegates. You can then assign this variable to the event’s name using the += operator. Once this is done, you can call the event. Here is an example:

using System;

delegate void dlgSimple();

class Exercise
{
	public static event dlgSimple Simply;

	public static void Welcome()
	{
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
	}

	public static void SayHello()
	{
		Simply();
	}

	static int Main()
	{
		Simply += new dlgSimple(Welcome); SayHello();

		return 0;
	}
}

Instead of the += operator used when initializing the event, you can implement add andremove of the event class. Here is an example:

using System;

delegate void dlgSimple();

class Exercise
{
	public event dlgSimple Simply
	{
		add {
			Simply += new dlgSimple(Welcome);
		} remove {
			Simply -= new dlgSimple(Welcome);
		}
	}

	public void Welcome()
	{
	Console.WriteLine("Welcome to the Wonderful World of C# Programming!");
	}
}
Link --->http://www.functionx.com<---
1) blackwasp.co.uk     2)Wikipedia   3)Anonimous Merhods & Lambda expresions
Advertisements
This entry was posted in C# Programming. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s