Richtlinien für die Verwendung von Parametern

Die folgenden Regeln dienen als Richtlinie für die Verwendung von Parametern:

• Untersuchen Sie den Code auf gültige Parameterargumente. Führen Sie eine Argumentvalidierung für jede public- oder protected-Methode und jeden set-Eigenschaftsaccessor aus. Lösen Sie für ungültige Parameterargumente sinnvolle Ausnahmen für den Entwickler aus. Verwenden Sie die System.ArgumentException-Klasse oder eine von System.ArgumentException abgeleitete Klasse. Im folgenden Beispiel wird nach gültigen Parameterargumenten gesucht, und sinnvolle Ausnahmen werden ausgelöst.

  Class SampleClass
     Private countValue As Integer
     Private maxValue As Integer = 100
  
     Public Property Count() As Integer      
        Get
           Return countValue
        End Get
        Set
           ' Check for valid parameter.
           If value < 0 Or value >= maxValue Then
              Throw New ArgumentOutOfRangeException("value", value, 
                 "Value is invalid.")
           End If
           countValue = value
        End Set
     End Property
     Public Sub SelectItem(start As Integer, [end] As Integer)
        ' Check for valid parameter.
        If start < 0 Then
           Throw New ArgumentOutOfRangeException("start", start, "Start 
              is invalid.")
        End If
        ' Check for valid parameter.
        If [end] < start Then
           Throw New ArgumentOutOfRangeException("end", [end], "End is 
                 invalid.")
        End If 
        ' Insert code to do other work here.
        Console.WriteLine("Starting at {0}", start)
        Console.WriteLine("Ending at {0}", [end])
     End Sub 
  End Class
  [C#]
  class SampleClass
  {
     public int Count
     {
        get
        {
           return count;
        }
        set
        {
              // Check for valid parameter.
              if (count < 0 || count >= MaxValue)
                 throw newArgumentOutOfRangeException(
                    Sys.GetString(
                       "InvalidArgument","value",count.ToString()));
        }
     }
  
     public void Select(int start, int end)
     {
        // Check for valid parameter.
        if (start < 0)
           throw new ArgumentException(
                 Sys.GetString("InvalidArgument","start",start.ToString()));
        // Check for valid parameter.
        if (end < start)
           throw new ArgumentException(
                 Sys.GetString("InvalidArgument","end",end.ToString()));
     }
  }
  

  Beachten Sie, dass die eigentliche Überprüfung nicht unbedingt in der public- oder protected-Methode selbst erfolgen muss. Sie könnte auch auf einer tieferen Ebene in privaten Routinen stattfinden. Es kommt darauf an, dass der gesamte Oberflächenbereich, der dem Entwickler offengelegt wird, nach gültigen Argumenten durchsucht wird.

• Stellen Sie sicher, dass Sie die Auswirkungen der Übergabe von Parametern als Wert oder Verweis vollständig nachvollziehen können. Durch die Übergabe eines Parameters als Wert wird der übergebene Wert kopiert. Dies hat keine Auswirkungen auf den ursprünglichen Wert. Im folgenden Methodenbeispiel werden Parameter als Wert übergeben.

  public void Add(object value){}
  

  Bei der Übergabe von Parametern als Verweis wird der Speicherort für den Wert übergeben. Daher können Änderungen am Wert des Parameters vorgenommen werden. Im folgenden Methodenbeispiel wird ein Parameter als Wert übergeben.

  public static int Exchange(ref int location, int value){}
  

  Ein Ausgabeparameter stellt denselben Speicherort dar wie die im Methodenaufruf als Argument angegebene Variable. Daher können Änderungen nur am Ausgabeparameter vorgenommen werden. Im folgenden Methodenbeispiel wird ein out-Parameter übergeben.

  [DllImport("Kernel32.dll"]
  public static extern bool QueryPerformanceCounter(out long value)
  

Siehe auch

Entwurfsrichtlinien für die Entwicklung von Klassenbibliotheken | Richtlinien für die Benennung von Parametern | Richtlinien für die Verwendung von Klassenmembern