Variable Parameterlisten in Funktionen

Geschrieben von: Christoph Wille
Kategorie: C#

In den meisten aller Fälle weiß man im vorhinein, wieviele Parameter an eine Funktion übergeben werden sollen. Was aber, wenn bestimmte Parameter optional sein sollen, oder die Funktion ihre Arbeit an 1 bis n gleichartigen Parametern durchführen soll? In diesem Fall stellt uns C# das params Schlüsselwort zur Verfügung.

Nehmen wir doch gleich den zuletzt angeführten Anwendungsfall: ich möchte die Funktion so auslegen, daß sie ihre Arbeit an beliebig vielen Parametern durchführen kann. Das sieht dann so aus (sample.cs):

using System;

public class SimpleSample
{
 public void TakeParams(params object[] list)
 {
   foreach (object obj in list)
   {
     Console.WriteLine(obj.ToString());
   }
 }
 
 public static void Main()
 {
   SimpleSample ss = new SimpleSample();
   ss.TakeParams(1, "Test", 3.455);
 }
}

Die Funktion, die wir mit dem params Schlüsselwort versehen haben ist TakeParams. Dieser kann man nun eine beliebige Anzahl von Parametern übergeben - hier in diesem Beispiel mit drei demonstriert, der Leser kann nach Lust und Laune die Anzahl verändern - es wird weiterhin funktionieren.

Was man auch verändern kann, ist der Datentyp des Parameter Arrays - ich habe object gewählt, weil ich damit einfach alles übergeben kann, was es an Datentypen so gibt. Weis man im vorhinein, daß man zB nur Integers übergeben wird, sollte man das Parameter Array auch dementsprechend deklarieren.

Bevor ich nun mit weiteren Beispielen aufwarte, möchte ich den technischen Hintergrund hinter Parameter Arrays beleuchten, und wie .NET (und damit jede beliebige Sprache) erkennt, daß das Array hier ein Parameter Array ist. Dazu sehe ich mir meine kleine Beispielanwendung in ildasm.exe an:

Sieht doch irgendwie nach einfachem Object-Array aus, was die TakeParams Methode da annimmt, oder? Durch Doppelklick auf die TakeParams Methode bekomme ich Einblick in den IL Assembler:

.method public hidebysig instance void  TakeParams(object[] list) cil managed
{
  .param [1]
  .custom instance void [mscorlib]System.ParamArrayAttribute::.ctor() = ( 01 00 00 00 ) 
  // Code size       32 (0x20)
  .maxstack  2
  .locals init (object V_0,
           object[] V_1,
           int32 V_2)

Um niemand mit IL zu langweilen: der interessante Part ist ParamArrayAttribute. Dieses Attribut (auch auffindbar in der SDK Dokumentation) wird auf den letzten Parameter der Methode angewendet - und damit weiß .NET, daß es sich um kein gewöhnliches Array handelt, sondern um ein Parameter Array. Und dank dieser Information können alle Programmiersprachen damit umgehen.

Wer jetzt auf die Idee kommt, das Attribut selbst statt params zu verwenden (ich weiß nicht wer außer mir noch auf eine solche Idee kommen würde...)

public static void TakeParams([ParamArray()]object[] list)

bekommt eine Compilerfehlermeldung präsentiert:

error CS0674: Do not use 'System.ParamArrayAttribute'. Use the 'params' keyword instead.

Na gut, na gut, bleiben wir halt bei params ;-) Aber der technische Hintergrund ist jetzt klar, oder?

Weitere Anwendungen

Natürlich kann man an eine Funktion auch nicht-optionale Parameter mitgeben, zusätzlich zum Parameter Array. Wichtig ist, daß diese nicht-optionalen Parameter vor dem Parameter Array übergeben werden müssen - das Parameter Array muß immer am Schluß der Methodendeklaration sein. Der folgende Code stammt aus MoreSamples.cs:

using System;
using System.Text;

public class SimpleSample
{
 public static void TakeParams3(string strSeparator, 
                                out string strBuild,
                                params object[] list)
 {
   StringBuilder strBuilder = new StringBuilder();
   for (int i=0; i < list.GetLength(0); i++)
   {
     strBuilder.Append(list[i].ToString() + strSeparator);
   }
   strBuild = strBuilder.ToString();
 }

 public static void Main()
 {
   string strOut = "";
   TakeParams3("-", out strOut, "param1", 900, "param3");
   Console.WriteLine(strOut);
 }
}

Das stellt also auch keine Schwierigkeit dar.

In der Einleitung habe ich erwähnt, daß man mit Parameter Arrays optionale Parameter implementieren kann. Wie geht das? Im Prinzip kann man das auf zwei Arten implementieren:

• Optionale Parameter sind nur von rechts nach links zulässig (d.h. man kann nur am Ende der Liste auslassen, nicht irgendwo in der Mitte)
• Man übergibt für einen auszulassenden Parameter die null, falls dahinter noch ein weiterer Parameter kommt, den man übergeben möchte. Der Rest wird wie bei Option 1 gehandhabt - die äußerst rechten können entfallen.

Je nach Anwendungsfall kann man sich entscheiden, wobei die erste Option mit weniger Aufwand zu implementieren ist.

Schlußbemerkung

Damit hätten wir die Parameter Arrays abgehakt, die sich des öfteren als nützlich erweisen können.

Download des Codes

Klicken Sie hier, um den Download zu starten.

Verwandte Artikel

Das foreach Statement
Datentypen in C#
Die String Klasse in C#
Sichere Konvertierungen von Referenztypen
Unions in C#
Verwendung von Arrays in C#

Wenn Sie jetzt Fragen haben...

Wenn Sie Fragen rund um die in diesem Artikel vorgestellte Technologie haben, dann schauen Sie einfach bei uns in den Community Foren der deutschen .NET Community vorbei. Die Teilnehmer helfen Ihnen gerne, wenn Sie sich zur im Artikel vorgestellten Technologie weiterbilden möchten.

Eine weitere sehr hilfreiche Resource ist das deutsche ASP.NET Wiki, das als zentrale Anlaufstelle für Tips, Tricks, Know How und alles Nützliche was man in seinem Alltag als (ASP).NET-Entwickler so braucht und entdeckt gedacht ist.

Haben Sie Fragen die sich direkt auf den Inhalt des Artikels beziehen, dann schreiben Sie dem Autor! Unsere Autoren freuen sich über Feedback zu ihren Artikeln. Ein einfacher Klick auf die Autor kontaktieren Schaltfläche (weiter unten) und schon haben Sie ein für diesen Artikel personalisiertes Anfrageformular.

Und zu guter Letzt möchten wir Sie bitten, den Artikel zu bewerten. Damit helfen Sie uns, die Qualität der Artikel zu verbessern - und anderen Lesern bei der Auswahl der Artikel, die sie lesen sollten.