Valider des arguments de méthodes publiques

Mise à jour : novembre 2007

Cause

Une méthode visible de l'extérieur déréférence l'un de ses arguments de référence sans vérifier si cet argument a la valeur null (Nothing en Visual Basic).

Description de la règle

Tous les arguments de référence passés aux méthodes visibles de l'extérieur doivent être vérifiés par rapport à null. Si besoin, levez une exception System.ArgumentNullException lorsque l'argument a la valeur null.

Comment corriger les violations

Pour corriger une violation de cette règle, validez chaque argument de référence par rapport à null.

Quand supprimer les avertissements

Ne supprimez aucun avertissement de cette règle.

Exemple

L'exemple suivant présente une méthode qui viole la règle et une autre qui satisfait à la règle.

Imports System

Namespace DesignLibrary

    Public Class Test

        ' This method violates the rule.
        Sub DoNotValidate(ByVal input As String)

            If input.Length <> 0 Then
                Console.WriteLine(input)
            End If

        End Sub

        ' This method satisfies the rule.
        Sub Validate(ByVal input As String)

            If input Is Nothing Then
                Throw New ArgumentNullException("input")
            End If

            If input.Length <> 0 Then
                Console.WriteLine(input)
            End If

        End Sub

    End Class

End Namespace

using System;

namespace DesignLibrary
{
    public class Test
    {
        // This method violates the rule.
        public void DoNotValidate(string input)
        {
            if (input.Length != 0)
            {
                Console.WriteLine(input);
            }
        }

        // This method satisfies the rule.
        public void Validate(string input)
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }
            if (input.Length != 0)
            {
                Console.WriteLine(input);
            }
        }
    }
}

Dans Visual Studio 2005, cette règle présente plusieurs limites. Première limitation :

elle ne détecte pas le fait que des paramètres sont passés à une autre méthode qui effectue la validation.

Public Function Method(ByVal value As String) As String
    EnsureNotNull(value)

    ' Fires incorrectly    
    Return value.ToString()
End Function

Private Sub EnsureNotNull(ByVal value As String)
    If value Is Nothing Then
        Throw (New ArgumentNullException("value"))
    End If
End Sub

public string Method(string value)
{
    EnsureNotNull(value);

    // Fires incorrectly    
    return value.ToString();
}

private void EnsureNotNull(string value)
{
    if (value == null)
        throw new ArgumentNullException("value");
}

Autre limitation : elle ne comprend pas les opérateurs de court-circuit.

Public Function Method(ByVal value1 As String, ByVal value2 As String) As String
    If value1 Is Nothing OrElse value2 Is Nothing Then
        Throw New ArgumentNullException()
    End If

    ' Fires incorrectly    
    Return value1.ToString() + value2.ToString()

End Function

public string Method(string value1, string value2)
{
    if (value1 == null || value2 == null)
        throw new ArgumentNullException(value1 == null ? "value1" : "value2");

    // Fires incorrectly    
    return value1.ToString() + value2.ToString();
}