Invokes vs Coroutines || Qual eu devo usar?

Na programação nem sempre o que é mais prático é o mais eficiente, escolher bem os nossos códigos, é crucial.

Pois, muitas vezes um comando que parece inofensivo, quando usado excessivamente, pode prejudicar a performance do jogo como um todo.

E quando usamos comandos mais eficientes, a experiência de gameplay do jogador, melhora consideravelmente.

Invokes vs Coroutines

Durante a criação de nossos jogos, iremos constantemente nos deparar com a necessidade de chamar alguma função após determinado tempo.

Por exemplo, destruir algo, ficar um tempo sem tomar dano, criar loops para executar determinada função, etc.

E aqui existem várias soluções e inclusive você mesmo pode criar sua própria lógica para resolver isso.

Mas, dentre as mais utilizadas estão o uso de Invokes e Coroutines, que são comandos que encaixam muito bem aqui.

Pois, ambos os comandos nos permitem chamar uma função após esperar determinado tempo.

Porém, é preciso entender como funcionam e saber quais são as vantagens e desvantagens de cada uma delas.

Como usar Invokes?

Uma das grandes vantagens de utilizar Invokes é sua praticidade, com uma linha é possível chamar métodos, e funções.

E com InvokeRepeating, por exemplo, é fácil criar um loop no código que execute determinada função.

E para usar um Invoke você basicamente usa o comando: Invoke(“NomeDaFunção”, 2f), e está feito.

Pois, no primeiro parâmetro você passou o nome da função por String entre as aspas, e depois o tempo em float.

E esse float vai ser o tempo que o código vai esperar para chamar a função desejada.

Mas no InvokeRepeating, passamos um parâmetro a mais, e que determina o tempo do loop das próximas execuções.

Como usar Coroutines?

As Corrotinas basicamente precisam de 2 passos, uma é o comando que vai inicia-las e outro é uma função Ienumerator.

E por terem um tipo que não é void, logo exigem um retorno, como todo método que tem tipo.

E aqui usamos o Yield, que basicamente vai pedir para fazermos o aguardo de algo, que quase sempre é um tempo.

Então, você cria uma função Ienumerator e passa o nome, e dentro da função precisamos usar o Yield return.

E dessa forma retornaremos algo, se você escolher para retornar null, ele executa a função e sai dela.

Mas também podemos escolher outras opções como WaitForSeconds, por exemplo, e passar um tempo de espera.

E após a função estar pronta, basta usar o StartCoroutine (Função()), e chamar a função dentro dos parenteses.

E podemos perceber que as Corrotinas são um pouco mais elaboradas, mas ainda assim são práticas de usar.

Troque, seus Invokes por Corrotinas!

Agora quando comparamos às duas, temos grandes motivos para abandonar o uso de Invokes nos códigos.

Pois, os Invokes nos traz uma série de complicações, e que podem prejudicar demais a performance dos nossos jogos.

Por exemplo, passando o nome da função através de uma string, a Unity não indica onde está o método em uso.

E isso em um código muito extenso, pode fazer você pensar que a função não esteja sendo utilizada.

E outro problema é se por acaso você renomear alguma função, todos os Invokes irão falhar por não encontra-la.

Pois, a string precisa ser exatamente igual, em um projeto muito grande com vários scripts isso de torna um problema.

Outro ponto que desfavorece o uso de Invokes é que ele faz a busca por uma lista de métodos através de strings.

E isso é um trabalho muito pesado para o processamento, e pode prejudicar demais a performance do seu jogo.

Outro ponto negativo é o fato de não podermos passar parâmetros para as funções que são chamadas.

Coroutines e suas vantagens:

Por chamarmos um método e não uma String, aqui a Unity consegue encontrar facilmente onde está esse método no código.

E Corrotinas podem ser pausada no meio da execução, sem interferir na lógica da thread principal do jogo.

Pois, rodam em uma thread paralela, assim qualquer pausa feito no código, não trava a lógica principal do jogo.

Por exemplo, mecânicas de carregamento assíncrono são baseadas em Corrotinas, devido a essa particularidade.

Pois, enquanto o jogo roda normalmente, a Corrotina já faz o carregamento de uma próxima cena.

E aqui também podemos passar parâmetros para executar as funções, aumentando nossas possibilidades.

Em resumo, todas as desvantagens no uso de Invokes, são bem executados utilizando as Corrotinas.

E muitos programadores defendem a ideia de que o Invoke é obsoleto e deveria ser retirado das funções.

Pois, sua única grande vantagem sobre Corrotinas, é a praticidade de chamar funções com apenas uma linha de código.