Passing values between classes using delegates and events

You may need to prepare for this c# Commission of （delegate） And events （event） Knowledge of aspects of ...
Not very clear , All kinds of Google ~
You need to prepare two inheritance and MonoBehaviour Of EventDispatcher Classes and EventListener class .
I'll come here delegate It's written in EventDispatcher In the , You can also create a new class delegate In it , Make it convenient ...

1. // Define delegate events , It defines the types of methods that can be represented 
           
           /** event */
           public delegate void EventHandler(GameObject e);  
           /** collision detection */
           public delegate void CollisionHandler(GameObject e,Collision c);
           /** Trigger detection */
           public delegate void TriggerHandler(GameObject e,Collider other);
           /** Controller collision detection */
           public delegate void ControllerColliderHitHandler(GameObject e,ControllerColliderHit hit);
           /** New levels are loaded */
           public delegate void LevelWasLoadedHandler(GameObject e,int level);

   
   

The Commission is defined , In fact, these are similar to method parameters ... But it's hard to explain ...

Then rewrite MonoBehaviour Those time response functions supported ：
such as OnMouseDown();
So let's define a EventHandler This delegated event ... And then again OnMouseDown Operate on him in the response function ..
If a GameObject Listens for this event and writes the response function （ The response function is the definition The event entrust delegate）, So in rewriting OnMouseDown The function class will call and execute this passed in delegate And the this.gameObject Spread it out .

1. public event EventHandler MouseDown;  
           void OnMouseDown(){  
                   if (MouseDown != null)  
                           MouseDown (this.gameObject); 
           }

   
   
   

Copy code

And so on , Enclosed EventDispatcher class ：

1. using System;
   using UnityEngine;  
   /**  
   *   be based on MonoBehaviour An event dispatch class of  
   * A simple event dispatcher - allows to listen to events in one GameObject from another GameObject
   * 
   * 
   *  Usage: 
   *  Add this script to the object that is supposed to dispatch events.  
   *  In another objects follow this pattern to register as listener at intercept events:
     
       void Start () { 
           EventDispatcher ev = GameObject.Find("someObject").GetComponent<EventDispatcher>();
           ev.MouseDown += ListeningFunction; // Register the listener (and experience the beauty of overloaded operators!)
       } 
   
       void ListeningFunction (GameObject e) { 
           e.transform.Rotate(20, 0, 0); // 'e' is the game object that dispatched the event
           e.GetComponent<EventDispatcher>().MouseDown -= ListeningFunction; // Remove the listener
       } 
        
   *  This class does not implement all standards events, nor does it allow dispatching custom events,  
   *  but you shold have no problem adding all the other methods. 
   * 
   * date: 2013.8.21
   */  
   public class EventDispatcher:MonoBehaviour{
           
           // Define delegate events , It defines the types of methods that can be represented 
           
           /** event */
           public delegate void EventHandler(GameObject e);  
           /** collision detection */
           public delegate void CollisionHandler(GameObject e,Collision c);
           /** Trigger detection */
           public delegate void TriggerHandler(GameObject e,Collider other);
           /** Controller collision detection */
           public delegate void ControllerColliderHitHandler(GameObject e,ControllerColliderHit hit);
           /** New levels are loaded */
           public delegate void LevelWasLoadedHandler(GameObject e,int level);
                    
           
           
           
           public event EventHandler MouseEnter;  
           void OnMouseEnter(){  
                   if (MouseEnter != null)  // If there is a way to register a delegate variable 
                           MouseEnter(this.gameObject); // Calling methods through delegation 
           }
           
           public event EventHandler MouseOver;
           void OnMouseOver(){  
                   if (MouseOver != null)  
                           MouseOver (this.gameObject); 
           }
           
           public event EventHandler MouseExit;  
           void OnMouseExit(){  
                   if (MouseExit != null)  
                           MouseExit (this.gameObject); 
           }
           
           public event EventHandler MouseDown;  
           void OnMouseDown(){  
                   if (MouseDown != null)  
                           MouseDown (this.gameObject); 
           }
           
           public event EventHandler MouseUp;  
           void OnMouseUp(){  
                   if (MouseUp != null)  
                           MouseUp (this.gameObject); 
           }
           
           public event EventHandler MouseDrag;  
           void OnMouseDrag(){  
                   if (MouseDrag != null)  
                           MouseDrag (this.gameObject); 
           }
           
           /** When renderer( Renderers ) Called when visible on any camera OnBecameVisible*/
           public event EventHandler BecameVisible;  
           void OnBecameVisible (){  
                   if (BecameVisible != null)  
                           BecameVisible (this.gameObject);  
           }  
           /** When renderer( Renderers ) Called when not visible on any camera OnBecameInvisible*/
           public event EventHandler BecameInvisible;  
           void OnBecameInvisible (){  
                   if (BecameInvisible != null)  
                           BecameInvisible (this.gameObject);  
           }  
           public event EventHandler Enable;
           void OnEnable(){
                   if(Enable != null)
                           Enable(this.gameObject);
           }
           public event EventHandler Disable;
           void OnDisable(){
                   if(Disable != null)        
                           Disable(this.gameObject);
           }
            public event EventHandler Destroy;
           void OnDestroy(){
                   if(Destroy != null)
                           Destroy(this.gameObject);
           }
           /** Call... Before the camera renders the scene */
           public event EventHandler PreRender;
           void OnPreRender(){
                   if(PreRender != null)
                           PreRender(this.gameObject);
           }
           /** Call... After the camera finishes rendering the scene */
           public event EventHandler PostRender; 
           void OnPostRender(){
                   if(PostRender != null)
                           PostRender(this.gameObject);
           }
           /** Called after the camera scene rendering is completed */
           public event EventHandler RenderObject; 
           void OnRenderObject(){
                   if(RenderObject != null)
                           RenderObject(this.gameObject);
           }
           
   
           
           public event EventHandler ApplicationPause; 
           void OnApplicationPause(){
                   if(ApplicationPause != null)
                           ApplicationPause(this.gameObject);
           }
           /** Sent to all game objects when the player gains or loses focus */
           public event EventHandler ApplicationFocus; 
           void OnApplicationFocus(){
                   if(ApplicationFocus != null)
                           ApplicationFocus(this.gameObject);
           }
           public event EventHandler ApplicationQuit; 
           void OnApplicationQuit(){
                   if(ApplicationQuit != null)
                           ApplicationQuit(this.gameObject);
           }
           
           
           
           public event TriggerHandler TriggerEnter;
           void OnTriggerEnter(Collider other){
                   if(TriggerEnter != null)
                           TriggerEnter(this.gameObject,other);
           }
           public event TriggerHandler TriggerExit;
           void OnTriggerExit(Collider other){
                   if(TriggerExit != null)
                           TriggerExit(this.gameObject,other);
           }
           public event TriggerHandler TriggerStay;
           void OnTriggerStay(Collider other){
                   if(TriggerStay != null)
                           TriggerStay(this.gameObject,other);
           }
           
           public event ControllerColliderHitHandler controllerColliderHit;
             void OnControllerColliderHit(ControllerColliderHit hit){
                   if(controllerColliderHit != null)
                           controllerColliderHit(this.gameObject,hit);
           }
           
       public event CollisionHandler CollisionEnter;  
       void OnCollisionEnter (Collision c){  
           if (CollisionEnter != null)  
               CollisionEnter (this.gameObject, c);  
       }  
            public event CollisionHandler CollisionStay;  
       void OnCollisionStay (Collision c){  
           if (CollisionStay != null)  
               CollisionStay (this.gameObject, c);  
       }  
           
       public event CollisionHandler CollisionExit;  
       void OnCollisionExit (Collision c){  
           if (CollisionExit != null)  
               CollisionExit (this.gameObject, c);  
       }
           
           public event LevelWasLoadedHandler LevelWasLoaded;
           void OnLevelWasLoaded(int level){
                   if(LevelWasLoaded != null)
                           LevelWasLoaded(this.gameObject,level);
           }
   }  

   
   

