É essencial que eu aprenda as instruções Try / Catch e Finalmente para a Programação de Jogos, ou é algo em que posso voltar? [fechadas]

Não parece algo que seria uma parte essencial da programação do jogo.

Eles são 100% essenciais. Deseja que seu jogo falhe sempre que ocorrer um erro? É verdade que alguns erros sempre causam uma falha, mas e algo tão simples como o tempo limite da rede? Não seria mais inteligente contar ao jogador e fazê-lo tentar novamente ou verificar sua conexão de rede?

Pegá-los é muito fácil.

try
{
    //open a network connection and try to get the leaderboard 
}
catch(Exception ex)  //type of exception, and a variable to access it by
{
    //tell the user something happend, and have them try again.
    //maybe you jut want to log it.

    LogError(ex);
    //so we have a record it happend, but the error was really bad! (out of memory) just throw it again if you need to
    throw;
}
finally
{
    //this happens no matter what. it will run on success and failure
}

Embora eu concorde com a resposta de Joe de que o tratamento de exceções é uma habilidade útil para aprender, é minha experiência que eles raramente são usados ​​no desenvolvimento de jogos.

Não tenho muita certeza das diferenças na implementação, mas em C ++ a sobrecarga envolvida em manter rastreamentos de pilha para permitir um desenrolamento eficaz sempre que um 'lançamento' é encontrado é praticamente o único motivo pelo qual eles desaprovam.

Esta resposta pode fornecer mais informações sobre as despesas gerais envolvidas no tratamento de exceções em C #.

Em termos de arquitetura geral do programa, as exceções não são úteis para determinar os motivos exatos de uma falha e tornam problemático determinar exatamente onde está ocorrendo um erro. Você vai relaxar até o ponto da captura, mas tem pouca ou nenhuma informação (dependendo da utilidade da sua exceção) sobre onde o erro realmente se originou.

Concordo que é algo que você pode voltar.

Talvez não seja essencial "programar jogos" da maneira que pode ser para manutenção / suporte à programação. Em outras palavras, se você pode pensar em "programação de jogos" como a disciplina de criar e entregar o jogo, os benefícios do manuseio de exceção surgem à luz após o envio para fora da porta.

Dito isto, há coisas que podem desempenhar um papel em quanto tempo:

• Seu registro. Portanto, haverá um momento em que você começará a formular uma estratégia de gerenciamento de erros. O quão cedo você forma sua estratégia está diretamente relacionado à quantidade de suporte que você recebe dos relatórios de erros e entradas de log capturadas como "referência nula". Muitas vezes, sem o contexto que você pode capturar da exceção, você precisa fazer mais trabalhos de detetive e é mais difícil agrupar erros para ver as semelhanças.

• O seu sistema de patches. Se você puder enviar atualizações, terá muita liberdade para aguardar no tratamento de exceções. O mesmo se sua lógica for um aplicativo Web e os clientes forem apenas navegadores.

• O tamanho da sua equipe. Se você é um time de um homem, tem uma enorme liberdade para esperar. Você conhece o seu código. Você pode até saber de antemão que a exceção estava na sua lista de tarefas. Se você trabalha e compartilha código com outros desenvolvedores, pode ser atribuído um ticket para rastrear o código de outra pessoa, para que você não veja imediatamente onde a exceção foi disparada.

• Concorrência. Para mim, este é difícil de planejar, por isso pode não valer a pena. Além disso, acho que isso faz parte da robustez ou resiliência. Portanto, se os requisitos permitirem falhas súbitas, você terá grande liberdade e esperará para resolver exceções. Uma coisa que você pode encontrar com os threads é que é fácil obter um comportamento não determinístico. Quando isso acontece, você deseja maneiras de capturar o máximo de informações sobre o estado que levou à falha. Isso pode incluir simulação em um laboratório de máquinas, testes de regressão, logs e dados (ativos). Individualmente, cada uma dessas peças pode compensar as demais em algum grau. Por exemplo, se você tiver testes infinitos, poderá expor todas as falhas lógicas e, portanto, não precisará manipular exceções (ou registrar ou qualquer outra coisa).

O tratamento de exceções é uma maneira mais limpa de lidar com erros inesperados a partir de qualquer ponto do jogo. Mas a beleza disso é que, na sua base de código, não importa o quão profundo você esteja no código para lidar com isso. Sem exceções, algum tipo de rotina de tratamento de erros retornaria um bool ou int para algum tipo de status e, em seguida, desenrolaria as sub-rotinas aninhadas até chegar a uma área de nível superior (sua classe de jogo) e sair dali. Será muito complicado escrever seu código para verificação de erros a partir de qualquer ponto possível, pois o uso de exceções requer pouca ou nenhuma refatoração.

