100M Punkte in WinForms plotten

Wie stellt man 100.000.000 Datenpunkte in einem WinForms-Liniendiagramm dar? Die Antwort hängt vollständig davon ab, welche Charting-Bibliothek Sie wählen — und von einem Detail, das fast jeder Vergleich falsch herum darstellt: Auf der richtigen Engine ist WinForms nicht langsamer als WPF. Es ist schneller.

Dieser Beitrag liefert vollständigen, lauffähigen C#-Code zum Rendern von 100 Millionen Punkten in den WinForms-Charting-Bibliotheken, die Entwickler tatsächlich evaluieren — ProEssentials, LightningChart, DevExpress, Syncfusion, ComponentOne und ScottPlot. Er zeigt, was bei jedem Schritt mit Ihren Daten geschieht, und warum dieselbe ProEssentials-Engine unter WinForms rund 5 % schneller rendert als unter WPF.

Wenn Sie nach „plot millions of points WinForms", „fastest WinForms chart" oder „WinForms chart 100 million points" gesucht haben, ist dies die konkrete Antwort auf Code-Ebene — mit einem Clone-and-Run-GitHub-Repo, damit Sie jede Zahl selbst reproduzieren können.

Probieren Sie es selbst aus: Die WinForms-100M-Punkt-Demo ist ein öffentliches Repo — klonen, F5 drücken und 100 Millionen Punkte auf dem hDC rendern sehen. Kein Konto, keine Trial-Registrierung, keine gerasterten Ersatzdaten.

Building on WinUI 3? See the WinUI edition of this 100M-point comparison

Warum WinForms WPF auf derselben Engine schlägt

Vor dem Code der architektonische Punkt, der alles neu rahmt. Ein GPU-Chart unter WPF kann Direct3D nicht direkt auf den Bildschirm zeichnen — der WPF-Compositor besitzt die Pixel, sodass die Bibliothek in eine Off-Screen-Textur rendern, sie über D3DImage an WPF übergeben und vom Compositor einblenden lassen muss. Jeder Frame zahlt für eine Texturkopie und eine Compositor-Synchronisation.

Ein natives WinForms-Control besitzt ein echtes Win32-Fensterhandle und einen Gerätekontext (hDC). ProEssentials koppelt Direct3D direkt an diesen hDC — der vom Compute Shader konstruierte Frame wird direkt an das Fenster ausgegeben, ohne Render-to-Texture und ohne zweites Compositing. Über repräsentative Datensätze hinweg macht das den nativen WinForms-Pfad end-to-end rund 5 % schneller als dieselbe Engine, die ein WPF-Control antreibt.

Der Test: 100.000.000 Float-Werte

Jede Bibliothek erhält denselben Test: ein einreihiges Liniendiagramm aus 100 Millionen sequenziellen Float-Werten auf einem nativen WinForms-Formular rendern. Wir messen den Speicher-Overhead über das Quell-Array hinaus, die Renderzeit und ob die Bibliothek jeden Punkt zeigt oder eine heruntergesampelte Näherung.

Im Folgenden zeigen wir den vollständigen C#-Code für jede Bibliothek, kommentiert mit dem, was bei jedem Schritt mit Ihren Daten geschieht. Achten Sie vor allem auf eines: ob die 100M Werte kopiert, konvertiert oder in Objekte verpackt werden — und ob der Chart direkt an das Fenster ausgegeben wird oder über eine Interop-Schicht läuft.

Bibliothek 1: ProEssentials — Zero-Copy + GPU Compute Shader, hDC-gekoppelt

ProEssentials verwendet UseDataAtLocation(), um den WinForms-Chart direkt auf Ihr bestehendes Float-Array zu verweisen. Keine Kopie, keine Konvertierung, kein Objekt-Wrapping. Der Direct3D Compute Shader konstruiert alle 100M Vertices auf der GPU und gibt den Frame direkt an den hDC des Controls aus.

// ProEssentials — Plot 100 Million Points (WinForms, ~15 lines)
// NuGet: Install-Package ProEssentials.Chart.Net.Winforms

// 1. Allocate your data — this is the ONLY copy that will ever exist
float[] yData = new float[100_000_000];
for (int i = 0; i < yData.Length; i++)
    yData[i] = (float)Math.Sin(i * 0.0001) + (float)(rand.NextDouble() * 0.1);

// 2. Configure the WinForms chart control (PesgoWin)
pesgo1.PeData.Subsets = 1;
pesgo1.PeData.Points = 100_000_000;
pesgo1.PePlot.Method = SGraphPlottingMethod.Line;
pesgo1.PeConfigure.RenderEngine = RenderEngine.Direct3D;
pesgo1.PeData.ComputeShader = true;
pesgo1.PeData.Filter2D3D = true;  // GPU pre-filter shader — lossless min/max

