Glengamoi (Forum) · AspHeute · .NET Heute (RSS-Suche) · AspxFiles (Wiki) · .NET Blogs

Variable Parameterlisten in Funktionen

Geschrieben von: Christoph Wille
Kategorie: C#

This printed page brought to you by AlphaSierraPapa

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:

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.

This printed page brought to you by AlphaSierraPapa

Download des Codes

Klicken Sie hier, um den Download zu starten.
http://www.aspheute.com/code/20020125.zip

Verwandte Artikel

Das foreach Statement
http:/www.aspheute.com/artikel/20000720.htm
Datentypen in C#
http:/www.aspheute.com/artikel/20000726.htm
Die String Klasse in C#
http:/www.aspheute.com/artikel/20000803.htm
Sichere Konvertierungen von Referenztypen
http:/www.aspheute.com/artikel/20001019.htm
Unions in C#
http:/www.aspheute.com/artikel/20020207.htm
Verwendung von Arrays in C#
http:/www.aspheute.com/artikel/20000731.htm

 

©2000-2006 AspHeute.com
Alle Rechte vorbehalten. Der Inhalt dieser Seiten ist urheberrechtlich geschützt.
Eine Übernahme von Texten (auch nur auszugsweise) oder Graphiken bedarf unserer schriftlichen Zustimmung.