.NET 10.0'daki yenilikler [5]: C# 14.0'daki genişletme blokları

Sınıfların ek yöntemlerle daha sonra genişletilebilirliği, Uzantı Yöntemleri adıyla .NET Framework 3.5 ile birlikte 2007'de yayımlanan C# dilinin 3.0 sürümünden itibaren mevcuttur. Bu, sınıflar Microsoft tarafından .NET Framework'te sağlanan kitaplıklar gibi başka bir yerde zaten derlenmiş olsa bile mümkündür.

Uzantı yöntemleriyle mevcut sınıflara yalnızca bir örnek yöntem ekleyebilirsiniz. Ne yazık ki, geliştiriciler aslında isimdeki özellikler olan yapıları yöntem olarak ifade etmek zorunda kaldılar, bkz. IsEmptyClassic() bir sonraki listede.

Bu nedenle, .NET sınıf kitaplığında sezgisel olarak özellik olmasını bekleyeceğiniz adlara sahip bazı uzantı yöntemleri vardır:

• Enumerable.Count()
• Queryable.Count()
• Enumerable.First()
• Enumerable.Last()

Aşağıdaki örnek kod klasik uzantı yöntemlerini gösterir:

public static class StringExtensionClassic
{
   public static string TruncateClassic(this string s, int count)
   {
      if (s == null) return "";
      if (s.Length <= count) return s;
      return s.Substring(0, count) + "...";
   }

   public static bool IsEmptyClassic(this string s)
               => String.IsNullOrEmpty(s);
}

C# 14.0'da Microsoft artık yeni blok anahtar sözcüğünü sunuyor extension Uzantı blokları veya uzantı üyeleri olarak adlandırılan mevcut .NET sınıflarını genişletmenin genelleştirilmiş bir yolu.

Anahtar kelime extension en üst düzeyde statik, genel olmayan bir sınıfın parçası olmalıdır (yani iç içe geçmiş bir sınıf olmamalıdır). Anahtar kelimeden sonra extension Genişletilecek tür (alıcı) bildirilir. Bir sonraki listede alıcı sınıftır System.String (alternatif olarak yerleşik türden kısaltılmıştır) string). Uzatma bloğundaki tüm yöntemler ve özellikler burada belirtilen alıcı tipini genişletir. Şu anda bu uzantı bloklarında aşağıdaki yapıları kullanabilirsiniz (sonraki listeye bakın):

• Örnek yöntemleri
• Statik yöntemler
• Örnek özellikleri
• Statik özellikler
• operatörler

Uzantı bloklarında örnek alanlar bulunmadığından, uzantı blokları bir sınıfın durumunu genişletmek için kullanılamaz. Yalnızca mevcut durumları okuyabilir ve değiştirebilirsiniz (tür değiştirilebilir olduğu sürece).

Bir uzantı bloğu herhangi bir sayıda uzantı üyesi içerebilir. Bir sınıf, klasik uzantı yöntemleri ve diğer statik üyelerin yanı sıra birkaç uzantı bloğu içerebilir. Bu, geliştiricilerin klasik genişletme yöntemleriyle mevcut sınıflara yeni uzantı blokları uygulamasına olanak tanır. Bir alıcı tipi için uzatma bloklarına sahip birden fazla sınıf da olabilir.

Aşağıdaki kod örneği şunun için uzantıları gösterir: System.String C# 14.0 ile:

public static class MyExtensions
{
 // NEU in C# 14.0: // NEU in C# 14.0 Erweiterungsmitglieder (Schlüsselwort extension)
 extension(System.String s) // <-- Receiver (Zielklasse). 
 {
  /// <summary>
  /// Erweitern um eine Instanz-Methode (alternative Möglichkeit zur bisherigen Syntax)
  /// </summary>
  public string Truncate(int count)
  {
   if (s == null) return "";
   if (s.Length <= count) return s;
   return s.Substring(0, count) + string.Dots;
  }
 
  /// <summary>
  /// NEU: Erweitern um eine Instanz-Eigenschaft nur mit Getter 
  /// </summary>
  public bool IsEmpty => String.IsNullOrEmpty(s);
 
  /// <summary>
  /// NEU: Erweitern um eine Instanz-Eigenschaft mit Getter und Setter 
  /// </summary>
  public int Size
  {
   get { return s.Length; }
   set
   {
    // Neuzuweisung geht nicht; Da Strings immutable sind, funktioniert die Setter-Logik so nicht!!!
    if (value < s.Length) s = s.Substring(0, value);
    if (value > s.Length) s = s + new string('.', value - s.Length);
   }
  }
 
  /// <summary>
  /// NEU: Erweitern um eine statische Methode
  /// </summary>
  public static string Create(int count, char c = '.')
  {
   return new string(c, count);
  }
 
  /// <summary>
  /// NEU: Erweitern um eine statische Instanz-Eigenschaft
  /// </summary>
  public static string Dots => "...";
 
  // NEU: Erweitern um eine Operatorüberladung  
  public static string operator *(string str, int i) // Operatorüberladung
  {
   return string.Concat(Enumerable.Repeat(str, i)); ;
  }
 
  // NEU: Operatorüberladung als Extension und neu ist auch, dass man ++ überladen kann
  public void operator ++()
  {
   s = s + String.Dots; // Das funktioniert so nicht, da Strings immutable sind!!!
  }
  }
}

Aşağıdaki kod, sınıflar için uzantı yöntemlerinin nasıl çağrılacağını gösterir String VE List<int>:

public void Run()
 {
  CUI.Demo(nameof(CS14_ExtensionDemo) + ": String");
 
  string s1 = "Hallo Holger";
  Console.WriteLine($"Vorher: {s1}");
  string s2 = s1.TruncateClassic(5);
  Console.WriteLine($"Nach TruncateClassic(): {s1}"); // Hello...
  Console.WriteLine($"IsEmptyClassic():{s2.IsEmptyClassic()}"); // false
 
  string s3 = "Hallo Holger";
  Console.WriteLine($"Vorher: {s3}");
  string s4 = s3.Truncate(5);
  Console.WriteLine($"Nach Truncate(): {s4}"); // Hello...
  Console.WriteLine($"IsEmpty:{s4.IsEmpty}"); // false
 
  string s5 = (s1 + "! ") * 3; 
  Console.WriteLine($"*3: {s5}"); // "Hallo Holger!Hallo Holger!Hallo Holger!"
 
  string s6 = string.Create(5, '#');
  Console.WriteLine($"string.Create(5, '#'): {s6}"); // "#####"
 
  #region nicht möglich
  CUI.H2("s1.Size = 5 --> das geht nicht, weil die Size Property versucht, die Zeichenkette neu zuzuweisen!");
  // Das geht nicht, weil die Size Property versucht, die Zeichenkette neu zuzuweisen!
  s1.Size = 5;
  Console.WriteLine(s1); // "Hallo Holger" statt wie erwartet "Hallo"
  s1++;
  Console.WriteLine(s1); // "Hallo Holger" statt wie erwartet "Hallo Holger..."
  #endregion
 }

(Ben)