Connect with us

Entwicklung & Code

Open Source ist nicht das Problem, sondern sein Missbrauch durch Konzerne


close notice

This article is also available in
English.

It was translated with technical assistance and editorially reviewed before publication.

Wer heute Software entwickelt und dafür Geld verlangt, muss sich rechtfertigen. Wer sie verschenkt, gilt als moralisch überlegen. Diese Haltung hat ein Strukturproblem geschaffen, das die gesamte Branche betrifft.

Weiterlesen nach der Anzeige


the next big thing – Golo Roden

the next big thing – Golo Roden

Golo Roden ist Gründer und CTO von the native web GmbH. Er beschäftigt sich mit der Konzeption und Entwicklung von Web- und Cloud-Anwendungen sowie -APIs, mit einem Schwerpunkt auf Event-getriebenen und Service-basierten verteilten Architekturen. Sein Leitsatz lautet, dass Softwareentwicklung kein Selbstzweck ist, sondern immer einer zugrundeliegenden Fachlichkeit folgen muss.

Open Source hat in den vergangenen Jahrzehnten die Softwareentwicklung grundlegend verändert, und zwar überwiegend zum Besseren. Quelloffene Projekte haben Wissen demokratisiert, Zusammenarbeit über Unternehmensgrenzen hinweg ermöglicht und Innovationszyklen beschleunigt. Doch hinter der Erfolgsgeschichte verbirgt sich ein Mechanismus, den erstaunlich wenige hinterfragen: Open Source ist längst nicht mehr nur ein Modell der Zusammenarbeit. Es ist zu einem strategischen Instrument geworden, das vor allem denjenigen nutzt, die es am wenigsten nötig haben.

Es gibt einen Satz, den vermutlich jede Entwicklerin und jeder Entwickler schon einmal gehört hat:

„Warum soll ich dafür bezahlen, wenn es das auch als Open Source gibt?“

Die Frage klingt pragmatisch, beinahe vernünftig. Doch sie offenbart ein Denkmuster, das sich über Jahre eingeschliffen hat und das weitreichende Konsequenzen hat.

Open Source hat dazu beigetragen, dass wir den Wert von Softwarearbeit systematisch herabgesetzt haben. Nicht den Wert der Ausführung, wohlgemerkt, denn Entwicklerinnen und Entwickler werden nach wie vor gut bezahlt, wenn sie in Anstellung arbeiten. Sondern den Wert der Gedankenleistung, die in ein Softwareprodukt fließt: das Durchdenken einer Architektur, das Entwerfen einer API, das Lösen eines komplexen fachlichen Problems. All das verschenken wir, weil es als selbstverständlich gilt, dass Software im Quellcode frei verfügbar sein sollte.

Weiterlesen nach der Anzeige

Was dabei verloren geht, ist das Bewusstsein dafür, dass Softwareentwicklung nicht nur Handwerk ist, sondern auch geistige Schöpfung. Wenn ein Autor ein Buch schreibt, erwartet niemand, dass er es kostenlos verteilt. Wenn eine Architektin ein Gebäude entwirft, käme niemand auf die Idee, den Entwurf als Open Source zu veröffentlichen. Doch bei Software hat sich die Erwartung etabliert, dass alles, was nicht hinter einer Bezahlschranke steht, auch nichts kosten darf. Und wer dennoch Geld verlangt, steht unter Rechtfertigungsdruck.

Das ist eine bemerkenswerte Entwicklung. Innerhalb weniger Jahrzehnte haben wir uns daran gewöhnt, dass die intellektuelle Leistung hinter Software keinen monetären Wert hat, solange sie in Form von Quellcode vorliegt. Wir haben kostenlos zur Normalität erklärt und Bezahlen zur Ausnahme. Dabei übersehen wir, dass hinter jeder Bibliothek, jedem Framework und jedem Tool Hunderte oder Tausende Stunden stecken, in denen jemand nachgedacht, entworfen, verworfen und neu gebaut hat. Diese Stunden haben einen Wert. Doch das vorherrschende Narrativ der Branche erzählt uns, dass dieser Wert erst dann legitim ist, wenn jemand anderes darauf einen Service baut und diesen verkauft.

