ImageSharp para C# (.NET): guia completo com exemplos práticos

1. O que é e para que serve?

ImageSharp é uma biblioteca poderosa, totalmente gerenciada e multiplataforma para processamento de imagens, escrita em C# para o ecossistema .NET. Ela faz parte da família de bibliotecas SixLabors e oferece aos desenvolvedores uma API limpa, segura e de alto desempenho para trabalhar com imagens, sem a necessidade de dependências nativas externas (como ImageMagick, SkiaSharp ou GDI+). Isso significa que o ImageSharp funciona perfeitamente no Windows, Linux e macOS, tornando-se a escolha ideal para aplicações web (ASP.NET Core), microsserviços, utilitários de console e aplicativos móveis (via Xamarin/MAUI).

Para que serve o ImageSharp? No desenvolvimento moderno, o processamento de imagens é necessário em diversas situações: desde a criação de miniaturas para galerias e redimensionamento de avatares de usuários até a aplicação de marcas d'água, filtros e conversão de formatos. O ImageSharp oferece tudo isso "pronto para uso", com foco em desempenho e segurança. Ao contrário do obsoleto System.Drawing, que é vinculado ao Windows e tem problemas com threads, o ImageSharp é thread-safe e totalmente multiplataforma. Além disso, é ativamente mantido pela comunidade e possui documentação detalhada.

Os principais recursos da biblioteca incluem: carregar e salvar imagens nos formatos mais populares (JPEG, PNG, BMP, GIF, WebP, TIFF), redimensionar, recortar, girar, espelhar, sobrepor texto e formas, aplicar matrizes de cores, filtros (desfoque, nitidez, sépia, preto e branco), trabalhar com dados EXIF, animações GIF e muito mais. O ImageSharp é construído sobre o conceito de Image como um contêiner para dados de pixel e oferece uma API flexível por meio de métodos de extensão.

2. Instalação

A instalação do ImageSharp em um projeto .NET é feita através do gerenciador de pacotes NuGet. Execute um dos seguintes comandos no terminal ou no console do gerenciador de pacotes:

// Via .NET CLI (recomendado)
dotnet add package SixLabors.ImageSharp

// Via Package Manager Console
Install-Package SixLabors.ImageSharp

// Via NuGet Package Manager no Visual Studio/Rider
// Procure por "SixLabors.ImageSharp" e instale a versão estável mais recente

Após a instalação, adicione a diretiva using no início do seu arquivo:

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

3. Métodos principais com exemplos

Abaixo estão os métodos mais utilizados do ImageSharp, organizados por categoria, com exemplos práticos de código em C#.

3.1. Carregar e salvar imagens

// Carregar uma imagem
using (Image image = Image.Load("foto.jpg"))
{
    // Processar a imagem...
    
    // Salvar como PNG
    image.Save("foto_processada.png");
    
    // Salvar como JPEG com qualidade 80
    var encoder = new JpegEncoder { Quality = 80 };
    image.Save("foto_qualidade.jpg", encoder);
}

3.2. Redimensionar (Resize)

using (Image image = Image.Load("foto.jpg"))
{
    // Redimensionar para 300x200 (ignora proporção)
    image.Mutate(x => x.Resize(300, 200));
    
    // Redimensionar mantendo a proporção (largura máxima 400)
    image.Mutate(x => x.Resize(new ResizeOptions
    {
        Size = new Size(400, 0), // Altura é calculada automaticamente
        Mode = ResizeMode.Max
    }));
    
    image.Save("foto_redimensionada.jpg");
}

3.3. Recortar (Crop)

using (Image image = Image.Load("foto.jpg"))
{
    // Recortar um retângulo (x, y, largura, altura)
    Rectangle rect = new Rectangle(50, 30, 200, 150);
    image.Mutate(x => x.Crop(rect));
    
    image.Save("foto_recortada.jpg");
}

3.4. Girar e espelhar (Rotate e Flip)

using (Image image = Image.Load("foto.jpg"))
{
    // Girar 90 graus no sentido horário
    image.Mutate(x => x.Rotate(90));
    
    // Espelhar horizontalmente (efeito espelho)
    image.Mutate(x => x.Flip(FlipMode.Horizontal));
    
    image.Save("foto_transformada.jpg");
}

