Devo suprimir CA1062: validar argumentos de métodos públicos?

Question

Recentemente, atualizei meu projeto para o Visual Studio 2010 do Visual Studio 2008.

No Visual Studio 2008, esta regra de análise de código não existe.

Agora não tenho certeza se devo usar esta regra ou não.

Estou construindo uma biblioteca de código aberto, por isso parece importante manter as pessoas a salvo de cometer erros. No entanto, se tudo o que vou fazer é jogar ArgumentNullException Quando o parâmetro é null, parece escrever um código inútil desde ArgumentNullException será jogado mesmo se eu não escrever esse código.

EDITAR: Além disso, há um problema de desempenho que precisa ser abordado. Procurando por null Em todo método público, pode causar problemas de desempenho.

Devo remover essa regra ou corrigir as violações?

Answer 1

Depende. A convenção ao usar o argumentnullexception é incluir o nome do argumento nulo na descrição. Portanto, o chamador saberá exatamente o que deu errado.

A fonte de uma NullReferenceException (que é o que acontecerá se você não validar) pode ser fácil de detectar, mas se o método for complexo, pode ser mais difícil. Você pode acabar em uma linha de código em que várias referências podem ser nulas.

Pessoalmente, prefiro que os métodos públicos joguem argumentnullexception se eles não puderem lidar com a entrada nula para o argumento especificado, porque permite um comportamento consistente, não importa como o método seja implementado.

Em resposta à edição: na minha opinião, é mais importante fornecer um conjunto consistente de interfaces com poucas surpresas do que otimizar todas as linhas de código. Meu palpite é que, na maioria dos casos, a sobrecarga de desempenho da verificação nula não será significativa. Se acabar sendo um problema (como no perfil diz isso), eu consideraria alterá -lo. Caso contrário, eu não consideraria um problema neste momento.

Answer 2

Mantemos essa regra porque decidimos que sempre era melhor verificar os parâmetros em sua primeira entrada no seu código. Dessa forma, quando a pessoa que usa seu código obtém a exceção, o contexto será melhor. Alguém que não possui seu código -fonte, por exemplo, verá que a exceção foi lançada no seu código e pode registrar um relatório de bug contra você por desperdiçar seu tempo e o deles.

Answer 3

O IMHO Não. A verificação do NULLS quase nunca será o gargalo de desempenho em seu aplicativo. (E no caso em um milhão de casos em que é significativo, você o encontrará com seu perfil e removerá esse caso).

A outra pergunta que deve se formar em sua mente é "é lançar a nova nullReferenceException () realmente a melhor maneira de lidar com o erro?" Muitas vezes, você pode lidar com as coisas melhor do que isso (mesmo que apenas forneça um melhor relatório de erro ao usuário e/ou a si mesmo para fins de depuração). Em muitos casos, o código pode lidar com nulas graciosamente, tornando -o desnecessário que isso seja um erro.

editar

Para responder sua edição: verificações nulas realmente não demoram muito. A sobrecarga para simplesmente chamar um método será dezenas, se não centenas de vezes mais do que uma verificação nula. O único lugar onde uma verificação nula fará uma diferença significativa está em um loop grande e apertado, onde você está fazendo muito pouco mais. Essa situação não acontece com muita frequência - geralmente você verifica um nulo e depois faz algo relativamente caro com essa referência.

Não há situação em que um acidente ou fracasso seja uma coisa boa. É sempre melhor "desacelerar seu aplicativo" com verificações nulas do que travar e perder os dados do cliente.

Portanto, não otimize prematuramente seu código. Escreva bem, para ser sustentável e robusto, então perfil para ver onde estão os gargalos. Estou programando há 28 anos, sendo muito liberal com verificações nulas e tenho Nunca descobriram que uma verificação nula era a causa de um problema de desempenho. Geralmente, são coisas como fazer muito trabalho desnecessário em um loop, usando um algoritmo O (n^3) em que uma abordagem O (n^2) é possível, não é possível cache os valores caros para computar, etc.