Wer verstehen will, warum Open Source heute so funktioniert, wie es funktioniert, muss den Blick auf diejenigen richten, die am meisten davon profitieren. Und das sind nicht die einzelnen Entwicklerinnen und Entwickler, die ihre Wochenenden in ein Projekt investieren. Es sind die großen Technologiekonzerne.

Nehmen wir PostgreSQL als Beispiel. PostgreSQL gilt als Vorzeigeprojekt der Open-Source-Welt: stabil, leistungsfähig, kostenlos. Was viele nicht wissen oder bewusst ausblenden: Ein erheblicher Teil der Entwicklung wird von Unternehmen wie Microsoft, Google und Amazon finanziert. Die Entwicklerinnen und Entwickler, die den Kern von PostgreSQL vorantreiben, sind zu großen Teilen bei genau diesen Konzernen angestellt.

Auf den ersten Blick wirkt das wie Altruismus. Microsoft investiert in eine Datenbank, die dem eigenen Produkt (dem SQL Server) Konkurrenz macht. Warum sollte ein Konzern das tun? Die Antwort ist ernüchternd schlicht: Weil sich die Rechnung trotzdem lohnt. Jede PostgreSQL-Instanz, die auf Azure läuft, bringt Microsoft Umsatz. Es spielt keine Rolle, ob der SQL Server dabei Marktanteile verliert, solange die Cloud-Plattform gewinnt. Die Investition in Open Source ist keine Spende. Sie ist eine strategische Entscheidung mit kalkulierbarem Return.

Dieses Muster wiederholt sich in der gesamten Branche. Kubernetes wird maßgeblich unter anderem von Google und Microsoft vorangetrieben. Linux wird von allen großen Cloudanbietern unterstützt, weil es die Grundlage ihrer Infrastruktur bildet. Chromium ist Open Source, doch Google kontrolliert die Richtung. Überall dort, wo Konzerne Open-Source-Projekte finanzieren, geschieht das nicht aus Idealismus. Es geschieht, weil es ihr Geschäftsmodell stützt.

Und es geht noch weiter. Viele der großen Open-Source-Projekte werden über Foundations organisiert, die den Anschein von Neutralität und Gemeinschaftlichkeit erwecken. Die Cloud Native Computing Foundation, die Linux Foundation, die Apache Software Foundation: Sie alle werden in erheblichem Maße von denselben Konzernen getragen, die von den Projekten profitieren. Die Foundation-Struktur verleiht dem Ganzen Legitimität und schafft den Eindruck, hier arbeite eine unabhängige Community am Gemeinwohl. Im Hintergrund sind es aber oft dieselben Geldgeber, die auch die strategische Ausrichtung beeinflussen.

Es wäre naiv, das als Zufall abzutun. Die Konzerne haben erkannt, dass Open Source ein hervorragendes Mittel ist, um Märkte zu gestalten, ohne die damit verbundenen Kosten vollständig selbst tragen zu müssen. Die Community liefert Code, Dokumentation, Bug-Reports und Evangelismus. Die Konzerne liefern Infrastruktur, Hosting und Managed-Services. Wer dabei das bessere Geschäft macht, muss man nicht lange überlegen.

Was bedeutet das für diejenigen, die Software nicht verschenken können oder wollen? Für kleine Unternehmen, die mit einem kommerziellen Produkt am Markt bestehen müssen?

Sie stehen vor einer doppelten Herausforderung. Auf der einen Seite konkurrieren sie mit den Großen, die über nahezu unbegrenzte Ressourcen verfügen: Marketing-Budgets, Vertriebsstrukturen, Bekanntheit. Das war schon immer schwierig. Doch Open Source hat eine zweite Barriere geschaffen, die mindestens ebenso wirksam ist.

Denn kleine Anbieter konkurrieren nicht nur mit den Konzernen selbst. Sie konkurrieren auch mit den Open-Source-Alternativen, die von eben diesen Konzernen finanziert werden. Wer eine kommerzielle Datenbank anbietet, kämpft nicht nur gegen Oracle und Microsoft. Er kämpft auch gegen PostgreSQL und gegen die Erwartungshaltung, dass eine Datenbank nichts kosten darf, weil es ja eine kostenlose Alternative gibt.