// 3. Zero-copy: point the chart at your existing array — no duplication
pesgo1.PeData.Y.UseDataAtLocation(yData, yData.Length);

// 4. Tell the Direct3D engine to rebuild vertices and colors
pesgo1.PeFunction.Force3dxVerticeRebuild = true;
pesgo1.PeFunction.Force3dxNewColors = true;

// 5. Render — presented DIRECTLY to the WinForms window hDC
//    (no render-to-texture, no WPF compositor hop)
pesgo1.PeFunction.ReinitializeResetImage();

Die Schlüsselzeile ist UseDataAtLocation(yData, yData.Length). Dies ist keine Kopieroperation — es ist eine Zeigerzuweisung. Die 400 MB, die Ihre Daten bereits belegen, sind die einzige Kopie, die je existieren wird; der Chart fügt praktisch null Overhead hinzu.

Die Flags Force3dxVerticeRebuild und Force3dxNewColors weisen die Direct3D-Engine an, Vertices und Farben auf der GPU neu aufzubauen. Mit ComputeShader = true und Filter2D3D = true berechnet ein GPU-Vorfilter verlustfreie Min/Max-Werte pro Pixelspalte, sodass keine Spitze verloren geht — und das Ergebnis wird ohne WPFs Compositor-Schritt an den hDC ausgegeben.

Bibliothek 2: SciChart — Kein natives WinForms-Control

SciChart wird häufig als das schnellste WPF-Chart genannt, aber unter WinForms gibt es einen Haken, den kein Code-Beispiel umgehen kann: SciChart hat kein natives WinForms-Control. Die eigene Dokumentation gibt an, dass WinForms nur durch Integration mit WPF unterstützt wird — indem das WPF-SciChartSurface in einem Microsoft-ElementHost gehostet wird.

// SciChart — Plot 100 Million Points (WinForms)
// NOTE: SciChart has NO native WinForms control.
// WinForms is supported only by hosting the WPF control in an ElementHost.

// 1. Host the WPF SciChartSurface inside a WinForms ElementHost
var host = new System.Windows.Forms.Integration.ElementHost();
host.Dock = DockStyle.Fill;
var sciChartSurface = new SciChart.Charting.Visuals.SciChartSurface();
host.Child = sciChartSurface;       // WPF control living inside WinForms
this.Controls.Add(host);

// 2. From here the code is identical to the WPF path — and inherits
//    WPF's render-to-texture compositor cost plus ElementHost interop
//    limitations (mouse events, focus, z-order / "airspace").
var dataSeries = new XyDataSeries<double, double>();  // double[], not float[]
dataSeries.Append(xData, yData);    // full internal copy
var lineSeries = new FastLineRenderableSeries {
    DataSeries = dataSeries,
    ResamplingMode = ResamplingMode.Auto   // downsamples to ~viewport width
};
sciChartSurface.RenderableSeries.Add(lineSeries);

// There is no native WinForms SciChart control to target.

Das bedeutet, dass eine SciChart-WinForms-App den Render-to-Texture-Compositor-Pfad von WPF erbt, plus die dokumentierten ElementHost-Interop-Einschränkungen rund um Mausereignisse, Fokus und Z-Reihenfolge. Der 100M-Punkt-Code ist im Wesentlichen der WPF-Code, eingewickelt — und er trägt die Compositor-Kosten, die natives WinForms vermeidet.

Für eine echte native WinForms-Anwendung gibt es keinen erstklassigen SciChart-Pfad. Der Performance-Spitzenname der Kategorie stellt keinen nativen WinForms-Eintrag, weshalb er hier als Interop statt als Code-Beispiel gezeigt wird.

Bibliothek 3: LightningChart — Nativ, DirectX, spezialisierte Series

LightningChart ist der stärkste echte native WinForms-Rivale. Es rendert 100 Millionen Punkte über seine DirectX-Pipeline mit einer spezialisierten Sample-Series und kopiert Ihr float[] über einen AddSamples-artigen Aufruf in seinen internen Speicher.

// LightningChart — Plot 100 Million Points (WinForms)
// NuGet: Install-Package LightningChart.NET (native WinForms control)

// 1. Allocate your data
float[] yData = new float[100_000_000];
for (int i = 0; i < yData.Length; i++)
    yData[i] = (float)Math.Sin(i * 0.0001) + (float)(rand.NextDouble() * 0.1);

// 2. Configure the native WinForms chart for large data
lightningChart.BeginUpdate();
lightningChart.ViewXY.XAxes[0].SetRange(0, 100_000_000);

// 3. SampleDataSeries (fixed-interval) — copies float[] into internal buffer
var series = new SampleDataSeries(lightningChart.ViewXY,
    lightningChart.ViewXY.XAxes[0], lightningChart.ViewXY.YAxes[0]);
