Neu in .NET 9.0 [8]: Generische Mengentypen bei variadischen Parametern in C#

Seit der ersten Version von C# gibt es Parameter-Arrays für sogenannte variadische Parameter (vgl. Wikipedia-Eintrag zu variadischen Funktionen), mit denen eine Methode eine beliebig lange Liste von Parametern eines Typs empfangen kann, wenn dies mit dem Schlüsselwort params eingeleitet wird.

Der Dotnet-Doktor – Holger Schwichtenberg

Dr. Holger Schwichtenberg ist technischer Leiter des Expertennetzwerks www.IT-Visions.de, das mit 53 renommierten Experten zahlreiche mittlere und große Unternehmen durch Beratungen und Schulungen sowie bei der Softwareentwicklung unterstützt. Durch seine Auftritte auf zahlreichen nationalen und internationalen Fachkonferenzen sowie mehr als 90 Fachbücher und mehr als 1500 Fachartikel gehört Holger Schwichtenberg zu den bekanntesten Experten für .NET und Webtechniken in Deutschland.

Der folgende Code zeigt die bisherige Variante eines variadischen Parameters mit Arrays:

public void MethodeMitBeliebigVielenParametern_Alt(string text, 
                                                 params int[] args)
{
 CUI.H2(nameof(MethodeMitBeliebigVielenParametern_Alt));
 CUI.Print(text + ": " + args.Length);
 foreach (var item in args)
 {
  CUI.LI(item);
 }
}

Die Methode kann man beispielsweise folgendermaßen aufrufen:

MethodeMitbeliebigVielenParametern_Alt("Anzahl Zahlen", 1, 2, 3);
MethodeMitbeliebigVielenParametern_Alt("Number of numbers",
                                       1, 2, 3, 4);

Neu in C# 13.0 ist, dass statt eines Arrays bei den variadischen Parametern auch generische Mengentypen verwendet werden dürfen (sogenannte Parameter Collections) wie params Span<T>:

public void MethodeMitBeliebigVielenParametern_Neu(string text,
                                                   params Span<int> args)
{
 CUI.H2(nameof(MethodeMitBeliebigVielenParametern_Neu));
 CUI.Print(text + ": " + args.Length);  // statt args.Length
 foreach (var item in args)
 {
  CUI.LI(item);
 }
}

Analog ist der Aufruf dann genauso flexibel möglich wie beim Parameter-Array:

MethodeMitBeliebigVielenParametern_Neu("Anzahl Zahlen", 1, 2, 3);
MethodeMitBeliebigVielenParametern_Neu("Number of numbers", 
                                       1, 2, 3, 4);

Dann sind diese generischen Mengentypen bei params in C# 13.0 erlaubt:

• Collections.Generic.IEnumerable<T>
• System.Collections.Generic.IReadOnlyCollection<T>
• Collections.Generic.IReadOnlyList<T>
• System.Collections.Generic.ICollection<T>
• Collections.Generic.IList<T>
• Alle Klassen, die Collections.Generic.IEnumerable<T>implementieren
• Span<T>
• ReadOnlySpan<T>

Wenn möglich, sollte man die Parameterliste per Span<T> oder ReadOnlySpan<T> übergeben, damit die Parameterübergabe komplett per Stack erfolgt und keinerlei Speicherallokation auf dem Heap erfolgen muss.

Ebenso wie man bei einem Parameter-Array auch ein fertiges Array übergeben kann, das dann auf die Parameter verteilt wird

MethodeMitBeliebigVielenParametern_Alt(
  "Anzahl Zahlen - übergeben als Int-Array", 
  [1, 2, 3]);

kann man auch einen der obigen neuen Typen übergeben, wenn die Methode eine Parameter Collection erwartet:

MethodeMitBeliebigVielenParametern_Neu(
  "Anzahl Zahlen - übergeben als List<int>", 
  new List<int> { 1, 2, 3 });

oder

MethodeMitBeliebigVielenParametern_Neu(
  "Anzahl Zahlen - übergeben als List<int>", 
  [1, 2, 3]);

Achtung: Die folgende Syntax funktioniert aber nicht:

MethodeMitBeliebigVielenParametern_Neu(
  "Anzahl Zahlen - übergeben als List<int>", 
  new List<int> [1, 2, 3 ]);

Das ist nicht möglich, da new List<int> [1, 2, 3 ] ein dreidimensionales Array von List<int> erzeugt.

(rme)