Como sua pergunta é específica ao XNA, provavelmente será útil saber como lidar com exceções em um jogo do Xbox, porque quando um jogo lá não pega um, você não fica com uma pista do motivo pelo qual isso aconteceu. Este artigo mostra uma maneira inteligente de solucionar isso executando todo o jogo em um bloco try / catch. Ele iniciará um novo "ExceptionGame" se algo der errado, passando os detalhes do erro a serem exibidos no ExceptionGame.

Não sei nada sobre c #, mas aqui estão meus três centavos:

1. O paradigma de manipulação de exceção try / catch / finalmente é generalizado e por boas razões: fornece uma excelente estrutura para lidar com exceções no seu código.
2. Se você estiver usando um determinado idioma, deve aprender todas as instruções e como usá-las ou seu código será uma combinação de confuso, com erros e ineficiente. Muito se pensa no design de linguagens de programação, e tentar escrever um programa sem usar todas as ferramentas disponíveis é simplesmente ... bobo.
3. Não deve ser menosprezo, mas há muitos aspectos desafiadores do desenvolvimento de jogos e tentar fazê-lo com a atitude de "Eu só vou aprender o que absolutamente preciso para sobreviver" não vai acabar bem. Você seria melhor servido usando a jornada para o seu objetivo de desenvolver um jogo como uma oportunidade de aprender o máximo que puder.

Não, as exceções não são vitais ou essenciais de forma alguma. Na maioria das vezes, os programas tradicionais de jogos são muito pesados ​​nas verificações de erros e sabem exatamente o que está acontecendo com os dados e parâmetros.

A exceção é que, ao acessar chamadas do sistema, elas estarão lançando exceções e como capturá-las está muito bem documentada e você pode usar o try / catch como uma caixa preta até começar a usar as exceções mais profundamente por conta própria.

A coisa toda de try / catch é, no entanto, muito fácil de entender e, quando você se familiarizar com o C #, poderá ver onde as exceções fazem sentido e poderá começar a adicioná-las naturalmente ao seu próprio código.

Supondo, é claro, que você está apenas começando. Se você estiver aprendendo C # após outros idiomas, deverá pegar exceções e não esperar até mais tarde.

Acredito que depende da natureza do seu código de jogo. Existem áreas no seu fluxo de execução em que as coisas podem falhar? Seu código é 100% manipulado? Se o código não tem como falhar, se você está ciente da condição de postagem e de algumas delas, o tratamento de exceções é de pouca utilidade e simplesmente aumentaria o uso de recursos para verificar sem motivo. No entanto, a maioria do código tem situações em que as coisas podem falhar. Especialmente no desenvolvimento de jogos, se um jogo for previsível, provavelmente não terá a essência de ser um jogo. Independentemente de seu uso no desenvolvimento de jogos, você DEVE estar ciente e como usá-lo. Mas aplique-o onde necessário.

Deseja saber o que deu errado em seu programa sem inserir pontos de interrupção ou examinar todo o código. Se sim, as instruções try-catch o ajudarão a fazer exatamente isso. Ele informa o que deu errado usando tipos predefinidos de erros. Portanto, aprendendo realmente essas instruções e sabendo qual erro representa o quê, você pode efetivamente depurar seu código sem qualquer aborrecimento.

Bem,

Normalmente, a tendência do software Orientado a Objetos é usar Exceções para relatar erros no processo em execução. Se acontecer algo que o método atual não consiga resolver / resolver, ele deve lançar uma exceção e deixar alguém no mais alto para tratar esse problema. Se você fizer isso, seus principais métodos de processamento (os mais específicos) serão muito mais limpos sem a necessidade de tratar erros que não podem ser resolvidos.

Mas normalmente, no desenvolvimento de jogos, exceções não são lançadas porque você está projetando o ambiente do buraco. Se você estiver projetando seu mecanismo, sim, usará exceções aos recursos basicamente de E / S, mas na cena, por exemplo, não é provável que você o utilize. Descobri que é melhor tentar adicionar a uma lista de coisas que devem ser resolvidas em vez de gerar um erro. Por exemplo, você tem um jogo cliente / servidor. No cliente, você notou algo que deu errado. Acho que é melhor (para mim) adicionar esse erro a uma lista de erros que devem ser resolvidos, em vez de interromper a sequência. Dessa forma, você pode simplesmente pular esse erro e não lançar uma exceção, mas alguém tentará corrigir esse problema.

Mas em qualquer software OO com o qual você trabalha, lembre-se de que sempre são usadas exceções. É uma coisa muito boa de aprender, muito útil e nem um pouco difícil.