Richtlinien für die Verwendung von Methoden

Artikel
03/31/2008

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

Wählen Sie für die Methode einen Namen gemäß den empfohlenen Richtlinien für die Benennung von Methoden.
Verwenden Sie nicht die ungarische Notation.
Methoden sind standardmäßig nicht-virtuell. Behalten Sie diese Standardeinstellung in Situationen bei, in denen die Bereitstellung von virtuellen Methoden nicht erforderlich ist. Weitere Informationen zur Implementierung der Vererbung finden Sie unter Richtlinien für die Verwendung von Basisklassen.

Richtlinien für das Überladen von Methoden

Eine eine Methodenüberladung tritt auf, wenn eine Klasse zwei Methoden mit dem gleichen Namen, aber unterschiedlichen Signaturen enthält. In diesem Abschnitt finden Sie einige Richtlinien für die Verwendung von überladenen Methoden.

Verwenden Sie die Methodenüberladung, um unterschiedliche Methoden bereitzustellen, die semantisch die gleiche Funktion haben.
Sie können die Methodenüberladung auch verwenden, anstatt Standardargumente zuzulassen. Standardargumente erlauben keine gute Versionserstellung und sind deshalb in der Common Language Specification (CLS) nicht zulässig. Das folgende Codebeispiel veranschaulicht eine überladene String.IndexOf-Methode.
```
Function String.IndexOf(name As String) As Integer
Function String.IndexOf(name As String, startIndex As Integer) As Integer
[C#]
int String.IndexOf (String name);
int String.IndexOf (String name, int startIndex);
```
Verwenden Sie Standardwerte korrekt. In einer Familie von überladenen Methoden sollte die komplexe Methode Parameternamen verwenden, die einen Wechsel des Standardstatus anzeigt, von dem in der einfachen Methode ausgegangen worden war. Im folgenden Codebeispiel geht die erste Methode davon aus, dass die Groß-/Kleinschreibung bei der Suche nicht beachtet wird. Die zweite Methode verwendet statt des Namens caseSensitive den Namen ignoreCase, um anzugeben, wie das Standardverhalten geändert wird.
```
' Method #1: ignoreCase = false.
Function Type.GetMethod(name As String) As MethodInfo
' Method #2: Indicates how the default behavior of method #1 
' is being changed.
Function Type.GetMethod(name As String, ignoreCase As Boolean) As MethodInfo
[C#]
// Method #1: ignoreCase = false.
MethodInfo Type.GetMethod(String name); 
// Method #2: Indicates how the default behavior of method #1 is being // changed.
 MethodInfo Type.GetMethod (String name, Boolean ignoreCase);
```

Verwenden Sie ein konsistentes Anordnungs- und Benennungsschema für Methodenparameter. Es ist üblich, mit einer steigenden Anzahl an Parametern einen Satz überladener Methoden bereitzustellen, damit der Entwickler die Möglichkeit hat, die gewünschte Menge an Informationen anzugeben. Je mehr Parameter Sie festlegen, desto mehr Details kann der Entwickler angeben. Im folgenden Codebeispiel hat die überladene Execute-Methode eine konsistente Parameterreihenfolgen- und Benennungsschemavariante. Jede Variante der Execute-Methode verwendet die gleiche Semantik für den gemeinsam genutzten Satz an Parametern.

Public Class SampleClass
   Private defaultForA As String = "default value for a"
   Private defaultForB As Integer = "42"
   Private defaultForC As Double = "68.90"

   Overloads Public Sub Execute()
      Execute(defaultForA, defaultForB, defaultForC)
   End Sub

   Overloads Public Sub Execute(a As String)
      Execute(a, defaultForB, defaultForC)
   End Sub

   Overloads Public Sub Execute(a As String, b As Integer)
      Execute(a, b, defaultForC)
   End Sub

   Overloads Public Sub Execute(a As String, b As Integer, c As Double)
      Console.WriteLine(a)
      Console.WriteLine(b)
      Console.WriteLine(c)
      Console.WriteLine()
   End Sub 