Open Source wird auf diese Weise zum Burggraben der großen Konzerne. Nicht, weil die Konzerne die Open-Source-Projekte direkt kontrollieren, sondern weil sie über die Finanzierung ein Ökosystem geschaffen haben, in dem kommerzielle Alternativen es schwer haben, überhaupt wahrgenommen zu werden. Der Markt wird von zwei Seiten eingeengt: von oben durch die Konzerne mit ihren Managed-Services, von unten durch die kostenlosen Alternativen, die oft von denselben Konzernen mitfinanziert werden.

Wer als kleines Unternehmen in diesem Umfeld ein kommerzielles Softwareprodukt anbietet, muss nicht nur technisch überzeugen. Er muss zunächst einmal erklären, warum das eigene Produkt überhaupt etwas kosten darf. Diese Erklärungspflicht existiert in kaum einer anderen Branche in dieser Form. Niemand fragt einen Handwerker, warum sein Angebot nicht kostenlos ist. Niemand erwartet von einer Steuerberaterin, dass sie ihre Arbeit verschenkt, weil es irgendwo eine kostenlose Vorlage gibt. Doch bei Software ist diese Frage so tief verankert, dass sie oft nicht einmal bewusst gestellt wird. Sie schwingt einfach mit, in jedem Evaluierungsprozess, in jeder Kaufentscheidung, in jedem Vergleich.

Das Ergebnis ist ein Markt, der Innovation dort bremst, wo sie am meisten gebraucht würde. Kleine, spezialisierte Anbieter, die spezifische Probleme besser lösen könnten als generische Open-Source-Werkzeuge, schaffen es oft gar nicht erst in die engere Auswahl. Nicht, weil ihre Produkte schlechter sind, sondern weil sie gegen eine Erwartungshaltung antreten, die von den Großen systematisch kultiviert wird.

Besonders perfide ist dabei die Dynamik, die sich aus dem Zusammenspiel ergibt. Die Konzerne finanzieren Open-Source-Projekte, die den Markt für kommerzielle Alternativen austrocknen. Gleichzeitig bauen sie auf denselben Open-Source-Projekten Managed-Services auf, die sie gewinnbringend verkaufen. Der kleine Anbieter zahlt also doppelt: Er verliert potenzielle Kundinnen und Kunden an die kostenlose Alternative und an den Managed-Service des Konzerns, der auf eben dieser Alternative basiert.

An dieser Stelle wird es unbequem. Denn die Konzerne können dieses Spiel nur spielen, weil die Community es mitträgt. Und zwar nicht aus böser Absicht, sondern aus einer Mischung aus Idealismus und Kurzsichtigkeit.

In der Entwickler-Community hat sich über Jahrzehnte eine Überzeugung verfestigt, die selten hinterfragt wird: Open Source ist gut. Kommerziell ist verdächtig. Wer Software verschenkt, handelt im Sinne der Gemeinschaft. Wer Geld dafür verlangt, hat erklärungsbedürftige Motive.

Diese Haltung ist verständlich. Sie wurzelt in einer Zeit, in der Software tatsächlich überteuert war, in der Lizenzmodelle undurchsichtig waren und Vendor-Lock-in die Regel. Open Source war die Antwort auf reale Probleme, und es hat viele dieser Probleme gelöst. Doch die reflexhafte Verteidigung von Open Source als moralisch überlegenes Modell ignoriert, wie sich die Rahmenbedingungen verändert haben.

Heute ist Open Source kein Gegenmodell mehr zu den großen Konzernen. Es ist ein integraler Bestandteil ihrer Strategie. Und wer in der Community weiterhin jedes Open-Source-Projekt verteidigt, ohne zu fragen, wer dahintersteht und wer davon profitiert, macht sich zum Werkzeug genau jener Interessen, die man eigentlich kritisch sehen sollte.

