Neu in .NET 10.0 [6]: Generische Erweiterungsblöcke in C# 14.0

Die Erweiterungsblöcke in C# 14.0 dürfen auch generische Typparameter enthalten.

(Bild: Pincasso / Shutterstock.com)

07:23 Uhr

Lesezeit: 1 Min.

Von

Dr. Holger Schwichtenberg

Erweiterungsblöcke mit dem Schlüsselwort extension habe ich in der vorherigen Folge der Serie zu .NET 10.0 vorgestellt. Ein Erweiterungsblock darf einen oder mehrere generische Typparameter (optional inklusive Einschränkung mit where) besitzen:

extension<T>(List<T> source) { … }

oder

extension<T>(List<T> source) where T : INumber<T> { … }

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.

Folgender Code zeigt eine Klasse mit Erweiterungsblocken für List<T>, wobei T auf Zahlen beschränkt ist, durch where T : INumber<T>:

public static class MyExtensions
{
 extension<T>(List<T> source) where T : INumber<T> // <-- Receiver Ein Erweiterungsblock darf eine oder mehrere generische Typparameter (optional inklusive Constraint) besitzen!!!
 {
  public List<T> WhereGreaterThan(T threshold)
           => source.Where(x => x > threshold).ToList();
 
  public bool IsEmpty
           => !source.Any();
 
  /// <summary>
  /// Erweitern um eine Instanz-Eigenschaft mit Getter und Setter
  /// </summary>
  public int Size
  {
   get { return source.Count; }
   set
   {
    while (value < source.Count) source.RemoveAt(source.Count - 1);
    if (value > source.Count) source.AddRange(Enumerable.Repeat(default(T)!, value - source.Count).ToList());
   }
  }
 
  // NEU: Operatorüberladung als Extension und neu ist auch, dass man += überladen kann
  public void operator +=(int count)
  {
   source.Size = source.Count + count;
  }
 
  // NEU: Operatorüberladung als Extension und neu ist auch, dass man -= überladen kann
  public void operator -=(int count)
  {
   source.Size = source.Count - count;
  }
 
  // NEU: Operatorüberladung als Extension und neu ist auch, dass man ++ überladen kann
  public void operator ++()
  {
   source.Size += 1;
  }
 }
}

Folgender Code ruft die Erweiterungsmethoden für List<int> auf:

public void Run()
 {
  CUI.Demo(nameof(CS14_ExtensionDemo) + ": Collection");
 
  var list = new List<int> { 1, 2, 3, 4, 5 };
  var large = list.WhereGreaterThan(3);
  Console.WriteLine(large.IsEmpty);
  if (large.IsEmpty)
  {
   Console.WriteLine("Keine Zahlen größer als 3!");
  }
  else
  {
   Console.WriteLine(large.Count + " Zahlen sind größer als 3!");
  }
 
  CUI.H2("list.Size = 10");
  // Das klappt: Die Liste wird auf 10 Elemente mit Nullen aufgefüllt
  list.Size = 10;
  foreach (var x in list)
  {
   CUI.OL(x, separator: " = ");
  }
 
  CUI.H2("list.Size -= 2");
  list.Size -= 2;
  bool restart = true;
  foreach (var x in list)
  {
   CUI.OL(x, separator: " = ", restartCounter: restart);
   restart = false;
  }
 
  CUI.H2("list.Size++");
  list.Size++;
  restart = true;
  foreach (var x in list)
  {
   CUI.OL(x, separator: " = ", restartCounter: restart);
   restart = false;
  }
 }

Videos by heise