End Class
[C#]
public class SampleClass
{
   readonly string defaultForA = "default value for a";
   readonly int defaultForB = "42";
   readonly double defaultForC = "68.90";

   public void Execute()
   {
      Execute(defaultForA, defaultForB, defaultForC);
   }

   public void Execute (string a)
   {
      Execute(a, defaultForB, defaultForC);
   }

   public void Execute (string a, int b)
   {
      Execute (a, b, defaultForC);     
   }

   public void Execute (string a, int b, double c)
   {
      Console.WriteLine(a);
      Console.WriteLine(b);
      Console.WriteLine(c);
      Console.WriteLine();
   } 
}

Beachten Sie, dass die einzige Methode in der Gruppe, die virtuell sein soll, die meisten Parameter aufweist. Dies trifft außerdem nur zu, wenn Erweiterbarkeit benötigt wird.

Wenn Sie die Möglichkeit des Überschreibens einer Methode bereitstellen müssen, legen Sie nur die umfassendste Überladung als virtuell fest, und definieren Sie die anderen Operationen entsprechend. Das folgende Beispiel veranschaulicht dieses Schema.

Public Class SampleClass
   Private myString As String

   Public Sub New(str As String)
      Me.myString = str
   End Sub

   Overloads Public Function IndexOf(s As String) As Integer
      Return IndexOf(s, 0)
   End Function

   Overloads Public Function IndexOf(s As String, startIndex As 
            Integer) As Integer
      Return IndexOf(s, startIndex, myString.Length - startIndex)
   End Function

   Overloads Public Overridable Function IndexOf(s As String, 
            startIndex As Integer, count As Integer) As Integer
      Return myString.IndexOf(s, startIndex, count)
   End Function 
End Class
[C#]
public class SampleClass
{
   private string myString;

   public MyClass(string str)
   {
      this.myString = str;
   }

   public int IndexOf(string s) 
   {
      return IndexOf (s, 0);
   }

   public int IndexOf(string s, int startIndex) 
   {
      return IndexOf(s, startIndex, myString.Length - startIndex );
   }

   public virtual int IndexOf(string s, int startIndex, int count) 
   {
      return myString.IndexOf(s, startIndex, count);
   }
}

Methoden mit einer variablen Anzahl an Argumenten

Sie müssen u. U. eine Methode offenlegen, die eine variable Anzahl an Argumenten annimmt. Ein klassisches Beispiel hierfür ist die printf-Methode in der Programmiersprache C. Bei verwalteten Klassenbibliotheken verwenden Sie für dieses Konstrukt das params (in Visual Basic ParamArray)-Schlüsselwort. Verwenden Sie z. B. folgenden Code anstelle von mehreren überladenen Methoden.

Sub Format(formatString As String, ParamArray args() As Object)
[C#]
void Format(string formatString, params object [] args)

Sie sollten die Aufrufkonvention für VarArgs oder Auslassungszeichen (...) nicht ausschließlich verwenden, da die Common Language Specification diese nicht unterstützt.

Bei extrem rechenintensivem Code empfiehlt es sich, spezielle Codepfade für eine kleine Anzahl an Elementen bereitzustellen. Dies sollten Sie jedoch nur tun, wenn Sie vorhaben, den gesamten Codepfad in spezieller Schreibweise anzugeben (d. h. nicht nur ein Array zu erstellen und die allgemeinere Methode aufzurufen). In solchen Fällen empfiehlt sich das folgende Schema als Kompromiss zwischen Leistungsoptimierung und den Speicheranforderungen von Code in spezieller Schreibweise.

Sub Format(formatString As String, arg1 As Object)
Sub Format(formatString As String, arg1 As Object, arg2 As Object)

Sub Format(formatString As String, ParamArray args() As Object)
[C#]
void Format(string formatString, object arg1)
void Format(string formatString, object arg1, object arg2)
   
void Format(string formatString, params object [] args)

Siehe auch

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

Richtlinien für die Verwendung von Methoden

Richtlinien für das Überladen von Methoden

Methoden mit einer variablen Anzahl an Argumenten

Siehe auch

Zusätzliche Ressourcen