3.5. Aplicar filtros (Filters)

using (Image image = Image.Load("foto.jpg"))
{
    // Converter para preto e branco
    image.Mutate(x => x.Grayscale());
    
    // Aplicar filtro sépia
    image.Mutate(x => x.Sepia());
    
    // Aplicar desfoque gaussiano (intensidade 5)
    image.Mutate(x => x.GaussianBlur(5));
    
    // Aumentar nitidez
    image.Mutate(x => x.GaussianSharpen(3));
    
    image.Save("foto_filtrada.jpg");
}

3.6. Sobrepor texto (Text)

using (Image image = Image.Load("foto.jpg"))
{
    // Configurar fonte e cor
    Font font = SystemFonts.CreateFont("Arial", 24, FontStyle.Bold);
    Color textColor = Color.White;
    PointF position = new PointF(10, 10);
    
    // Desenhar texto
    image.Mutate(x => x.DrawText("Minha Marca d'Água", font, textColor, position));
    
    image.Save("foto_com_texto.jpg");
}

3.7. Trabalhar com pixels (Pixel Access)

using (Image image = Image.Load("foto.jpg"))
{
    // Acessar e modificar pixels
    for (int y = 0; y < image.Height; y++)
    {
        for (int x = 0; x < image.Width; x++)
        {
            Rgba32 pixel = image[x, y];
            // Inverter cores (negativo)
            pixel.R = (byte)(255 - pixel.R);
            pixel.G = (byte)(255 - pixel.G);
            pixel.B = (byte)(255 - pixel.B);
            image[x, y] = pixel;
        }
    }
    
    image.Save("foto_negativo.jpg");
}

4. Exemplo completo: redimensionar e aplicar marca d'água

Este exemplo combina redimensionamento e sobreposição de texto para criar uma imagem pronta para web:

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Processing;
using SixLabors.Fonts;

string caminhoOriginal = "foto_original.jpg";
string caminhoSaida = "foto_final.jpg";

using (Image image = Image.Load(caminhoOriginal))
{
    // Redimensionar para largura máxima de 800px mantendo proporção
    image.Mutate(x => x.Resize(new ResizeOptions
    {
        Size = new Size(800, 0),
        Mode = ResizeMode.Max
    }));
    
    // Adicionar marca d'água no canto inferior direito
    string textoMarca = "© 2025 Meu Site";
    Font fonte = SystemFonts.CreateFont("Arial", 20, FontStyle.Bold);
    Color corTexto = Color.FromRgba(255, 255, 255, 128); // Branco com 50% de opacidade
    
    // Calcular posição (10px de margem)
    float x = image.Width - 250;
    float y = image.Height - 40;
    PointF posicao = new PointF(x, y);
    
    image.Mutate(ctx => ctx.DrawText(textoMarca, fonte, corTexto, posicao));
    
    // Salvar como JPEG com qualidade 85
    image.SaveAsJpeg(caminhoSaida, new JpegEncoder { Quality = 85 });
}

Console.WriteLine($"Imagem processada salva em: {caminhoSaida}");

5. Dicas de desempenho e boas práticas

• Use using: Sempre envolva objetos Image em blocos using para liberar recursos corretamente.
• Processamento em lote: Para várias imagens, use paralelismo com cuidado (ex: Parallel.ForEach) para melhorar o desempenho.
• Evite redimensionamentos desnecessários: Redimensione apenas quando necessário para economizar memória.
• Escolha o formato certo: JPEG para fotos (com qualidade ajustável), PNG para imagens com transparência, WebP para melhor compressão.
• Libere memória: Em aplicações web, descarte imagens após o uso para evitar vazamentos de memória.

6. Conclusão

O ImageSharp é uma biblioteca essencial para qualquer desenvolvedor .NET que precise processar imagens de forma eficiente, segura e multiplataforma. Com uma API intuitiva e suporte a diversos formatos e operações, ela substitui com vantagens o antigo System.Drawing e outras soluções dependentes de plataforma.

Seja para redimensionar fotos de perfil, gerar miniaturas, aplicar filtros ou criar composições complexas, o ImageSharp oferece todas as ferramentas necessárias. Comece a usar hoje mesmo e simplifique o processamento de imagens nos seus projetos C#!