Das zeigt sich besonders deutlich im Umgang mit Maintainerinnen und Maintainern, die an ihren Projekten zerbrechen. Die Burnout-Rate unter Open-Source-Maintainern ist erschreckend hoch. Menschen investieren Jahre ihrer Freizeit in Projekte, die von Millionen genutzt werden, und erhalten dafür bestenfalls Anerkennung, schlimmstenfalls Beschwerden über zu langsame Bugfixes. Die Community reagiert darauf mit Mitleid und dem Verweis auf Sponsoring-Modelle, die in der Praxis kaum funktionieren. Was sie nicht tut: die grundlegende Frage stellen, ob es richtig ist, dass diese Arbeit überhaupt kostenlos erwartet wird.

Denn genau das ist der blinde Fleck. Die Community verteidigt ein System, das den Wert von Arbeit nach dem Lizenzmodell bemisst, nicht nach der Qualität oder dem Nutzen. Ein Projekt ist gut, weil es Open Source ist. Nicht, weil es ein Problem besser löst als die Alternativen. Diese Umkehrung der Bewertungskriterien schadet nicht nur den Maintainern. Sie schadet der gesamten Softwarebranche, weil sie Innovation dort bremst, wo sie am dringendsten gebraucht wird: bei kleinen, spezialisierten Anbietern, die es sich nicht leisten können, ihre Arbeit zu verschenken.

Und es gibt noch einen weiteren Aspekt, der selten ausgesprochen wird: Viele Nutzerinnen und Nutzer wählen Open Source nicht aus Überzeugung, sondern schlicht, weil es kostenlos ist. Die moralische Überhöhung dient als bequeme Rechtfertigung für eine Entscheidung, die im Kern ökonomisch motiviert ist. Das wäre an sich nicht verwerflich. Doch es wird problematisch, wenn dieselben Menschen andere dafür kritisieren, dass sie für ihre Software Geld verlangen. Es entsteht eine Kultur, in der kostenlos als ethisch gilt und das Verlangen einer Bezahlung als gierig, und in der diese Zuschreibungen kaum noch hinterfragt werden.

Wer etwa als Unternehmen eine Technologieentscheidung trifft und sich für ein Open-Source-Produkt entscheidet, tut das selten aus ideologischer Überzeugung. Die Budgetfreigabe für ein kostenloses Tool ist schlicht einfacher als für ein kommerzielles. Dass die versteckten Kosten in Form von Einarbeitung, Anpassung und fehlendem Support oft höher liegen als ein Lizenzpreis, wird in der Kalkulation gerne übersehen. Open Source gewinnt die Evaluierung nicht, weil es besser ist, sondern weil es den geringeren Erklärungsbedarf hat.

Ich möchte nicht missverstanden werden. Dieser Blogpost ist kein Plädoyer gegen Open Source. Ich möchte nicht zurück in eine Zeit, in der ein C-Compiler mehrere tausend Mark kostete und eine Textverarbeitung ein Luxusgut war. Open Source hat Barrieren abgebaut, Wissen zugänglich gemacht und die Art, wie wir Software entwickeln, grundlegend verbessert. Das ist eine Leistung, die man nicht kleinreden sollte.

Aber ebenso wenig sollte man die Augen davor verschließen, was aus Open Source geworden ist. Es ist heute nicht mehr nur ein Modell der Zusammenarbeit und des Teilens. Es ist ein strategisches Werkzeug in den Händen von Konzernen, die es nutzen, um ihre Marktposition zu sichern und den Wettbewerb einzuschränken. Und es ist ein System, das die Arbeit derjenigen entwertet, die es am Leben halten.

Das Problem ist nicht Open Source selbst. Das Problem sind die Strukturen, die sich um Open Source herum gebildet haben. Es sind die Konzerne, die Open-Source-Projekte instrumentalisieren, ohne dafür die Verantwortung zu übernehmen, die mit einer solchen Abhängigkeit einhergeht. Und es ist eine Community, die dieses Spiel unreflektiert mitspielt, weil die Alternative bedeuten würde, liebgewonnene Überzeugungen infrage zu stellen.

