CA2208: Argumentausnahmen korrekt instanziieren

TypeName	InstantiateArgumentExceptionsCorrectly
CheckId	CA2208
Kategorie	Microsoft.Usage
Unterbrechende Änderung	Nicht unterbrechend

Ursache

Als mögliche Ursachen kommen folgende Situationen in Betracht:

• Es wird der (parameterlose) Standardkonstruktor eines Ausnahmetyps aufgerufen, der [System.ArgumentException] entspricht oder davon abgeleitet wird.

• Es wird ein falsches Zeichenfolgenargument an den parametrisierten Konstruktor eines Ausnahmetyps übergeben, der [System.ArgumentException.] entspricht oder davon abgeleitet wird.

Regelbeschreibung

Statt den Standardkonstruktor aufzurufen, sollte einer der überladenen Konstruktoren aufgerufen werden, der zulässt, dass eine aussagekräftigere Ausnahmemeldung bereitgestellt wird. Die Ausnahmemeldung sollte auf den Entwickler abzielen und die Fehlerbedingung und Wege zur Behebung oder Vermeidung der Ausnahme klar darlegen.

Die Signaturen der Konstruktoren von ArgumentException und davon abgeleiteten Typen mit einer oder zwei Zeichenfolgen sind nicht konsistent in Bezug auf den message-Parameter und den paramName-Parameter. Stellen Sie sicher, dass diese Konstruktoren mit den richtigen Zeichenfolgenargumenten aufgerufen werden. Die Signaturen lauten wie folgt:

ArgumentException(string message)

ArgumentException(string message, string paramName)

ArgumentNullException(string paramName)

ArgumentNullException(string paramName, string message)

ArgumentOutOfRangeException(string paramName)

ArgumentOutOfRangeException(string paramName, string message)

DuplicateWaitObjectException(string parameterName)

DuplicateWaitObjectException(string parameterName, string message)

Behandeln von Verstößen

Um einen Verstoß gegen diese Regel zu beheben, rufen Sie einen Konstruktor auf, der eine Meldung, einen Parameternamen oder beides annimmt, und stellen sicher, dass die Argumente für den Typ von ArgumentException, der aufgerufen wird, korrekt sind.

Wann sollten Warnungen unterdrückt werden?

Eine Warnung dieser Regel kann nur dann gefahrlos unterdrückt werden, wenn ein parametrisierter Konstruktor mit den richtigen Zeichenfolgenargumenten aufgerufen wird.

Beispiel

Im folgenden Beispiel wird ein Konstruktor veranschaulicht, der unordnungsgemäß eine Instanz des ArgumentNullException-Typs instanziiert.

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

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

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

Im folgenden Beispiel wird der oben erwähnte Verstoß korrigiert, indem die Konstruktorargumente vertauscht werden.

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

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

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