Partager via


Valider des arguments de méthodes publiques

Mise à jour : novembre 2007

TypeName

ValidateArgumentsOfPublicMethods

CheckId

CA1062

Catégorie

Microsoft.CSharp

Modification avec rupture

Modification sans rupture

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();
}