Microsoft hat Visual Studio Code 1.108 veröffentlicht. Traditionell nutzt Microsoft den Dezember für Aufräumarbeiten statt für ein reguläres Release, doch in diesem Jahr gibt es offenbar zwölf statt elf Releases. Dabei haben die VS-Code-Entwickler die Tradition beibehalten, im Dezember Issues und Pull Requests aufzuräumen: Rund 6000 davon wurden geschlossen, und darüber hinaus sind einige Feature-Updates in das Dezember-Update eingeflossen.

Profile importieren per Drag & Drop

Es ist nun möglich, Einstellungsprofile per Drag & Drop einer .code-profile-Datei in VS Code zu ziehen, ähnlich wie bei einer .code-workspace-Datei zum Öffnen eines Workspace. Dann öffnet sich der Profile-Editor, der eine Vorschau zeigt und das Importieren des Profils ermöglicht. Das soll es vereinfachen, Profile mit Teammitgliedern zu teilen oder schnell eine neue Umgebung aufzusetzen.

Spezialisierte Skills für den KI-Agenten

Als experimentelles Feature lassen sich Agent Skills in GitHub Copilot verwenden. Entwicklerinnen und Entwickler können dem KI-Agenten dadurch neue Fähigkeiten beibringen und ihn beispielsweise mit domänenspezifischem Wissen füttern. Agent Skills bestehen aus Ordnern mit Anweisungen, Skripte und Ressourcen, die GitHub Copilot bei Bedarf laden kann. Sie sind ein offener Standard und wurden ursprünglich vom Unternehmen Anthropic entwickelt.

Zu den Vorteilen zählen laut Microsoft die Kombinierbarkeit mehrerer Skills für das Erstellen komplexer Workflows, die Spezialisierungsmöglichkeit für domänenspezifische Aufgaben ohne wiederholenden Kontext und das effiziente Laden ausschließlich relevanter Inhalte. Die Skills können zudem Wiederholungen vermeiden, da sie sich über alle Unterhaltungen hinweg verwenden lassen.

Das Erstellen und Verwenden von Agent Skills behandelt die VS-Code-Dokumentation im Detail. Dort kommen auch die Unterschiede zwischen den Agent Skills und den VS-Code-spezifischen benutzerdefinierten Anweisungen (Custom Instructions) zur Sprache.

Neuerungen in Agent-Sessions- und Chat-Ansicht

Die Agent-Sessions-Ansicht wurde überarbeitet: Sie bietet nun Keyboard-Zugang zu Aktionen wie „Archivieren“, „State lesen“ und „Session öffnen“, zeigt Informationen zu geänderten Dateien sowie zugehörigen Pull Requests für eine Session und kann aus den neuen Gruppenabschnitten heraus mehrere Sessions auf einmal archivieren.

Neuerungen gibt es auch im Chat. Unter anderem werden nun vorherige Chat-Sessions nicht automatisch wiederhergestellt, wenn VS Code neu gestartet wird. Allerdings lassen sich aus der Agent-Sessions-Steuerung frühere Chat-Sessions aufrufen. Dieses neue Verhalten lässt sich in der Einstellung chat.viewRestorePreviousSession anpassen.

Hausputz im Dezember

Im Rahmen des jährlichen Dezember-Housekeeping hat das VS-Code-Entwicklungsteam dieses Mal 5951 offene Issues und Pull Requests geschlossen. Für weitere 1203 Issues wurde eine Triage durchgeführt, sodass diese nicht länger unter „Unknown Type“ laufen.

Alle weiteren Informationen zu den Neuerungen in VS Code 1.108 teilt das Entwicklungsteam in der Ankündigung mit.

(mai)

Die nachträgliche Erweiterbarkeit von Klassen um zusätzliche Methoden gibt es unter dem Namen Extension Methods bereits seit der C#-Sprachversion 3.0, die im Jahr 2007 zusammen mit .NET Framework 3.5 erschien. Dies ist sogar dann möglich, wenn die Klassen bereits an anderer Stelle kompiliert wurden, wie etwa die von Microsoft bereitgestellten Bibliotheken im .NET Framework.