series.FirstSampleTimeStamp = 0;
series.SamplingFrequency = 1;

// 4. Add all 100M samples — array copy (not zero-copy)
series.AddSamples(yData, false);

// 5. Add series; continuous DirectX render loop keeps the GPU active
lightningChart.ViewXY.SampleDataSeries.Add(series);
lightningChart.EndUpdate();

Es rendert alle 100M Punkte verlustfrei (mit dem korrekten Serientyp), was eine echte Stärke ist. Die Kompromisse entsprechen dem breiteren Vergleich: Eine kontinuierliche DirectX-Render-Schleife hält die GPU aktiv, selbst wenn sich nichts ändert, und der Datenpfad kopiert Ihr Array, statt es zu referenzieren.

LightningChart ist der nächstgelegene native WinForms-Konkurrent bei der reinen Leistungsfähigkeit. Die Unterschiede laufen auf die Array-Kopie, den Stromverbrauch durch die kontinuierliche Schleife und Aktivierung/Lizenzierung hinaus — nicht darauf, ob es die Punkte rendern kann.

Bibliothek 4: DevExpress — SwiftPlot (nur WinForms) + Objekt-pro-Punkt

DevExpress ist die interessante Umkehrung: Seine schnelle Großdaten-View, SwiftPlotSeriesView, ist nur WinForms — sie existiert im WPF-ChartControl nicht. WinForms ist also tatsächlich die stärkere Oberfläche von DevExpress für große Datenmengen.

// DevExpress — Plot 100 Million Points (WinForms)
// NuGet: DevExpress.Win.Charts
// NOTE: SwiftPlotSeriesView is WinForms-ONLY — it does not exist in WPF.

// 1. Create data model — DevExpress uses object-per-point
public class DataPoint {
    public double Argument { get; set; }
    public double Value { get; set; }
}

// 2. Allocate the objects (object-per-point is the binding constraint)
var data = new List<DataPoint>(100_000_000);
for (int i = 0; i < 100_000_000; i++)
    data.Add(new DataPoint {
        Argument = i,
        Value = Math.Sin(i * 0.0001) + rand.NextDouble() * 0.1
    });
// ⚠ Billions of bytes of DataPoint objects before rendering starts.
//   DevExpress markets 20M+ "without preprocessing" — short of 100M.

// 3. SwiftPlotDiagram + SwiftPlotSeriesView (the WinForms fast path)
var series = new Series("Signal", ViewType.SwiftPlot);
series.DataSource = data;
series.ArgumentDataMember = "Argument";
series.ValueDataMembers.AddRange("Value");
chartControl.Series.Add(series);
((SwiftPlotDiagram)chartControl.Diagram).EnableAxisXScrolling = true;

SwiftPlot verwendet einen erleichterten Generierungsalgorithmus und ein Objekt-pro-Punkt-Datenmodell. Bei 100 Millionen Punkten müssen Sie enorme Mengen an SeriesPoint-Objekten allokieren, bevor das Rendering beginnt; in der Praxis ist dies die bindende Einschränkung, lange bevor es der Renderer ist. DevExpress bewirbt 20M+ Punkte ohne Vorverarbeitung — deutlich unter 100M.

Bibliothek 5: Syncfusion — Kein WinForms-Fast-Pfad

Syncfusions Aushängeschild „Fast Series" (FastLineSeries, FastLineBitmapSeries) existiert nur unter WPF, WinUI und UWP. Unter WinForms gibt es überhaupt keinen Fast-Series-Pfad — Syncfusions eigenes Support-Team erfasste die Feature-Anfrage und erklärte, es gebe keinen unmittelbaren Plan zur Umsetzung.

Das lässt Standard-GDI+-Rendering ohne GPU-Beschleunigung für WinForms übrig. Bei 100 Millionen Punkten ist dies kein praktikables Szenario; Syncfusion WinForms ist eine starke Wahl für Business-Dashboards unter ~100K Punkten, nicht für großmaßstäbliche wissenschaftliche Erfassung.

Bibliothek 6: ScottPlot — Kostenlos, CPU, Dezimierung

ScottPlot ist die dominierende kostenlose/Open-Source-WinForms-Option. Es rendert über System.Drawing, dann SkiaSharp auf der CPU und verlässt sich auf Datendezimierung — die Reduktion Ihres Datensatzes auf eine repräsentative Teilmenge sichtbarer Punkte —, um reaktionsfähig zu bleiben.

// ScottPlot — Plot 100 Million Points (WinForms, free / open-source)
// NuGet: Install-Package ScottPlot.WinForms

// 1. Allocate your data
double[] yData = new double[100_000_000];
for (int i = 0; i < yData.Length; i++)
    yData[i] = Math.Sin(i * 0.0001) + rand.NextDouble() * 0.1;

