‫Tudo bem, então nesta palestra, você aprenderá sobre delegados e eventos multicast.
‫Portanto, vamos primeiro explorar o problema.
‫Imagine que estamos desenvolvendo um videogame do zero.
‫Nosso código é uma combinação de bibliotecas de gráficos e áudio e a lógica do nosso player.
‫Então, vamos começar a codificá-lo.
‫Considere as seguintes classes simples.
‫Então, em primeiro lugar, temos essa classe de renderização, que no início do jogo, queremos habilitar o mecanismo de
‫renderização e começar a desenhar os visuais.
‫Então, vai renderizar e depois começar a desenhar visuais.
‫E também, quando o jogo acabar, queremos parar nosso motor de renderização.
‫Portanto, temos esse método game over que irá parar o mecanismo de renderização.
‫Portanto, aqui estou apenas usando as instruções da linha direita do console.
‫Isso, é claro, seria um código muito mais complexo e, então, realmente faria alguma coisa.
‫No nosso caso.
‫Estamos apenas tentando entender o conceito de delegados multicast, bem como eventos.
‫É por isso que vamos exibi-lo apenas por meio de uma instrução de linha vermelha no console.
‫Essa é a nossa classe de renderização.
‫Agora vamos dar uma olhada em nossa classe de sistema de áudio.
‫Então, aqui no sistema de áudio, também temos esse método de jogo de dardos, que apenas iniciará o sistema de áudio
‫e reproduzirá algum áudio.
‫E então temos o método game over, que basicamente irá parar o sistema de áudio.
‫E, finalmente, temos um jogador e o jogador tem um nome de jogador e temos este construtor simples onde apenas
‫definimos esse nome com base no que foi passado para o objeto quando ele foi criado.
‫E você também tem os métodos de início de jogo e de final de jogo.
‫OK, então este irá gerar uma ideia no jogador e este irá apenas remover
‫o jogador com aquele ID específico que atribuímos como o nome do jogador.
‫OK, então essas são nossas três classes e vou mantê-las bem simples com elas.
‫Portanto, vamos prosseguir para o nosso método principal.
‫Então, dentro de nosso método principal, vamos agora criar objetos desses sistemas.
‫Então, primeiro do sistema de áudio e depois do mecanismo de renderização.
‫Muito simples, apenas objetos simples aqui.
‫E então também criamos dois jogadores com o ID.
‫Então nós temos esse jogador, um que é Duco, e então o jogador dois, que será o doggle Silva.
‫Portanto, precisamos iniciar nosso mecanismo de renderização, nosso sistema de áudio e estimular os jogadores chamando o método de início
‫de jogo de cada uma das classes.
‫Então, vamos apenas fazer isso.
‫E vou fazer desta forma, então vou apenas dizer que o sistema de áudio que inicia o mecanismo de renderização do jogo não
‫executa um jogo e o jogador para iniciar o jogo cada um.
‫E então apenas dizemos que o jogo está em execução.
‫Pressione qualquer tecla para encerrar o jogo.
‫Então, o que queremos fazer agora é basicamente encerrar o jogo assim que o jogador tiver que pressionar o botão.
‫OK, então é claro que seria muito mais complexo.
‫Digamos que o jogador pressione todos os quatro ou no menu de opções, ele fecha o jogo, então a próxima quadra
‫seria executada.
‫Portanto, o próximo código seria, é claro, chamar o sistema de áudio, o mecanismo de renderização do método game over, o método
‫game over, bem como os métodos jogador um jogador para o game over.
‫OK, então vamos cuidar disso.
‫Vamos adicionar isso aqui também.
‫E, a propósito, precisaremos ler as instruções porque, caso contrário, ele irá desligá-lo diretamente.
‫Então, deixe-me adicionar rapidamente uma declaração de leitura aqui para que possamos realmente pressionar manualmente uma tecla e, em seguida, desligar
‫tudo e basicamente o jogo termina.
‫Então, vamos executar isso bem rápido e ver o que vai acontecer.
‫Portanto, vemos que o sistema de áudio iniciado já está tocando, o mecanismo de renderização foi iniciado.
‫Agora vemos o visual e os jogadores são gerados.
‫Então, jogador um e jogador para o nosso lugar.
‫Agora o jogo está rodando e podemos brincar com ele.
‫E então, quando queremos terminar, pressionamos uma tecla.
‫Vou pressionar uma tecla e você verá o mecanismo de renderização inicializado, o sistema de áudio parado e
‫removemos os dois reprodutores.
‫Portanto, foi um grande esforço configurar isso.
‫E imagino que tenhamos que fazer isso com muito mais coisas.
‫E pode haver algumas coisas que podem dar errado.
‫Direito.
‫Digamos que adicionemos mais sistemas, então isso se torna muito mais complexo, então podemos facilmente esquecer de chamar
‫o método start game ou game over.
‫Ou, pior ainda, poderíamos chamar um desses métodos duas vezes, o que poderia causar todos os tipos de
‫problemas e exigir que colocássemos muitos códigos de proteção.
‫Portanto, teríamos que realmente nos certificar de que esse objeto está vivo?
‫Ele chamou esse método ou deve ter chamado os métodos policiais de muito complicado?
‫E é aqui que os delegados multicast são úteis.
‫Um delegado multicast é um delegado que funciona como uma lista.
‫O Word pode armazenar uma referência a mais de um método, e é basicamente isso.
‫Ok, isso parece um tanto complexo, mas vamos construí-lo e então provavelmente fará mais sentido.
‫Então, vamos criar uma classe estática chamada gerenciador de eventos de jogo.
‫Assim.
‫Tudo bem, então vamos em frente e criar um novo.
‫Aula aqui.
‫E vou chamá-lo de gerenciador de eventos de jogo.
‫Certo, então este gerenciador de eventos do jogo agora terá um delegado.
‫Vou criar um novo delegado chamado Game Event.
‫Portanto, não retornará nada, mas será de delegado rígido e será público para que
‫possamos usá-lo fora desta classe.
‫OK, então vimos como os delegados em geral funcionam.
‫E vamos usar esse delegado agora para nos permitir basicamente adicionar mais do que apenas um evento a ele.
‫Portanto, vamos criar as duas variáveis chamadas no início do jogo e no final do jogo, e elas serão eventos do tipo fora do
‫jogo.
‫Portanto, eles estarão fora do tipo de nossos delegados.
‫OK, então este será um delegado de evento de jogo e este será um delegado de evento de jogo.
‫Portanto, temos essas duas variáveis de delegado que podemos usar agora.
‫Então, de volta às nossas três aulas.
‫Vamos começar o jogo e os métodos de final de jogo para o início do jogo e os delegados do jogo.
‫Além disso, não há necessidade de que esses métodos se tornem públicos.
‫Então, vamos passar ao sistema de áudio e agora vamos tornar esses dois
‫métodos privados, porque não precisamos expô-los, pois vamos usar o construtor do sistema de áudio para adicionar ou assinar os
‫eventos.
‫Então, aqui, o melhor lugar para adicionar nossos métodos ao jogo, delegados MENAGED, é de dentro do próprio
‫construtor.
‫OK, é isso que estamos fazendo aqui.
‫E quando um objeto é criado, seu método será automaticamente adicionado aos delegados ou, em outras palavras,
‫eles irão se inscrever neles.
‫Então o que vai acontecer agora é que nosso jogo inicial e nosso método de fim de jogo serão
‫adicionados ao gerenciador de eventos do jogo no delegado de Início de Jogo.
‫E estamos usando o sinal de mais igual aqui para dizer, OK, queremos adicionar este método a esse delegado multicast.
‫Basicamente, estamos nos inscrevendo nele e aguardando que esse evento seja acionado, porque assim
‫que esse evento for acionado, nosso método será chamado, OK.
‫Então, o legal é que agora podemos fazer a mesma coisa com a classe do mecanismo de renderização e a classe do jogador.
‫Portanto, o que é importante aqui é que estou usando o sinal de mais igual e não apenas o sinal de igual, portanto,
‫não o estou atribuindo.
‫E veremos mais tarde o que uma assinatura significaria e o que fará por nós.
‫Mas aqui estamos apenas adicionando outro.
‫Método para o nosso coletor de eventos, por assim dizer, nosso gerente de eventos.
‫OK, ele está coletando todos os eventos ou métodos que devem ser executados.
‫Portanto, é um delegado multi-elenco.
‫Agora, vamos fazer a mesma coisa com nosso mecanismo de renderização.
‫Eu gostaria que você fizesse isso sozinho.
‫Então passe o vídeo bem rápido e tente atribuir o mesmo código ou construir o mesmo código que fizemos
‫no sistema de áudio aqui.
‫OK, antes de mais nada, certifiquei-me de que meus métodos serão privados, pois
‫não precisamos mais expô-los, pois isso não é necessário, nunca os chamaremos fora desta classe.
‫É por isso que é sempre uma boa prática torná-los privados.
‫O que podemos chamar, no entanto, é o construtor certo, para que possamos criar um objeto de nosso mecanismo de
‫renderização, pois é público.
‫Portanto, agora podemos ir em frente e adicionar nosso método START ao início contínuo de nosso gerenciador de eventos de jogo também.
‫E o mesmo vale para o fim do jogo.
‫Então, aqui também estamos usando mais igual.
‫Portanto, estamos dizendo que estamos assinando os eventos on game start e on game over.
‫Basicamente, estamos dizendo que assim que o evento de início do jogo for acionado, chame também nosso método de início de jogo, por
‫favor.
‫Por nosso, quero dizer que os motores de renderização iniciam o método de jogo.
‫Então, ele chamará esse método.
‫E, claro, se o jogo acabou, o método de fim de jogo será denominado este aqui.
‫É assim que estamos usando a abordagem agora.
‫Pequeno desafio para você.
‫Faça a mesma coisa na classe de jogadores, por favor.
‫OK, então, em primeiro lugar, espero que você passe e, bem, não vou garantir que esses dois métodos sejam privados, porque ninguém
‫deve chamar o método de início de jogo e de término de jogo de fora
‫dele .
‫Mas então já temos um construtor aqui, e vou apenas usar esse construtor para inscrever os
‫métodos de início de jogo, início de jogo para os eventos de início de jogo e eventos de fim de
‫jogo.
‫OK, então agora em nosso gerenciador de eventos de jogo, vamos adicionar métodos estáticos públicos para disparar os eventos do método
‫principal.
‫Então aqui podemos então.
‫Chame de, bem, basicamente execute este evento, porque agora neste ponto, bem, depois que todos esses engines de
‫renderização, sistemas de áudio e players forem criados, assim que este evento for disparado,
‫ele executará algo.
‫Mas não dissemos realmente o que deveria acontecer se isso acontecer.
‫Portanto, se esse evento for disparado, vamos criar um método estático para disparar no início do jogo.
‫Portanto, este método aqui, bem, em primeiro lugar, verifique se o evento de início do jogo não está vazio,
‫o que significa que outros métodos já o assinam, o que basicamente será o caso assim que criarmos o mecanismo de
‫renderização.
‫E esse código aqui é executado, por exemplo, ou o sistema de áudio é criado e esse código é executado ou o
‫player é criado e esse código é executado.
‫OK, então esta afirmação aqui será verdadeira.
‫Portanto, o evento de jogo do evento START em andamento não ficará vazio, o que significa que não será nulo, e então este
‫código aqui será executado.
‫Então, o que vai fazer agora é dizer que o jogo começou e, em seguida, chamará o início do
‫jogo, que acionará todos os métodos inscritos neste evento.
‫O que significa que uma vez que chamamos este método aqui, este evento do jogo, por assim dizer,
‫uma vez que o chamamos, este método é executado aqui.
‫Este método é executado assim como este método será executado, e veremos isso em breve
‫também.
‫OK, então esse é o início do jogo.
‫Então é assim que vamos acioná-lo.
‫E apenas chamar este método e você verá que o estamos tornando estático, como fizemos com os próprios
‫eventos do jogo, porque não precisamos criar o gerenciador de eventos do jogo para chamar esses métodos.
‫Então é isso que queremos alcançar.
‫É por isso que estamos tornando isso estático.
‫Portanto, você não precisa criar um objeto para chamar esses métodos.
‫E então vamos criar outro método estático para seu próprio jogo.
‫E eu recomendo que você poste um vídeo e tente construir-se agora bem rápido.
‫Ok, então espero que você tenha postado que é basicamente a mesma coisa que fizemos aqui, mas agora vai funcionar com
‫o jogo da ONU aqui.
‫Portanto, eu tenho este método público estático, void trigger game over que irá acionar o evento e se unjam over não
‫for nulo.
‫Portanto, se houver métodos que se inscrevem no evento, isso não será falso e, basicamente, será verdadeiro, o que
‫significa que esse código será executado e o game over
‫será executado, o que chamará todos os métodos game over ou todos os métodos que atribuíram ou se inscreveram
‫neste evento game over, o que significa este método aqui, bem como este método.
‫E, finalmente, é claro, esse método.
‫Portanto, se vamos criar um novo motor, agora temos o motor de renderização e o motor de áudio.
‫Digamos que criemos o terceiro mecanismo, então não precisamos mais chamar isso manualmente.
‫Mas nós o enviamos para lá.
‫O que podemos configurar diretamente no motor onde dizemos que queremos nos inscrever nesse evento e o método
‫será chamado automaticamente assim que acionarmos esse evento.
‫Tudo bem.
‫Portanto, agora vamos dar uma olhada em nosso código no método principal, porque há muita coisa acontecendo aqui.
‫Agora você vê que todo esse código não funciona mais, é claro, porque todos esses métodos de
‫início de jogo eram públicos antes, mas agora não são mais.
‫Então agora eles estão.
‫Vai ser o que eles são privados, então eles estão fechados.
‫Portanto, agora vamos prosseguir e nos certificar de que realmente acionamos este evento de jogo.
‫Então, aqui temos o gerenciador de eventos do jogo e iniciamos esse jogo de gatilho, porque é isso que queremos fazer
‫neste momento.
‫Direito.
‫Assim, uma vez que todos os jogadores e todos os seus sistemas e tudo estejam preparados, podemos prosseguir e executá-lo.
‫E agora podemos fazer a mesma coisa com o método game over aqui.
‫Então, vamos iniciar o evento game over aqui.
‫O que acontecerá agora é que nos permitirá ter certeza de que temos um código muito mais simples e
‫limpo.
‫Portanto, isso apenas garante que nosso código funcionará perfeitamente.
‫Então, agora vamos dizer que adicionamos outro jogador a ele.
‫Não precisamos pensar sobre isso e chamar todos esses métodos corretos, chamados de método de início de jogo, chamado de método de finalização
‫de jogo e assim por diante.
‫Podemos simplesmente sair e criar este novo player e ele chamará automaticamente os métodos de acordo.
‫Como você pode ver aqui, o jogo iniciou o sistema de áudio e começou a reproduzir
‫áudio, renderizar o motor, desenhar visuais e, em seguida, gerar o jogador Steve Call Douglas Silver e Dragon Doc.
‫Então agora vamos apertar o botão.
‫E você pode ver que o jogo acabou, o sistema de áudio parou, o motor de renderização parou
‫e removemos todos os jogadores.
‫Esse é realmente o poder dos delegados multicast.
‫Super, super útil, muito poderoso.
‫Podemos ver que nosso terceiro jogador de objeto iniciou o jogo e terminou o jogo.
‫O método é chamado automaticamente porque nossos objetos foram notificados quando os eventos no início do jogo e no fim do
‫jogo foram acionados.
‫Agora, ao usar delegados, algumas coisas podem dar errado.
‫Vamos primeiro ver alguns dos erros que podem nos custar horas para consertar, digamos por engano.
‫Em vez de se inscrever em um método para o nosso evento, use o sinal de mais igual.
‫Vejamos, por exemplo, a classe do jogador.
‫Em vez de usar o sinal de mais igual, teríamos acidentalmente usado apenas o sinal de igual.
‫Portanto, o compilador não diz que isso está errado porque não está errado.
‫Você também pode substituir o evento existente com apenas um método.
‫Então, o que estamos fazendo aqui é dizer que tudo o mais foi inscrito neste ponto,
‫vamos substituí-lo.
‫E é isso que basicamente acontece aqui.
‫Portanto, iremos remover todos os métodos que referenciam no início do jogo e nos eventos do game over e definindo o jogador
‫como o último objeto do jogador, para ser mais preciso, que foi criado como o único subscritor de todos
‫esses eventos.
‫Além disso, como os primeiros passos no game over são públicos, podemos ligar para eles diretamente de qualquer lugar.
‫Então, digamos que queremos chamar o gerenciador de eventos do jogo no início do jogo a partir daqui, então podemos fazer isso também.
‫Portanto, agora vamos executar o código.
‫E você pode ver.
‫Gerando jogador com imagem idêntica e Silver Dragon Dong, o jogo começou a jogar com
‫nosso Dragon Dog em um Dragon Dong.
‫Então sim, primeiro o evento foi acionado pelo nosso programa.
‫sim.
‫E então do nosso último jogador, que foi nosso Dragon Dog.
‫Também é chamado de início contínuo, mais uma vez.
‫OK, então foi basicamente isso o que aconteceu aqui.
‫Portanto, realmente precisamos ter cuidado aqui.
‫Isso é algo que pode ser muito difícil de consertar.
‫Portanto, agora podemos marcar nossos eventos como privados porque precisamos que eles sejam públicos para inscrevê-los em nossos
‫construtores de classe.
‫Portanto, agora estamos usando o evento de nome ao falar sobre delegados porque nossos delegados estavam literalmente se
‫comportando como eventos.
‫Mas, na verdade, existe um tipo especial de delegados chamado eventos e que é feito para evitar esse tipo de
‫erro.
‫Tudo bem.
‫Portanto, agora existe um belo teclado que nos ajuda a evitar esse erro.
‫E essa é a palavra-chave do evento porque basicamente esse delegado que criamos em nosso gerenciador de eventos de
‫jogo aqui, esse evento de jogo estático público, é um evento.
‫Então, poderíamos ter usado essa palavra-chave de evento aqui.
‫E isso nos impediria de cometer esse erro, porque agora você vê que não está
‫feliz com o que fizemos aqui, então podemos substituir um delegado.
‫Mas, quando se trata de eventos, só podemos assiná-los.
‫E não podemos simplesmente chamar esse evento diretamente.
‫Ele será acionado diretamente do gerenciador de eventos do jogo para que não possamos mais chamar o evento diretamente, pois
‫no Game Start agora é um evento e só poderemos chamá-lo de dentro da classe onde
‫foi criado.
‫E também, está nos forçando a tratá-lo como uma lista, portanto, ter um evento do lado esquerdo do sinal de igual
‫não é permitido.
‫Então, algo assim, como vimos, não é permitido.
‫Tudo bem.
‫E agora, se executarmos o aplicativo novamente, você verá que funciona perfeitamente.
‫Deixe-me executar o código.
‫E funcionou perfeitamente bem.
‫Portanto, este foi um exemplo bastante condensado e bastante simples, porque analisamos os delegados, multicanais, delegados e eventos
‫em um vídeo.
‫Mas espero que este vídeo tenha deixado claro quais são as vantagens que você tem quando se trata de trabalhar com delegados e
‫eventos.
‫E o legal é que agora você viu como criar seus próprios delegados, bem como
‫seus próprios eventos, porque veremos muitos outros eventos mais tarde, quando se trata de usar a IU.
‫Por exemplo, quando você está clicando em algo, um evento é acionado e várias coisas podem
‫ser inscritas.
‫Múltiplas mães podem se inscrever naquele evento que foi disparado e executado uma vez, por exemplo,
‫o botão é clicado ou qualquer tecla do teclado é clicada.
‫Tudo bem.
‫Então, agora vamos resumir bem rápido.
‫Um evento é uma forma restrita de um delegado forçado a se comportar como uma lista, então podemos apenas adicionar ou remover
‫métodos dela para que possamos assinar ou cancelar a assinatura usando o sinal de mais igual ou o sinal de menos igual, mas não
‫o sinal de igual um delegado permite uma atribuição direta por meio do meu delegado é igual ao meu método.
‫Isso substitui todos os outros métodos que foram adicionados a ele antes.
‫Portanto, tome cuidado aqui.
‫Além disso, os eventos só podem ser chamados pela classe que os define de fora de sua classe.
‫Você só pode registrar e cancelar o registro de métodos para eles.
‫Ok, então espero que tenham gostado desse vídeo e isso deu uma boa ideia de eventos e delegados e espero
‫vê-los no próximo vídeo.