Man kann mit Extension Methods aber lediglich eine Instanzmethode zu bestehenden Klassen ergänzen. So mussten Entwicklerinnen und Entwickler zwangsweise Konstrukte, die vom Namen her eigentlich Properties waren, leidigerweise als Methoden ausdrücken, siehe IsEmptyClassic() im nächsten Listing.

In der .NET-Klassenbibliothek gibt es aus diesem Grund einige Erweiterungsmethoden, die Namen besitzen, die man intuitiv als Property erwarten würde, darunter

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

Folgender Beispielcode zeigt die klassischen Erweiterungsmethoden:

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);
}

In C# 14.0 bietet Microsoft nun mit dem neuen Block-Schlüsselwort extension eine verallgemeinerte Möglichkeit der Erweiterung bestehender .NET-Klassen, die Erweiterungsblöcke (Extension Blocks) oder Erweiterungsmitglieder (Extension Members) genannt werden.

Das Schlüsselwort extension muss Teil einer statischen, nicht generischen Klasse auf der obersten Ebene sein (also keine Nested Class). Nach dem Schlüsselwort extension deklariert man den zu erweiternden Typ (Receiver). Im nächsten Listing ist der Receiver die Klasse System.String (alternativ abgekürzt durch den eingebauten Typ string). Alle Methoden und Properties innerhalb des Extension-Blocks erweitern dann den hier genannten Receiver-Typ. Aktuell kann man in diesen Extension-Blöcken folgende Konstrukte verwenden (siehe nächstes Listing):

• Instanz-Methoden
• Statische Methoden
• Instanz-Properties
• Statische Properties
• Operatoren

Da es keine Instanzfelder (Fields) in Erweiterungsblöcken gibt, kann man mit Erweiterungsblöcken nicht den Zustand einer Klasse erweitern. Man kann nur bestehende Zustände lesen und verändern (sofern der Typ mutable ist).

Ein Erweiterungsblock darf beliebig viele Erweiterungsmitglieder enthalten. Eine Klasse darf mehrere Erweiterungsblöcke sowie zusätzlich auch klassische Extension Methods und andere statische Mitglieder enthalten. Das erlaubt Entwicklerinnen und Entwicklern, in bestehenden Klassen mit klassischen Erweiterungsmethoden nun noch die neuen Erweiterungsblöcke zu implementieren. Es darf auch mehrere Klassen mit Extension-Blöcken für einen Receiver-Typ geben.

Folgendes Codebeispiel zeigt die Erweiterungen für System.String mit C# 14.0:

public static class MyExtensions
{
 // NEU in C# 14.0: // NEU in C# 14.0 Erweiterungsmitglieder (Schlüsselwort extension)
 extension(System.String s) // <-- Receiver (Zielklasse). 
 {
  /// 

  /// Erweitern um eine Instanz-Methode (alternative Möglichkeit zur bisherigen Syntax)
  /// 
  public string Truncate(int count)
  {
   if (s == null) return "";
   if (s.Length <= count) return s;
   return s.Substring(0, count) + string.Dots;
  }
 
  /// 

  /// NEU: Erweitern um eine Instanz-Eigenschaft nur mit Getter 
  /// 
  public bool IsEmpty => String.IsNullOrEmpty(s);
 
  /// 

  /// NEU: Erweitern um eine Instanz-Eigenschaft mit Getter und Setter 
  /// 
  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);
   }
  }
 
  /// 

  /// NEU: Erweitern um eine statische Methode
  /// 
  public static string Create(int count, char c = '.')
  {
   return new string(c, count);
  }
 
  /// 

  /// NEU: Erweitern um eine statische Instanz-Eigenschaft
  /// 
  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!!!
  }
  }
}

Folgender Code zeigt den Aufruf der Erweiterungsmethoden für die Klassen String und List:

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
 }