Was es braucht, ist ein differenzierterer Blick. Ein Verständnis dafür, dass Open Source und kommerziell keine moralischen Kategorien sind, sondern Lizenzmodelle. Dass die Frage nicht lautet, ob Software etwas kosten darf, sondern wer davon profitiert, wenn sie es nicht tut. Und dass die reflexhafte Verteidigung von „kostenlos“ oft genau denen in die Hände spielt, deren Marktmacht man eigentlich einschränken wollte.

Open Source ist nicht das Problem. Aber wer so tut, als wäre es die Lösung für alles, hat das eigentliche Problem noch nicht erkannt.


(rme)



Source link

Entwicklung & Code

Kommentar: Microsofts Open-Source-Liebe hat einen Preis


close notice

This article is also available in
English.

It was translated with technical assistance and editorially reviewed before publication.

Wie sich die Zeiten doch ändern: Ausgerechnet Microsoft liefert heute Open Source frei Haus. Richtig praktische und wirklich offene Werkzeuge für Entwickler reihte der Konzern auf der Build 2026 auf – ein quelloffenes KI-Terminal, hilfreiche Dev Configs, dazu WSL-Container und mehr als 75 Unix-Werkzeuge der Coreutils. Doch wer darin nur Entwicklerfreundlichkeit sieht, verpasst den eigentlichen Coup. Open Source ist inzwischen das perfekte Business für den Konzern.

Weiterlesen nach der Anzeige


Ein Kommentar von Moritz Förster

Ein Kommentar von Moritz Förster

Moritz Förster schreibt seit 2012 für die iX und heise online. Er betreut neben dem iX-Channel den Bereich Arbeitsplatz.

Microsoft ging gegen offene Standards lange strategisch vor – und die Strategie trug in den 90ern ein berüchtigtes Kürzel: „EEE – Embrace, Extend, and Extinguish“. Das US-Justizministerium dokumentierte, wie der Konzern dabei vorging. Erst drang Microsoft in Märkte mit offenen Standards ein, dann erweiterte es diese Standards um proprietäre Funktionen, und schließlich nutzte es die so entstandenen Unterschiede, um die Konkurrenz auszuschalten.

Sofort wurde das zu Microsofts Geschäftspraxis: Zum Beispiel setzt Microsoft im Browserkrieg den Internet Explorer nicht nur offensiv gegen Netscape ein; interne Memos zeigen darüber hinaus, dass der Konzern Office und HTML-Funktionen so verzahnen wollte, dass sie als Hebel ausschließlich das eigene Ökosystem stärken.

Doch die Ankündigungen der Build 2026 sind nicht einfach nur EEE 2.0 mit besserem Marketing. Das Umarmen war immer nur Mittel zum Zweck, und der Zweck hieß ersticken. Heute fehlt diese dritte Stufe.

Microsoft gibt bei den Werkzeugen, die Entwickler täglich nutzen, keinen Zentimeter Boden auf. Niemand muss migrieren oder sich umgewöhnen. Und niemand lockt den offenen Standard in eine proprietäre Sackgasse. Was hier an Reibung verschwindet, kostet Microsoft nur Entwicklungsaufwand – aber keinesfalls Marktmacht.

Nehmen wir als Beispiel die Datenbanken: Statt einer hauseigenen, geschlossenen Datenbank setzt Microsoft mit Azure HorizonDB auf das offene PostgreSQL. Die Botschaft: Bleibt bei Postgres, wir bauen die KI-Bausteine drumherum. Ausgerechnet der Konzern, der mit proprietären Datenbanken groß wurde, setzt jetzt auf die Open-Source-Alternative.

Weiterlesen nach der Anzeige

Die Motivation ist betriebswirtschaftlich, Satya Nadella hat das nie verheimlicht. Seit 2014 verschiebt Microsoft sein Kerngeschäft von der Lizenzsoftware zu den Plattformdiensten, und Nadella sagt offen, dass sich mit geschlossenen Lizenzen auf Dauer kein Staat mehr machen lässt. Warum eine Lizenz einmal verkaufen, wenn man dieselbe Leistung monatlich vermieten kann? Dass heute über die Hälfte der Azure-Workloads unter Linux laufen, gehört inzwischen zum Geschäftsmodell.

