CA2208 : Instanciez les exceptions d’argument comme il se doitCA2208: Instantiate argument exceptions correctly

TypeNameTypeName InstantiateArgumentExceptionsCorrectlyInstantiateArgumentExceptionsCorrectly
CheckIdCheckId CA2208CA2208
CategoryCategory Microsoft.UsageMicrosoft.Usage
Modification avec ruptureBreaking Change Sans ruptureNon Breaking

CauseCause

Les causes possibles incluent les situations suivantes :Possible causes include the following situations:

  • Un appel est effectué au constructeur par défaut (sans paramètre) d’un type d’exception qui est ou dérive ArgumentException.A call is made to the default (parameterless) constructor of an exception type that is, or derives from ArgumentException.

  • Un argument string incorrect est passé à un constructeur paramétrable d’un type d’exception qui est ou dérive ArgumentException.An incorrect string argument is passed to a parameterized constructor of an exception type that is, or derives from ArgumentException.

Description de la règleRule description

Au lieu d’appeler le constructeur par défaut, appelez une des surcharges de constructeur qui permet à un message d’exception plus explicite doit être fourni.Instead of calling the default constructor, call one of the constructor overloads that allows a more meaningful exception message to be provided. Le message d’exception doit cibler le développeur et expliquer clairement la condition d’erreur et comment corriger ou éviter l’exception.The exception message should target the developer and clearly explain the error condition and how to correct or avoid the exception.

Les signatures des constructeurs de chaîne un et deux de ArgumentException et ses types dérivés ne sont pas cohérents par rapport à la message et paramName paramètres.The signatures of the one and two string constructors of ArgumentException and its derived types are not consistent with respect to the message and paramName parameters. Assurez-vous que ces constructeurs sont appelés avec les arguments de chaîne correcte.Make sure these constructors are called with the correct string arguments. Les signatures sont les suivantes :The signatures are as follows:

ArgumentException(chaîne message)ArgumentException(string message)

ArgumentException(chaîne message, chaîne paramName)ArgumentException(string message, string paramName)

ArgumentNullException(chaîne paramName)ArgumentNullException(string paramName)

ArgumentNullException(chaîne paramName, chaîne message)ArgumentNullException(string paramName, string message)

ArgumentOutOfRangeException(chaîne paramName)ArgumentOutOfRangeException(string paramName)

ArgumentOutOfRangeException(chaîne paramName, chaîne message)ArgumentOutOfRangeException(string paramName, string message)

DuplicateWaitObjectException(chaîne parameterName)DuplicateWaitObjectException(string parameterName)

DuplicateWaitObjectException(chaîne parameterName, chaîne message)DuplicateWaitObjectException(string parameterName, string message)

Comment corriger les violationsHow to fix violations

Pour corriger une violation de cette règle, appelez un constructeur qui accepte un message, un nom de paramètre ou les deux et assurez-vous que les arguments sont appropriées pour le type de ArgumentException qui est appelée.To fix a violation of this rule, call a constructor that takes a message, a parameter name, or both, and make sure the arguments are proper for the type of ArgumentException being called.

Quand supprimer les avertissementsWhen to suppress warnings

Il est possible de supprimer un avertissement de cette règle uniquement si un constructeur paramétrable est appelé avec les arguments de chaîne correcte.It is safe to suppress a warning from this rule only if a parameterized constructor is called with the correct string arguments.

Exemple 1Example 1

L’exemple suivant montre un constructeur qui n’instancie pas correctement une instance du type ArgumentNullException.The following example shows a constructor that incorrectly instantiates an instance of the ArgumentNullException type.

using namespace System;
 
namespace Samples1 
{    
	public ref class Book    
	{
     private: initonly String^ _Title;
 
    public:
        Book(String^ title)        
		{            
			// Violates this rule (constructor arguments are switched)            
			if (title == nullptr)                
				throw gcnew ArgumentNullException("title cannot be a null reference (Nothing in Visual Basic)", "title");
 
            _Title = title;        
		}
 
        property String^ Title        
		{            
			String^ get()            
			{                
				return _Title;            
			}        
		}    
	};
}
using System;
 
namespace Samples1
{    
    public class Book    
    {        
        private readonly string _Title;
 
        public Book(string title)        
        {            
            // Violates this rule (constructor arguments are switched)            
            if (title == null)                
                throw new ArgumentNullException("title cannot be a null reference (Nothing in Visual Basic)", "title");
 
            _Title = title;        
        }
 
        public string Title        
        {            
            get { return _Title; }        
        }
    }
}
Imports System

Namespace Samples1

    Public Class Book

        Private ReadOnly _Title As String

        Public Sub New(ByVal title As String)
            ' Violates this rule (constructor arguments are switched)            
            If (title Is Nothing) Then
                Throw New ArgumentNullException("title cannot be a null reference (Nothing in Visual Basic)", "title")
            End If
            _Title = title
        End Sub

        Public ReadOnly Property Title()
            Get
                Return _Title
            End Get
        End Property

    End Class

End Namespace

Exemple 2Example 2

L’exemple suivant résout la violation ci-dessus en passant les arguments de constructeur.The following example fixes the above violation by switching the constructor arguments.

using namespace System;
 
namespace Samples2 
{    
	public ref class Book    
	{
     private: initonly String^ _Title;
 
    public:
        Book(String^ title)        
		{            
			if (title == nullptr)                
				throw gcnew ArgumentNullException(("title", "title cannot be a null reference (Nothing in Visual Basic)"));
 
            _Title = title;        
		}
 
        property String^ Title        
		{            
			String^ get()            
			{                
				return _Title;            
			}        
		}    
	};
}
namespace Samples2
{    
    public class Book    
    {        
        private readonly string _Title;
 
        public Book(string title)        
        {            
            if (title == null)                
                throw new ArgumentNullException("title", "title cannot be a null reference (Nothing in Visual Basic)");
 
            _Title = title;        }
 
        public string Title        
        {            
            get { return _Title; }        
        }
    }
}
Namespace Samples2

    Public Class Book

        Private ReadOnly _Title As String

        Public Sub New(ByVal title As String)
            If (title Is Nothing) Then
                Throw New ArgumentNullException("title", "title cannot be a null reference (Nothing in Visual Basic)")
            End If

            _Title = title
        End Sub

        Public ReadOnly Property Title()
            Get
                Return _Title
            End Get
        End Property

    End Class

End Namespace