Unity Invoke : Exécuter vos méthodes

Unity Invoke offre un moyen d’exécuter une méthode au sein de votre classe, avec ou sans délai, en utilisant le nom de la méthode. Cependant, il est important de noter que bien qu’Invoke soit un outil utile, il existe des alternatives plus élégantes et contrôlables, comme les coroutines. Dans cet article, nous allons explorer comment utiliser Invoke et examiner ses alternatives.

Table des matières

• Utilisation standard d’Invoke
• Améliorer la réutilisation du code avec Invoke
• Annuler Invoke
• Invoke avec des paramètres (Coroutines)
• Arrêt des Coroutines
• Invoke vs. Coroutines

Utilisation standard d’Invoke

Commençons par l’utilisation de base d’Invoke :

using UnityEngine;

public class InvokeMonoBehaviour : MonoBehaviour
{
    private void Start()
    {
        // Invoquer la fonction "LaunchMissile" après un délai de 3 secondes
        Invoke("LaunchMissile", 3f);
    }

    private void LaunchMissile()
    {
        // Actions à effectuer
    }
}
    

Dans le code ci-dessus, nous invoquons la fonction « LaunchMissile » après un délai de 3 secondes. Veuillez noter que si vous définissez le délai à 0, la fonction sera exécutée à la fin de la frame. Dans de tels cas, il peut être plus pratique d’appeler la fonction directement. Un autre détail important est que même si vous désactivez le GameObject après avoir appelé Invoke, la fonction sera toujours exécutée jusqu’à ce que l’objet soit détruit.

Améliorer la réutilisation du code avec Invoke

Un inconvénient de l’utilisation d’Invoke est qu’elle repose sur une chaîne de caractères représentant le nom de la fonction. Si vous renommez la fonction lors de la refactorisation, cela entraînera une erreur. Pour remédier à cela, vous pouvez utiliser « nameof« , à partir de C# 6 :

using UnityEngine;

public class InvokeMonoBehaviour : MonoBehaviour
{
    private void Start()
    {
        // Invoquer la fonction "LaunchMissile" après un délai de 3 secondes en utilisant "nameof"
        Invoke(nameof(LaunchMissile), 3f);
    }

    private void LaunchMissile()
    {
        // Actions à effectuer
        Debug.Log("Missile lancé");
    }
}
    

Annuler Invoke

Pour annuler un Invoke, vous pouvez utiliser la méthode CancelInvoke. Voici comment faire :

private void Annuler()
{
    // Annuler tous les Invokes dans le MonoBehaviour
    CancelInvoke();

    // Annuler un Invoke spécifique pour "LaunchMissile"
    CancelInvoke(nameof(LaunchMissile));
}
    

Invoke avec des paramètres (Coroutines)

Malheureusement, Invoke ne vous permet pas de transmettre des arguments. Pour travailler avec des paramètres, vous devrez utiliser des coroutines. Voici un exemple :

using System.Collections;
using UnityEngine;

public class InvokeCoroutine : MonoBehaviour
{
    private void Start()
    {
        StartCoroutine(LaunchMissile(3f, 5));
    }

    private IEnumerator LaunchMissile(float délai, int nombre)
    {
        yield return new WaitForSeconds(délai);

        // Effectuer vos actions
    }
}
    

Les coroutines fonctionnent différemment des méthodes standard. Elles ont un type de retour IEnumerator et doivent inclure au moins une instruction yield, ce qui force une pause dans l’exécution. Pour invoquer une coroutine, utilisez StartCoroutine, et vous pouvez toujours utiliser le nom de la fonction ou nameof, bien que cela ne soit pas recommandé.

Arrêt des Coroutines

Pour arrêter une coroutine, utilisez la méthode StopCoroutine. Il est conseillé d’arrêter une coroutine en utilisant sa référence plutôt que son nom ounameof. Voici un exemple :

using System.Collections;
using UnityEngine;

public class InvokeCoroutine : MonoBehaviour
{
    private Coroutine _coroutineLaunchMissile;

    private void Start()
    {
        // Stockez la référence dans une propriété
        _coroutineLaunchMissile = StartCoroutine(LaunchMissile(3f, 5));
    }

    private IEnumerator LaunchMissile(float délai, int nombre)
    {
        yield return new WaitForSeconds(délai);

        // Effectuer vos actions
    }

    private void StopCoroutineMissile()
    {
        // Arrêter toutes les coroutines dans le MonoBehaviour
        StopAllCoroutines();

        // Arrêter une seule coroutine
        StopCoroutine(_coroutineLaunchMissile);
    }
}
    

Invoke vs. Coroutines

Selon la documentation d’Unity, les coroutines sont plus rapides que l’utilisation d’Invoke. Les coroutines cessent de s’exécuter lorsqu’un GameObject est désactivé ou détruit, tandis qu’Invoke continue de fonctionner tant que l’objet existe. Les coroutines peuvent être enchaînées et offrent une variété d’instructions yield pour répondre à divers cas d’utilisation :

• WaitUntil : Met en pause l’exécution jusqu’à ce qu’une fonction ou un délégué spécifié retourne true.
• WaitWhile : L’inverse de WaitUntil.
• WaitForSeconds : Retard de plusieurs secondes.
• WaitForSecondsRealtime : Retard en utilisant le temps unscaled.
• WaitForEndOfFrame : Retard se finissant juste avant la fin du rendu de la frame.
• WaitForFixedUpdate : Utile pour la physique.

Pour une compréhension complète des coroutines, veuillez consulter la documentation complète d’Unity.

En conclusion, bien qu’Invoke soit une méthode fonctionnelle pour invoquer des fonctions dans Unity, les coroutines offrent de meilleures performances, un meilleur contrôle et une approche plus robuste pour gérer des scénarios complexes. Considérez l’adoption de coroutines pour vos projets Unity afin d’améliorer l’efficacité.