ImageSharp für C# (.NET): Komplettguide mit Beispielen

1. Was ist ImageSharp und warum brauchst du es?

ImageSharp ist eine leistungsstarke, vollständig verwaltete, plattformübergreifende Bibliothek zur Bildverarbeitung, die in C# für das .NET-Ökosystem geschrieben wurde. Sie gehört zur SixLabors-Familie und bietet Entwicklern eine saubere, sichere und hochperformante API für die Arbeit mit Bildern – ganz ohne externe native Abhängigkeiten (wie ImageMagick, SkiaSharp oder GDI+). Das bedeutet: ImageSharp läuft unter Windows, Linux und macOS gleichermaßen zuverlässig und ist damit die ideale Wahl für Webanwendungen (ASP.NET Core), Microservices, Konsolentools und mobile Apps (via Xamarin/MAUI).

Warum ist ImageSharp so wichtig? In der modernen Softwareentwicklung ist Bildverarbeitung allgegenwärtig: Vom Erstellen von Thumbnails für Galerien und dem Ändern der Größe von Benutzerprofilbildern bis hin zum Hinzufügen von Wasserzeichen, Anwenden von Filtern und Konvertieren von Formaten. ImageSharp liefert all das „out of the box“ mit Fokus auf Performance und Sicherheit. Im Gegensatz zum veralteten System.Drawing, das an Windows gebunden ist und Probleme mit Threading hat, ist ImageSharp threadsicher und vollständig plattformunabhängig. Die Bibliothek wird zudem aktiv von der Community unterstützt und bietet eine umfangreiche Dokumentation.

Zu den wichtigsten Funktionen der Bibliothek gehören: Laden und Speichern von Bildern in gängigen Formaten (JPEG, PNG, BMP, GIF, WebP, TIFF), Größenänderung, Zuschneiden, Drehen, Spiegeln, das Hinzufügen von Text und Formen, die Anwendung von Farbmatrizen, Filtern (Weichzeichnen, Schärfen, Sepia, Schwarz-Weiß), die Arbeit mit EXIF-Daten, GIF-Animationen und vieles mehr. ImageSharp basiert auf dem Konzept von Image als Container für Pixeldaten und bietet eine flexible API über Erweiterungsmethoden.

2. Installation

Die Installation von ImageSharp in dein .NET-Projekt erfolgt über den NuGet-Paketmanager. Führe einen der folgenden Befehle im Terminal oder in der Paketmanager-Konsole aus:

// Über die .NET CLI (empfohlen)
dotnet add package SixLabors.ImageSharp

// Über die Package Manager Console
Install-Package SixLabors.ImageSharp

// Über den NuGet Package Manager in Visual Studio/Rider
// Suche nach "SixLabors.ImageSharp" und installiere die neueste stabile Version

Nach der Installation fügst du die using-Direktive am Anfang deiner Datei hinzu:

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using SixLabors.ImageSharp.Formats.Jpeg;
using SixLabors.ImageSharp.PixelFormats;

3. Grundlegende Methoden mit Codebeispielen

Im Folgenden findest du die wichtigsten Methoden von ImageSharp mit praktischen Codebeispielen. Jede Methode wird in einer übersichtlichen Karte vorgestellt.

using (Image image = Image.Load("input.jpg"))
{
    // Bild verarbeiten (z.B. Größe ändern)
    image.Mutate(x => x.Resize(800, 600));
    
    // Bild speichern
    image.Save("output.jpg");
}

using (Image image = Image.Load("photo.jpg"))
{
    // Auf 300x300 Pixel skalieren
    image.Mutate(x => x.Resize(300, 300));
    image.Save("thumbnail.jpg");
    
    // Mit Beibehaltung des Seitenverhältnisses
    image.Mutate(x => x.Resize(new ResizeOptions
    {
        Size = new Size(300, 300),
        Mode = ResizeMode.Max
    }));
    image.Save("thumbnail_aspect.jpg");
}

using (Image image = Image.Load("landscape.jpg"))
{
    // Rechteckigen Bereich zuschneiden (x, y, Breite, Höhe)
    Rectangle cropArea = new Rectangle(100, 50, 400, 300);
    image.Mutate(x => x.Crop(cropArea));
    image.Save("cropped.jpg");
}