After writing the dispatch event class, drag it to the component that needs to dispatch the event , Then register and listen , Write below EventListener Class to do the listening step ..
First, you need to get the... On the target component EventDispatcher Components .

1. private EventDispatcher evt = null;
           
           // Use this for initialization
           void Start () {
                   evt = GameObject.Find("Cube1").GetComponent<EventDispatcher>();
           }

   
   
   

Copy code

After getting the target object , The local response function , Add to EventDispatcher Events Entrust to go inside .

1. /** Register listener functions */
           void addEventListener(){
                   // Assign a value to the event type variable of the delegate 
                   evt.MouseDown +=OnMouseDownListener;
                   evt.MouseDrag += OnMouseDragLIstener;
           }

   
   

Copy code

evt.MouseDown It can be simply understood as a delegate,+= The local function （delegate Specified types and parameters ） Assign in , Of course, just remove the monitoring -= La ~~

And then write out the processing function ...

1. /** Event response handler 
            * @param GameObject e  The source of the event GameObject object 
            * <li>  Parameters of the event response function , See EventDispatcher Class Handler The number of parameters 
            * */
           void OnMouseDownListener(GameObject e){
                   print("on mouse down..");
                   e.transform.Rotate(20, 0, 0);
                   // Remove listener function 
                   e.GetComponent<EventDispatcher>().MouseDown -= OnMouseDownListener;
           }
           
           void OnMouseDragLIstener(GameObject e){
                   print("on mouse drag..");
           }
    Copy code 
   
   
    Enclosed EventListener Source code ：
   using UnityEngine;
   using System.Collections;
   /**
   *  Responding to events 
   * */
   public class EventListener : MonoBehaviour {
           
           private EventDispatcher evt = null;
           
           // Use this for initialization
           void Start () {
                   evt = GameObject.Find("Cube1").GetComponent<EventDispatcher>();
                   addEventListener();
           }
           /** Register listener functions */
           void addEventListener(){
                   // Assign a value to the event type variable of the delegate 
                   evt.MouseDown +=OnMouseDownListener;
                   evt.MouseDrag += OnMouseDragLIstener;
           }
           
           // Update is called once per frame
           void Update () {
           
           }
           /** Event response handler 
            * @param GameObject e  The source of the event GameObject object 
            * <li>  Parameters of the event response function , See EventDispatcher Class Handler The number of parameters 
            * */
           void OnMouseDownListener(GameObject e){
                   print("on mouse down..");
                   e.transform.Rotate(20, 0, 0);
                   // Remove listener function 
                   //e.GetComponent<EventDispatcher>().MouseDown -= OnMouseDownListener;
           }
           
           void OnMouseDragLIstener(GameObject e){
                   print("on mouse drag..");
           }
           
   }

   
   

.. Code code play , Bound to the response Cube Go up and try ~~~



It's done ...


There is a problem , Let's study together , Learning together , Progress together ~~