(rme)

Das Topangebot von Too Good to Go für leckere Donuts, die immer so schnell weg sind, oder die Information aus der Airthings-App, dass mit der Luft etwas nicht stimmt: Manche iOS-Mitteilungen (Notifications) scheinen wie verhext zu sein. Sie tauchen trotz der Tatsache, dass sie ganz normal in den Systemeinstellungen aktiviert sind, nur dann auf, wenn man das iPhone gerade aktiv bedient. Es gibt weder einen Auslieferungston noch, bei lautlosem Gerät, eine Vibration. In der Übersicht auf dem Sperrbildschirm sind sie ebenfalls zu sehen – nur eben erst dann, wenn man aktiv nachschaut. Das hat zur Folge, dass selbst vom Nutzer als wichtig angesehene Mitteilungen untergehen. Des Rätsels Lösung: Apple ermöglicht es Entwicklern, Mitteilungen auch „heimlich“ auszuliefern, eine Funktion im Code, die diese aktiv wählen müssen. Der Nutzer hat darüber dann allerdings keinerlei Kontrolle mehr, was viele nicht wissen.

Eine Konstante sorgt für Nerv

Seit iOS 15 können Developer für Mitteilungen nämlich auswählen, welchen „Interruption Level“ diese haben. Das Feature nennt sich UNNotificationInterruptionLevel, eine Konstante, die darlegt, wie wichtig eine Notification sein soll. Hier kann der Entwickler sie auf „Active“ stellen und damit ganz normal ausliefern – mit Aufleuchten des Bildschirms und Sound/Vibration. „Critical“ gibt die Mitteilung auch mit Ton aus, wenn das Gerät lautlos gestellt wurde. „TimeSensitive“ macht aus der Mitteilung eine „dringliche Mitteilung“, die auch einen Fokus durchbrechen kann.

Und dann gibt es noch „Passive“, also passiv. Und genau das ist die nervigste Variante für User, die informiert bleiben wollen: „Das System fügt die Benachrichtigung zur Benachrichtigungsliste hinzu, ohne den Bildschirm hell zu machen [falls das Gerät nicht verwendet wird] oder einen Ton abzuspielen.“ Das Problem betrifft auch die Apple Watch: Auch dort werden solche Mitteilungen lautlos ausgeliefert und landen nur in der Mitteilungsübersicht.

Entwickler nehmen Nutzern Einstellmöglichkeiten

Warum Developer für ihre Mitteilungen manchmal „Passive“ wählen, lässt sich schwer sagen. Eventuell denken diese, dass sie die Kunden nicht mit Mitteilungen überfrachten sollten. Manchmal ändert sich die Einstellung auch von App-Version zu App-Version – so geschehen bei erwähnter Airthings-App, die früher alle Warnungen sichtbar auslieferte. Dass damit dann möglicherweise wichtige Informationen schlicht verpasst werden, nehmen die Developer hin. User können wenig tun, sich nur bei den Entwicklern / App-Herstellern melden und diese bitten, doch wieder eine Änderung durchzuführen, damit Mitteilungen normal (UNNotificationInterruptionLevel auf „Active“) ausgeliefert werden.

Normal heißt dann, dass sich wie gewohnt über die Systemeinstellungen auswählen lässt, ob die Mitteilung einer App einen Benachrichtigungston und/oder eine Vibration hat – eine Sache von wenigen Sekunden. Entwickler, die fürchten, User mit zu vielen Mitteilungen zu überfrachten, können diesen erklären, wie sie hier gegebenenfalls vorgehen, statt ihnen die Entscheidung einfach abzunehmen. Und Apple sollte darüber nachdenken, ob sich die heimliche Auslieferung nicht über einen zentralen Knopf einfach abdrehen lassen könnte, wenn Nutzer dies wünschen. Hinzu kommt: Potenziell nervige Apps – von der Uber-Werbung bis zu Facebook – liefern ihre Mitteilungen natürlich niemals lautlos aus.

(bsc)