using (Image image = Image.Load("portrait.jpg"))
{
    // Um 90 Grad im Uhrzeigersinn drehen
    image.Mutate(x => x.Rotate(90));
    
    // Horizontal spiegeln
    image.Mutate(x => x.Flip(FlipMode.Horizontal));
    
    image.Save("rotated_flipped.jpg");
}

using (Image image = Image.Load("document.jpg"))
{
    // Schriftart und Farbe definieren
    Font font = SystemFonts.CreateFont("Arial", 24);
    Color textColor = Color.White;
    
    // Text in der Mitte platzieren
    PointF textPosition = new PointF(50, 50);
    image.Mutate(x => x.DrawText("© 2025 Mein Unternehmen", font, textColor, textPosition));
    
    image.Save("watermarked.jpg");
}

using (Image image = Image.Load("sunset.jpg"))
{
    // Helligkeit erhöhen
    image.Mutate(x => x.Brightness(1.2f));
    
    // Kontrast verstärken
    image.Mutate(x => x.Contrast(1.5f));
    
    // Sepia-Effekt anwenden
    image.Mutate(x => x.Sepia());
    
    image.Save("filtered.jpg");
}

using (Image image = Image.Load("image.png"))
{
    // Als JPEG mit Qualität 80 speichern
    image.Save("output.jpg", new JpegEncoder { Quality = 80 });
    
    // Als WebP speichern (falls installiert)
    image.Save("output.webp", new WebpEncoder());
}

4. Fortgeschrittene Techniken

Neben den grundlegenden Methoden bietet ImageSharp auch fortgeschrittene Funktionen für komplexe Bildverarbeitungsaufgaben.

byte[] imageBytes = File.ReadAllBytes("input.jpg");
using (MemoryStream ms = new MemoryStream(imageBytes))
using (Image image = Image.Load(ms))
{
    image.Mutate(x => x.Resize(200, 200));
    
    using (MemoryStream outputMs = new MemoryStream())
    {
        image.Save(outputMs, new JpegEncoder());
        byte[] resultBytes = outputMs.ToArray();
        // resultBytes an Client senden oder weiterverarbeiten
    }
}

using (Image image = Image.Load("photo.jpg"))
{
    // EXIF-Daten auslesen
    if (image.Metadata.ExifProfile != null)
    {
        foreach (var item in image.Metadata.ExifProfile.Values)
        {
            Console.WriteLine($"{item.Tag}: {item.GetValue()}");
        }
    }
    
    // EXIF-Daten entfernen (für Datenschutz)
    image.Metadata.ExifProfile = null;
    image.Save("clean.jpg");
}

using (Image gif = Image.Load("animation.gif"))
{
    // Alle Frames durchgehen und Größe ändern
    foreach (var frame in gif.Frames)
    {
        frame.Mutate(x => x.Resize(100, 100));
    }
    
    gif.Save("resized_animation.gif");
}

5. Best Practices und Performance-Tipps

Um das Beste aus ImageSharp herauszuholen, beachte diese Tipps:

• Immer using verwenden: ImageSharp implementiert IDisposable. Verwende immer using-Blöcke, um Speicherlecks zu vermeiden.
• Bilder parallel verarbeiten: Nutze Parallel.ForEach oder Task-basierte Ansätze, um mehrere Bilder gleichzeitig zu verarbeiten. ImageSharp ist threadsicher.
• Encoder-Konfiguration optimieren: Passe die Qualität von JPEG (JpegEncoder.Quality) an, um Dateigröße und Bildqualität auszubalancieren.
• Vor dem Speichern skalieren: Verkleinere Bilder auf die benötigte Größe, bevor du sie speicherst. Das spart Speicherplatz und Ladezeit.
• Streams bevorzugen: Verwende MemoryStream oder FileStream anstelle von temporären Dateien, wenn möglich.
• NuGet-Pakete aktuell halten: ImageSharp wird regelmäßig aktualisiert. Updates bringen oft Performance-Verbesserungen und neue Funktionen.

6. Fazit

ImageSharp ist eine der besten Bibliotheken für die Bildverarbeitung in C# und .NET. Sie ist modern, plattformunabhängig, sicher und extrem leistungsfähig. Egal, ob du eine kleine Konsolenanwendung oder eine große Web-API entwickelst – ImageSharp bietet dir alle Werkzeuge, die du brauchst, um Bilder effizient zu verarbeiten.

Mit den in diesem Guide gezeigten Methoden und Beispielen kannst du sofort loslegen. Probiere es selbst aus und integriere ImageSharp in dein nächstes .NET-Projekt!