Is "delegates" in "Update", efficient or worst

Question

I have 100 objects in the game, I need to move every cube. I know 100 "Updates" in 100 objects will cause performance issue.

So I design like only one class have "Update". The same class contains "event" using "delegate"; T$$anonymous$$s event is calling in "Update".

 using UnityEngine;
 namespace com.Test.One
 {
     public class Controller1 : MonoBehaviour
     {
         public delegate void OtherUpdateDelegate();
         public static event OtherUpdateDelegate OtherUpdate;
         private static Controller1 instance;
         public static Controller1 Instance
         {
             get { return instance;}
         }
         private void Awake()
         {
             if(instance != null && instance != t$$anonymous$$s)
             {
                 Destroy(t$$anonymous$$s.gameObject);
             }
             else
             {
                 instance = t$$anonymous$$s;
             }
         }
        /// <summary>
        /// events for calling custom Update fuctions of other scripts 
        /// </summary>
         private void Update()
         {
             if(OtherUpdate != null)
             {
                 OtherUpdate();
             }
         }
 
 
     }
 }

Other classes are adding " custom update " into the event, and performing their movement or other actions

 using UnityEngine;
 namespace com.Test.One
 {
     public class MovingObjects : MonoBehaviour
     {
 
         [SerializeField] private float speed = 5;
         [SerializeField] private float yMax = 3, yMin = -3;
         [SerializeField]
         private float currentSpeed;
         private void Start()
         {
             currentSpeed = speed;
             if (Controller1.Instance != null)
             {
                 Controller1.OtherUpdate += MyUpdate;
             }
         }
         private void OnDisable()
         {
             if (Controller1.Instance != null)
             {
                 Controller1.OtherUpdate -= MyUpdate;
             }
         }
         private void MyUpdate() // custom update
         {
             transform.Translate(transform.up * currentSpeed * Time.deltaTime);
             Debug.Log("" + transform.position.y);
             if (transform.position.y >= yMax)
             {
                 currentSpeed = -(speed);
             }
             if (transform.position.y <= yMin)
             {
                 currentSpeed = (speed);
             }
         }
     }
 }

Is t$$anonymous$$s efficient way or worst. If worst any alternative solution there?

Answer 1

If you plan to register many methods to the same multicast delegate, it will not be very efficient because the way the multicast delegate handles. A multicast delegate is essentially a doubly linked list of multicast delegate instances. So each delegate instance has next and a previous reference to the next and previous instance in the chain. Linked lists would actually be a great and flexible way to handle adding and removing instances. However the way "combining" of delegates work all instances are cloned whenever you add or remove an instance. So if you have 1000 delegates combined in a single multicast delegate you will clone all 1000 instances when you add another one or when you remove one.

It would be more efficient when you simply use a List<Action> where you simply add all the method you want to invoke and just iterate through that List in Update and invoke them one by one. (that's what a multicast delegate does anyways). Since the order of the registered methods usually don't matter when you want to remove a method you could use the "replace with last, delete last" approach. T$$anonymous$$s avoids the down s$$anonymous$$fting of the internal array elements when you remove the first element (or an element close to the start).

Though instead of storing delegates it often makes more sense to implement a custom interface and store the object references in a list. Delegates can be quite demanding especially when you often add / remove instances.

Note that you currently used Start to register and OnDisable to unregister the delegate. T$$anonymous$$s is the wrong pairing. The partner of Start is OnDestroy. Or if you like to use OnDisable you would use the pair OnEnable / OnDisable. Start is only called once in the lifetime of an object. OnDisable is called each time the object is disabled.

Answer 2

I followed the @Bunny83's instructions. It's work awesome.

Here is the code

 public class Controller3 : MonoBehaviour
 {
     private static Controller3 instance;
     public static Controller3 Instance
     {
         get { return instance; }
     }
     private List<Action> movingObjectList = new List<Action>();
     private void Awake()
     {
         if(instance != null && instance != t$$anonymous$$s)
         {
             Destroy(gameObject);
         }
         else
         {
             instance = t$$anonymous$$s;
         }
     }
     private void Update()
     {
         //Debug.Log("movingObjectList.Count:" + movingObjectList.Count);
         for (int i = 0; i < movingObjectList.Count; i++) 
         {
 
             if (movingObjectList.Count > i)
             {
                 //Debug.Log("" + i);
                 if (movingObjectList[i] != null )
                 {
                     movingObjectList[i].Invoke();
                 }
             }
         }
     }
 
     public void AddAction(Action action)
     {
         Debug.Log("AddAction " );
         if (!movingObjectList.Contains(action))
         {
             movingObjectList.Add(action);
         }
     }
     public void RemoveAction(Action action)
     {
         Debug.Log("RemoveAction ");
         if (movingObjectList.Contains(action))
         {
             movingObjectList.Remove(action);
         }
     }
 }

Controller3 script attached with one empty game object

public class MovingObject3 : MonoBehaviour {

     [SerializeField] private float speed = 5;
     [SerializeField] private float yMax = 3, yMin = -3;
     [SerializeField]
     private float currentSpeed;
     private void OnEnable()
     {
         StartCoroutine(I_DelayedActionAdd());
     }
     private void AddToAction()
     {
         Debug.Log("OnEnable" + Controller3.Instance.ToString());
         currentSpeed = speed;
         if (Controller3.Instance != null)
         {
             Controller3.Instance.AddAction(MyUpdate);
         }
     }
     private IEnumerator I_DelayedActionAdd()
     {
         if (gameObject.activeInHierarchy)
         {
             yield return new WaitForSeconds(1);
             if (gameObject.activeInHierarchy)
             {
                 AddToAction();
             }
         }
     }
     private void OnDisable()
     {
         if (Controller3.Instance != null)
         {
             Controller3.Instance.RemoveAction(MyUpdate);
         }
     }
     private void MyUpdate() // custom update
     {
         transform.Translate(transform.up * currentSpeed * Time.deltaTime);
         //Debug.Log("" + transform.position.y);
         if (transform.position.y >= yMax)
         {
             currentSpeed = -(speed);
         }
         if (transform.position.y <= yMin)
         {
             currentSpeed = (speed);
         }
     }
 }

MovingObject3 attached with 1000 of object

working smoothly in the Unity editor without any lag

Is "delegates" in "Update", efficient or worst

2 Replies

Your answer

Welcome to Unity Answers

Follow this Question

Related Questions