Object Orientation in C# is a fundamental concept in game programming with Unity. This chapter, 16.13, focuses specifically on Delegates and Events, two key concepts that enable effective and organized communication between objects in your game.
Delegates in C# are similar to function pointers in C++, but they are much safer and easier to use. A delegate is a type that represents references to methods with a particular parameter and return type. You can use a delegate object to call the method it references in a safe way.
To define a delegate, you use the keyword 'delegate' followed by the return type and the name of the delegate. Then you specify the parameters in parentheses. For example, 'delegate void MyDelegate(int a);' defines a delegate called MyDelegate that references methods that return void and accept a single parameter of type int.
Once a delegate is defined, a delegate object can be created to represent any method that matches the delegate type. For example, if you have a method called 'MyMethod' that corresponds to the delegate type MyDelegate, you can create a delegate object to represent MyMethod like this: 'MyDelegate md = new MyDelegate(MyMethod);'.
Once you have a delegate object, you can call the method it represents using the delegate object. For example, 'md(10);' calls the MyMethod method with parameter 10.
Delegates are used in many places in C# and .NET, including for events, callbacks, and LINQ. They are a powerful tool for creating code that is flexible, reusable, and organized.
Events in C# are a way to notify other objects when something happens. An event is declared using the 'event' keyword followed by the delegate type and the event name. For example, 'event MyDelegate MyEvent;' declares an event called MyEvent that uses the delegate type MyDelegate.
To trigger an event, you call the event as if it were a method. For example, 'MyEvent(10);' triggers the MyEvent event with parameter 10.
To respond to an event, an object must subscribe to the event. It does this by creating a method that matches the event's delegate type and then adding that method to the event using the '+=' operator. For example, if you have a method called 'MyEventHandler' that matches the delegate type MyDelegate, you can subscribe to the MyEvent event like this: 'MyEvent += MyEventHandler;'.
When the event is fired, all methods that subscribed to the event are called. This allows you to create code that responds in a flexible and organized way to things that happen in your program.
Events and delegates are used extensively in Unity game programming. For example, they can be used to notify other objects when a player reaches a certain point in the game, when an enemy is defeated, or when a level is completed. They can also be used to organize code so that it is easy to understand, reuse, and maintain.
In summary, delegates and events in C# are powerful tools for creating game code that is flexible, organized, and reusable. They are a fundamental concept in programming games with Unity and a solid understanding of how they work is essential for any game developer.