Der Coup steckt im Business-Schlachtfeld selbst. Der Kampf heißt nicht mehr Windows gegen Open Source. Er heißt Cloud gegen Cloud. Die Maut kassiert Microsoft nicht mehr an der Systemgrenze, sondern beim Cloud-Dienst: bei Azure, bei GitHub, beim Copilot-Abo. Der Konzern stellt das Kassenhäuschen einfach woanders auf.

Selbst Steve Ballmer hat das inzwischen eingeräumt. Seine frühere Haltung sei für ihre Zeit richtig gewesen, doch die Linux-Bedrohung liege heute „im Rückspiegel“. Und die harte Linie habe dem Konzern damals mehr Umsatz gebracht, als ein frühes Umarmen es getan hätte. Erst kämpfen, dann kassieren, schließlich umarmen – aus Sicht der Bilanz hat sich jede Phase gelohnt.

Man sollte die Wende trotzdem nicht zu gutgläubig feiern. Viele Entwickler misstrauen dem freundlichen Microsoft bis heute aus gutem Grund. Als der Konzern 2021 eine Hot-Reload-Funktion aus dem quelloffenen .NET herauslösen wollte und sie erst nach lautem Protest zurückholte, blitzten die alten Reflexe wieder auf. Auch die heute „umarmten“ Werkzeuge wie GitHub, Copilot und Codespaces tragen proprietäre Schichten in sich. Jede Nutzung zentralisiert die Branche ein Stück weiter auf einen einzigen Anbieter.

Microsofts Open-Source-Zuneigung mag heute echt sein – aber sie entspringt eben nicht einem Altruismus, sondern dem nüchternen Kalkül, nicht wie einst IBM zu erstarren. Doch in fünf Jahren kann schon wieder eine andere Business-Logik gelten.


(fo)



Source link

Weiterlesen

Entwicklung & Code

Visual Studio Code 1.123 synchronisiert Agenten-Sessions über Geräte hinweg


close notice

This article is also available in
English.

It was translated with technical assistance and editorially reviewed before publication.

Microsoft bringt in Version 1.123 von Visual Studio Code weitere neue Features für den Umgang mit großen Sprachmodellen. Dazu gehören synchronisierte Chat-Sessions über mehrere Geräte hinweg, ein vergrößertes Kontextfenster für spezielle Modelle und die Möglichkeit, multiple Agenten-Fenster parallel zu öffnen.

Weiterlesen nach der Anzeige

Als neue Standardfunktion synchronisiert Visual Studio Code nun Chat-Sessions zum GitHub-Account seiner Nutzerinnen und Nutzer, inklusive aller lokalen Agenten-Sessions. Wie Microsoft betont, seien die synchronisierten Chats privat, außer wenn Nutzer sie explizit teilen. Auf github.com erscheinen die Chats im Agents-Tab eines Repositories und lassen sich durchsuchen.

Wer die Synchronisierung nicht nutzen will, setzt die auf Organisationsebene bestehende Einstellung chat.sessionSync.enabled auf false.

Das Preview-Feature Agents Window hat eine neue Funktion erhalten: Neben einer geöffneten Agenten-Session lässt sich nun eine zusätzliche in „Side by Side“-Ansicht öffnen. Um eine weitere Session zu öffnen, wählen Entwicklerinnen und Entwickler im Kontextmenü einer Session innerhalb der Session-Liste Open to the Side aus, ziehen die gewünschte Session per Drag & Drop in den Sessions-Ansichtsbereich oder wählen sie bei gedrückter Alt-Taste aus.

Dabei ist zu beachten, dass jeweils nur eine der sichtbaren Sessions aktiv ist. Eine neue ausgewählte Session wird automatisch zur aktiven Session View, außer wenn die vorherige Session angepinnt wurde. Das Anpinnen erfolgt über die Pin-Aktion in der oberen rechten Ecke der View.

Weiterlesen nach der Anzeige


VS Code 1.123: Zwei Agenten-Sessions – hier eine Claude-Opus- und eine Claude-Sonnet-Session – lassen sich nebeneinander betrachten.