// 2. SignalPlot is the large-data path (assumes even X spacing)
formsPlot1.Plot.Add.Signal(yData);

// 3. ScottPlot renders on the CPU (System.Drawing -> SkiaSharp) and
//    relies on DECIMATION — it draws a representative subset, not all
//    100M points. Init for 10M+ runs 100+ ms; the displayed line is
//    not lossless.
formsPlot1.Refresh();

Für 10M+ Punkte läuft die Initialisierung 100+ ms, und das angezeigte Ergebnis ist dezimiert, nicht verlustfrei. ScottPlots Maintainer merkt an, dass das Managed-zu-Native-Marshalling von Punkt-Arrays die grundlegende Obergrenze ist. Hervorragendes Preis-Leistungs-Verhältnis für moderate Datenmengen; keine verlustfreie 100M-Engine.

Was Resampling und Dezimierung kosten

Telerik, ScottPlot und die erleichterte View von DevExpress reduzieren alle Daten in irgendeiner Form — sie zeigen eine repräsentative Teilmenge statt jedes Punktes —, um im großen Maßstab reaktionsfähig zu bleiben. Für Trendüberblicke ist das oft visuell in Ordnung.

Aber ein dezimierter Chart kann ein einzelnes Ereignis verbergen: eine EKG-Arrhythmie, eine Vibrationsresonanzspitze, einen Mikrosekunden-Halbleiterausschlag. Wenn die Teilmenge dieses Sample zufällig nicht enthält, sehen Sie es nie. Millionen von Punkten zu „bewältigen", indem man sie mittelt, bedeutet, eine Zusammenfassung Ihrer Daten zu rendern, nicht Ihre Daten.

ProEssentials verfolgt mit seinem Filter2D3D GPU Compute Shader einen anderen Ansatz. Statt Punkte zu verwerfen, berechnet es das korrekte Min/Max pro Pixelspalte über alle 100M Werte, sodass jede Spitze erhalten bleibt — verlustfrei, auf dem hDC.

Was es kostet, 100 Millionen Punkte unter WinForms zu plotten

Von den nativen WinForms-Optionen rendern nur ProEssentials und LightningChart realistisch 100M verlustfrei; DevExpress endet mit Objekt-pro-Punkt niedriger, SciChart hat kein natives Control, Syncfusion hat keinen Fast-Pfad, und ScottPlot dezimiert. Hier die praktische Zusammenfassung:

ProEssentials ist die einzige WinForms-Bibliothek, die Zero-Copy-Datenladen, verlustfreie GPU-Compute-Shader-Filterung, On-Demand-Rendering und direkte hDC-Ausgabe vereint — und das ~5 % schneller als dieselbe Engine unter WPF, mit einem öffentlichen Clone-and-Run-Repo als Beweis.

Das Fazit

Mehrere Bibliotheken können 100 Millionen Punkte in WinForms versuchen, aber die Landschaft ist enger als die von WPF. Nur ProEssentials schafft es mit null Speicher-Overhead, verlustfreier Treue und direkter hDC-Ausgabe — und schneller als sein eigener WPF-Build.

SciChart hat kein natives WinForms-Control. Syncfusion hat keinen WinForms-Fast-Pfad. ScottPlot dezimiert. DevExpress' SwiftPlot ist nur WinForms, aber Objekt-pro-Punkt. LightningChart ist der echte native Anwärter, mit Array-Kopie- und Kontinuierliche-Schleife-Kompromissen.

Wenn Ihre WinForms-Anwendung 100 Millionen Punkte darstellen muss — Sensordaten, Signalverarbeitung, wissenschaftliche Erfassung, LiDAR —, ist der hDC-gekoppelte Compute-Shader-Pfad die schnellste verlustfreie Option, die verfügbar ist, und die einzige, die Sie heute klonen und reproduzieren können.

WinForms-Performance im Detail

Die vollständige hDC-Kopplungs-Story, der 8-Bibliotheken-WinForms-Vergleich und reproduzierbare Repos.

KI-Code-Unterstützung

pe_query.py validiert jeden Eigenschaftspfad gegen die kompilierte DLL-Binärdatei — keine halluzinierten API-Aufrufe.

Preis- & Support-Vergleich

5-Jahres-TCO über die wichtigsten Bibliotheken. Unbefristete vs. Abo-Lizenzierung, kostenloser unbegrenzter Support.

Quellen & Referenzen

Alle Mitbewerber-Code-Beispiele und -Aussagen in diesem Beitrag wurden aus offizieller Dokumentation, öffentlichen GitHub-Repositories und Support-Aussagen der Anbieter zusammengestellt. Überprüfen Sie sie direkt: