Valide los argumentos de los métodos públicos

Actualización: noviembre 2007

TypeName	ValidateArgumentsOfPublicMethods
Identificador de comprobación	CA1062
Category	Microsoft.Design
Cambio problemático	No problemático

Motivo

Un método visible externamente elimina las referencias de uno de sus argumentos de referencia sin comprobar si ese argumento es null (Nothing en Visual Basic).

Descripción de la regla

Todos los argumentos de referencia argumentos pasados a métodos visibles externamente se deben comprobar para ver si son null. Si procede, inicie una excepción System.ArgumentNullException cuando el argumento sea null.

Cómo corregir infracciones

Para corregir una infracción de esta regla, valide cada argumento de referencia con respecto a null.

Cuándo suprimir advertencias

No suprima las advertencias de esta regla.

Ejemplo

El ejemplo siguiente muestra un método que infringe la regla y un método que la cumple.

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

En Visual Studio 2005, esta regla tiene varias limitaciones. Una limitación es que

no detecta que se están pasando parámetros a otro método que realiza la validación.

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

Otra limitación es que no entiende los operadores de cortocircuito.

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