VS Code 1.123: Zwei Agenten-Sessions – hier eine Claude-Opus- und eine Claude-Sonnet-Session – lassen sich nebeneinander betrachten.

VS Code 1.123: Zwei Agenten-Sessions – hier eine Claude-Opus-4.8- und eine Claude-Sonnet-4.6-Session – lassen sich nebeneinander betrachten.

(Bild: Microsoft)

Ein weiteres Update betrifft das Kontextfenster unterstützter Anthropic- und OpenAI-Modelle: Es kann nun eine Million Token umfassen. Diese Erweiterung soll es Usern ermöglichen, mit deutlich größeren Codebasen zu arbeiten sowie längere Konversationen zu führen, ohne wichtigen Kontext einzubüßen.

Weitere Details zu den Neuerungen in Visual Studio Code 1.123 lassen sich der Ankündigung entnehmen.

Dabei handelt es sich nicht um die einzigen Updates im Bereich KI von Microsoft: Im Rahmen der in dieser Woche stattgefundenen Hauskonferenz Microsoft Build wurde unter anderem eine eigenständige Desktopanwendung für GitHub Copilot vorgestellt.


(mai)



Source link

Weiterlesen

Entwicklung & Code

Neu in .NET 10.0 [26]: LINQ-Operationen auf IAsyncEnumerable


IAsyncEnumerable ist die in .NET Core 3.0 eingeführte asynchrone Variante von IEnumerable. Sie ermöglicht asynchrone Streams: das schrittweise, nicht-blockierende Iterieren über Daten, die asynchron bereitgestellt werden.

Weiterlesen nach der Anzeige


Der Dotnet-Doktor – Holger Schwichtenberg

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.

LINQ-Operationen auf IAsyncEnumerable erforderten bisher das NuGet-Paket System.Linq.Async. Nun ist diese Funktionalität im Kern von .NET verfügbar.


betterCode() .NET 11.0

betterCode() .NET 11.0

(Bild: King / stock.adobe.com)

Das ist neu in .NET 11.0: Dr. Holger Schwichtenberg und weitere Experten präsentieren am 17. November 2026 auf der Online-Konferenz betterCode() .NET 11.0 die Änderungen für Entwicklerinnen und Entwickler in .NET SDK, C# 15.0 und mehr. Bis zur Veröffentlichung des Programms sind vergünstigte Blind-Bird-Tickets verfügbar.

Folgender Code nutzt Where() und OrderBy() mit IAsyncEnumerable:


namespace NET10_Console.FCL;

using System.Collections.Generic;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;

public readonly record struct Kabinettsmitglied(string Name, string Amt);

/// 
/// LINQ auf IAsyncEnumerable erforderte bisher NuGet-Paket System.Linq.Async
/// 
public class FCL10_LINQAsyncEnumerable
{
 public async Task Run()
 {
  CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));

  // Hole Personen im Bundeskabinett
  var datenquelle = new Bundeskabinett().GetAll();

  // Asynchrone Iteration mit LINQ (Filtern und optional Sortieren)
  // Achtung: .OrderBy(x=>x.Name) führt dazu, dass foreach auf das letzte Element warten muss --> Vorteil von async entfällt :-(
  await foreach (var person in datenquelle.Where(x => x.Amt.Contains("ministerin")))
  {
   Console.WriteLine(DateTime.Now.ToLongTimeString() + ": " + person);
  }
 }

 public class Bundeskabinett
 {
  /// 
  /// Liefert alle Mitglieder des Bundeskabinetts (Stand: 21.09.2025) als Async-Stream.
  /// Quelle: Bundesregierung.de (siehe Code-Kommentar).
  /// 
  public async IAsyncEnumerable GetAll(
      [EnumeratorCancellation] CancellationToken cancellationToken = default)
  {
   // Quelle: 
   var daten = new List
        {
            new("Friedrich Merz", "Bundeskanzler"),
            new("Lars Klingbeil", "Bundesminister der Finanzen"),
            new("Alexander Dobrindt", "Bundesminister des Innern"),
            new("Dr. Johann Wadephul", "Bundesminister des Auswärtigen"),
            new("Boris Pistorius", "Bundesminister der Verteidigung"),
            new("Katherina Reiche", "Bundesministerin für Wirtschaft und Energie"),
            new("Dorothee Bär", "Bundesministerin für Forschung, Technologie und Raumfahrt"),
            new("Dr. Stefanie Hubig", "Bundesministerin der Justiz und für Verbraucherschutz"),
            new("Karin Prien", "Bundesministerin für Bildung, Familie, Senioren, Frauen und Jugend"),
            new("Bärbel Bas", "Bundesministerin für Arbeit und Soziales"),
            new("Dr. Karsten Wildberger", "Bundesminister für Digitales und Staatsmodernisierung"),
            new("Patrick Schnieder", "Bundesminister für Verkehr"),
            new("Carsten Schneider", "Bundesminister für Umwelt, Klimaschutz, Naturschutz und nukleare Sicherheit"),
            new("Nina Warken", "Bundesministerin für Gesundheit"),
            new("Alois Rainer", "Bundesminister für Landwirtschaft, Ernährung und Heimat"),
            new("Reem Alabali Radovan", "Bundesministerin für wirtschaftliche Zusammenarbeit und Entwicklung"),
            new("Verena Hubertz", "Bundesministerin für Wohnen, Stadtentwicklung und Bauwesen"),
            new("Thorsten Frei", "Bundesminister für besondere Aufgaben / Chef des Bundeskanzleramtes"),
        };

   foreach (var m in daten)
   {
    cancellationToken.ThrowIfCancellationRequested();
    yield return m;
    await Task.Delay(200); // Simuliere etwas Wartezeit
    await Task.Yield(); // sorgt für echte Asynchronität beim Streamen
   }
  }
 }
}



Screenshot

Screenshot

Der Screenshot zeigt die Ausgabe ohne Sortierung zu verschiedenen Zeitpunkten – direkt nach dem Eintreffen der Daten (Abb. 1).


Screenshot

Screenshot

Der Screenshot zeigt die Ausgabe mit Sortierung zu verschiedenen Zeitpunkten – es gab eine Wartezeit vor der ersten Ausgabe (Abb. 2).

Ein Praxisbeispiel dazu: Folgender Code zeigt die Ausführung einer Reihe von HTTP-Aufrufen mit asynchroner Ausgabe der Ergebnisse via Task.WhenEach(). Hier ist nun ein Filtern mit Where() oder eine Sortierung mit OrderBy() möglich. Diese blockiert jedoch – wie üblich – die Weiterverarbeitung, bis das letzte Ergebnis vorliegt, und beeinträchtigt damit den Vorteil der asynchronen Ausführung.

Weiterlesen nach der Anzeige


public async Task Run()
{
 CUI.Demo(nameof(FCL10_LINQAsyncEnumerable));
 Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: Starte Websiteabfragen...");
 using HttpClient http = new();
 Task t1 = http.GetAsync("
 Task t2 = http.GetAsync("
 Task t3 = http.GetAsync("
 Task t4 = http.GetAsync("
 Task t5 = http.GetAsync("
 Task t6 = http.GetAsync("
 Task t7 = http.GetAsync("
 // Liste aus Tasks
 List> taskList = new() { t1, t2, t3, t4, t5, t6, t7 };
 // WhenEach() gibt es seit .NET 9.0
 IAsyncEnumerable> taskList2 = Task.WhenEach(taskList);
 
 // NEU in .NET 10.0: LINQ auf IAsyncEnumerable
 taskList2 = taskList2.Where(x => x.Result.RequestMessage.RequestUri.ToString().Contains("dot"));
 taskList2 = taskList2.OrderBy(x => x.Result.RequestMessage.RequestUri.Host);

 await foreach (Task t in taskList2)
 {
  try
  {
   Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: {t.Status} {t.Result?.RequestMessage?.RequestUri} = {t?.Result?.StatusCode}"); // Status des HTTP-Aufrufs
  }
  catch (Exception ex)
  {
   CUI.Warning(ex);
  }
 }
}



(rme)



Source link

Weiterlesen

Beliebt