Como Criar um Conversor de Imagens em C# com ImageSharp

Quando comecei a publicar meus próprios posts, percebi que existe uma parte do processo que parece simples, mas pode consumir bastante tempo: preparar as imagens.

Para cada conteúdo, normalmente preciso pensar no banner, nas imagens utilizadas dentro do artigo e, principalmente, no card que será utilizado para divulgar a publicação.

Como estou começando nesse mercado, estou tentando seguir uma rotina organizada para publicar e divulgar os conteúdos nas redes. E foi justamente nesse processo que comecei a perceber um problema recorrente.

Eu precisava encontrar imagens, gerar ou solicitar imagens para os banners, adaptar os arquivos para os tamanhos necessários e, muitas vezes, reduzir o tamanho dessas imagens antes de colocá-las no site.

No começo, utilizei ferramentas que já estavam disponíveis no computador, como o Paint, além de algumas ferramentas gratuitas encontradas na internet.

O problema é que isso também começou a consumir tempo.

Em alguns serviços online, eu conseguia fazer o processamento gratuitamente, mas quando chegava a hora de baixar o arquivo apareciam exigências de cadastro, solicitação de e-mail ou opções de planos pagos.

Depois de passar por esse processo algumas vezes, pensei:

Será que eu consigo criar uma ferramenta simples em C# para resolver pelo menos uma parte desse problema?

Foi daí que surgiu a ideia deste pequeno projeto.

Não criei uma ferramenta profissional de edição de imagens e nem tentei competir com softwares especializados. A ideia foi muito mais simples: criar uma aplicação de console capaz de pegar imagens de uma pasta, converter o formato, redimensionar quando necessário, comprimir e colocar os arquivos processados em outra pasta.

E o interessante é que esse pequeno projeto também acabou se transformando em um bom exercício de C# e .NET.

A aplicação funciona basicamente com três pastas:

• Origem: onde ficam as imagens que serão processadas;
• Destino: onde serão colocadas as imagens convertidas;
• Processados: onde os arquivos originais serão movidos depois do processamento.

Os caminhos não ficam diretamente espalhados pelo código. Eles são definidos no arquivo appsettings.json e carregados pela aplicação.

Isso permite alterar os diretórios sem precisar modificar o código-fonte.

A estrutura que utilizei é relativamente pequena:

• Program.cs — entrada da aplicação e interação com o usuário;
• Modelos.cs — modelos utilizados para representar as opções e os resultados;
• ConversorServico.cs — responsável pelo processamento das imagens;
• appsettings.json — configuração das pastas utilizadas pelo programa.

Essa separação é interessante porque evita colocar toda a lógica dentro do Main. O programa conversa com o usuário, coleta as informações e depois entrega essas opções para o serviço responsável pelo processamento.

Começando pela configuração, o projeto utiliza um arquivo chamado appsettings.json:

{
  "Caminhos": {
    "PastaOrigem": "C:\\Users\\usuario\\Documents\\ImagensParaTratar\\origem",
    "PastaDestino": "C:\\Users\\usuario\\Documents\\ImagensParaTratar\\destino",
    "PastaProcessados": "C:\\Users\\usuario\\Documents\\ImagensParaTratar\\Processados"
  }
}

No meu arquivo original, esses caminhos apontam para as pastas que utilizo no meu computador. Aqui no artigo coloquei caminhos genéricos para que você possa adaptar ao seu ambiente.

A ideia é simples: qualquer imagem colocada na pasta de origem poderá ser processada pela aplicação.

Essa é uma pequena decisão que pode parecer desnecessária em um projeto tão simples, mas ajuda bastante.

Imagine que amanhã você queira colocar a pasta de origem em outro local. Se o caminho estiver espalhado pelo código, será necessário procurar e alterar os valores.

Com o appsettings.json, basta alterar a configuração.

No Program.cs, a aplicação carrega o arquivo utilizando o sistema de configuração do .NET:

IConfiguration config = new ConfigurationBuilder()
    .SetBasePath(Directory.GetCurrentDirectory())
    .AddJsonFile(
        "appsettings.json",
        optional: false,
        reloadOnChange: true)
    .Build();

Aqui temos algumas coisas acontecendo.

ConfigurationBuilder

O ConfigurationBuilder é utilizado para construir o objeto de configuração que será utilizado pela aplicação.

SetBasePath

O método SetBasePath define o diretório utilizado como referência para localizar o arquivo de configuração.

No projeto, utilizo:

Directory.GetCurrentDirectory()

Assim, o programa procura o appsettings.json a partir do diretório atual da aplicação.

AddJsonFile

Depois informamos qual arquivo será carregado:

.AddJsonFile(
    "appsettings.json",
    optional: false,
    reloadOnChange: true)

O parâmetro optional: false indica que o arquivo é obrigatório para a aplicação.

Depois que a configuração é carregada, podemos buscar os valores das pastas:

OpcoesConversao opcoes = new OpcoesConversao
{
    PastaOrigem =
        config["Caminhos:PastaOrigem"] ?? string.Empty,

    PastaDestino =
        config["Caminhos:PastaDestino"] ?? string.Empty,

    PastaProcessados =
        config["Caminhos:PastaProcessados"] ?? string.Empty
};

Perceba a sintaxe:

Caminhos:PastaOrigem

Ela representa a propriedade PastaOrigem dentro da seção Caminhos do JSON.

Para evitar passar várias informações soltas para o serviço, criei uma classe chamada OpcoesConversao.

Ela fica no arquivo Modelos.cs.

public class OpcoesConversao
{
    public string PastaOrigem { get; set; } = string.Empty;
    public string PastaDestino { get; set; } = string.Empty;
    public string PastaProcessados { get; set; } = string.Empty;

    public FormatoImagem FormatoSaida { get; set; }
        = FormatoImagem.Webp;

    public int? LarguraPx { get; set; }

    public int? AlturaPx { get; set; }

    public bool Comprimir { get; set; }

    public int Qualidade => Comprimir ? 75 : 100;
}

Essa classe representa as configurações necessárias para realizar uma conversão.

PastaOrigem, PastaDestino e PastaProcessados

Essas propriedades informam para onde a aplicação deve olhar e onde deve colocar os arquivos.

public string PastaOrigem { get; set; }

public string PastaDestino { get; set; }

public string PastaProcessados { get; set; }

A terceira propriedade é particularmente interessante porque permite que o programa não simplesmente apague ou deixe o arquivo original misturado com os arquivos que ainda precisam ser processados.

FormatoSaida

O formato de saída é representado por um enum:

public enum FormatoImagem
{
    Jpeg,
    Webp,
    Png
}

Portanto, a versão atual do projeto trabalha com três formatos de saída: JPEG, WebP e PNG.

Largura e altura

As dimensões são representadas por int?:

public int? LarguraPx { get; set; }

public int? AlturaPx { get; set; }

O ponto interessante aqui é o ?.

Isso significa que o valor pode ser nulo.

Na prática, isso permite que o usuário pressione ENTER e mantenha aquela dimensão sem informar um valor.

Essa decisão deixa o programa mais flexível do que simplesmente exigir largura e altura obrigatoriamente.

Compressão e qualidade

Também temos:

public bool Comprimir { get; set; }

public int Qualidade => Comprimir ? 75 : 100;

A propriedade Qualidade é calculada automaticamente.

Quando a compressão está ativada, a qualidade utilizada é 75. Quando não está, o valor é 100. Isso está definido diretamente no modelo utilizado pela aplicação.

É uma solução simples e adequada para o objetivo inicial do projeto. Uma futura versão poderia permitir que o usuário escolhesse manualmente a qualidade.

Outra classe criada no projeto é ResultadoItem:

public class ResultadoItem
{
    public string NomeArquivo { get; set; }
        = string.Empty;

    public bool Sucesso { get; set; }

    public string MensagemErro { get; set; }
        = string.Empty;

    public long TamanhoOriginalBytes { get; set; }

    public long TamanhoFinalBytes { get; set; }
}

Essa classe resolve uma necessidade importante: saber o que aconteceu com cada arquivo.

Além de informar se houve sucesso ou erro, ela guarda os tamanhos original e final do arquivo.

Com isso, o programa consegue mostrar algo como:

[OK] minha-imagem.png | 850.5 KB -> 245.3 KB (71.2% alteração)

Ou, se ocorrer algum problema:

[ERRO] minha-imagem.png: mensagem do erro

Agora chegamos ao ponto de entrada da aplicação.

O método Main começa carregando a configuração:

static void Main(string[] args)
{
    IConfiguration config = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile(
            "appsettings.json",
            optional: false,
            reloadOnChange: true)
        .Build();

Depois disso, as opções iniciais são montadas:

OpcoesConversao opcoes = new OpcoesConversao
{
    PastaOrigem =
        config["Caminhos:PastaOrigem"] ?? string.Empty,

    PastaDestino =
        config["Caminhos:PastaDestino"] ?? string.Empty,

    PastaProcessados =
        config["Caminhos:PastaProcessados"] ?? string.Empty
};

O programa também exibe no console quais diretórios serão utilizados:

Console.WriteLine("=============================================");
Console.WriteLine("   CONVERSOR & COMPRESSOR DE IMAGENS C#     ");
Console.WriteLine("=============================================");

Console.WriteLine("Origem     : " + opcoes.PastaOrigem);
Console.WriteLine("Destino    : " + opcoes.PastaDestino);
Console.WriteLine("Processados: " + opcoes.PastaProcessados);

Isso é útil principalmente durante os testes, porque permite confirmar rapidamente se a aplicação está apontando para as pastas corretas.

Antes de pedir qualquer informação ao usuário, o programa verifica se a pasta de origem realmente existe:

if (!Directory.Exists(opcoes.PastaOrigem))
{
    Console.ForegroundColor = ConsoleColor.Red;

    Console.WriteLine(
        "A pasta de origem informada no appsettings.json não existe!");

    Console.ResetColor();

    Console.ReadKey();

    return;
}

Essa validação evita que o programa chegue à etapa de processamento tentando acessar um diretório inexistente.

Também temos um pequeno cuidado visual: o console muda a cor do texto para vermelho quando apresenta o erro e depois volta ao padrão.

Depois da validação, o programa pergunta ao usuário qual formato deseja utilizar:

Console.Write(
    "Formato de saída (png, webp ou jpeg): ");

string entradaFormato =
    (Console.ReadLine() ?? "")
        .Trim()
        .ToLower();

Depois a entrada é convertida para o enum:

if (entradaFormato == "png")
{
    opcoes.FormatoSaida = FormatoImagem.Png;
}
else if (
    entradaFormato == "jpeg" ||
    entradaFormato == "jpg")
{
    opcoes.FormatoSaida = FormatoImagem.Jpeg;
}
else
{
    opcoes.FormatoSaida = FormatoImagem.Webp;
}

Temos aqui uma decisão simples: se o usuário informar PNG, utilizamos PNG; se informar JPEG ou JPG, utilizamos JPEG; qualquer outra entrada acaba levando ao WebP.

Em uma futura versão, eu provavelmente melhoraria essa validação para avisar quando o usuário informar um formato inválido, em vez de assumir WebP.

Em seguida, o programa pergunta:

Console.Write(
    "Deseja comprimir as imagens? (S/N): ");

string entradaComprimir =
    (Console.ReadLine() ?? "")
        .Trim()
        .ToUpper();

opcoes.Comprimir =
    (entradaComprimir == "S");

O funcionamento é direto: se o usuário digitar S, a propriedade Comprimir recebe true.

Essa informação posteriormente será utilizada pelo serviço para escolher como a imagem será codificada.

Depois vem a largura:

Console.Write(
    "Informe a LARGURA em Px " +
    "(ou aperte ENTER para tamanho original): ");

string inputLargura =
    Console.ReadLine() ?? "";

if (int.TryParse(inputLargura, out int larg)
    && larg > 0)
{
    opcoes.LarguraPx = larg;
}

O método int.TryParse é utilizado para tentar transformar o texto digitado em um número inteiro.

Isso é melhor do que simplesmente utilizar int.Parse, porque uma entrada que não seja numérica não provoca imediatamente uma exceção.

Além disso, o código verifica se o número é maior que zero.

Se o usuário simplesmente pressionar ENTER, a propriedade continua nula.

A altura segue praticamente a mesma lógica:

Console.Write(
    "Informe a ALTURA em Px " +
    "(ou aperte ENTER para tamanho original): ");

string inputAltura =
    Console.ReadLine() ?? "";

if (int.TryParse(inputAltura, out int alt)
    && alt > 0)
{
    opcoes.AlturaPx = alt;
}

Com isso, a aplicação já possui todas as informações necessárias para iniciar o processamento.

Aqui está uma decisão importante na estrutura do projeto.

O Program.cs não faz diretamente o processamento das imagens.

Ele cria uma instância de ConversorServico:

ConversorServico servico =
    new ConversorServico();

var resultados =
    servico.ProcessarTudo(opcoes);

Isso deixa o Program responsável pela interação com o usuário, enquanto a classe ConversorServico fica responsável pelo trabalho pesado.

É uma separação simples, mas que facilita bastante a evolução do projeto.

A classe começa importando os componentes necessários do ImageSharp:

using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats;
using SixLabors.ImageSharp.Formats.Jpeg;
using SixLabors.ImageSharp.Formats.Png;
using SixLabors.ImageSharp.Formats.Webp;
using SixLabors.ImageSharp.Processing;

Também utilizamos classes do próprio .NET para trabalhar com arquivos, diretórios e listas.

O método principal é:

public List ProcessarTudo(
    OpcoesConversao opcoes)

Ele recebe todas as opções que foram definidas no Program.cs e retorna uma lista de resultados.

Uma das primeiras coisas feitas pelo serviço é garantir que as pastas de destino existam:

if (!Directory.Exists(opcoes.PastaDestino))
{
    Directory.CreateDirectory(
        opcoes.PastaDestino);
}

O mesmo acontece com a pasta de processados:

if (!string.IsNullOrEmpty(opcoes.PastaProcessados)
    && !Directory.Exists(
        opcoes.PastaProcessados))
{
    Directory.CreateDirectory(
        opcoes.PastaProcessados);
}

Assim, o programa não depende de o usuário criar manualmente todas as pastas antes de executar a aplicação.

O programa define quais extensões são aceitas:

string[] extensoesValidas =
{
    ".jpg",
    ".jpeg",
    ".png",
    ".webp",
    ".bmp"
};

Depois procura os arquivos existentes na pasta de origem:

List arquivos =
    Directory.GetFiles(opcoes.PastaOrigem)
        .Where(f =>
            extensoesValidas.Contains(
                Path.GetExtension(f).ToLower()))
        .ToList();

Esse trecho é interessante porque evita que qualquer arquivo encontrado na pasta seja tratado como imagem.

Por exemplo, um arquivo .txt colocado acidentalmente no diretório não entra na lista de processamento.

Atualmente, a lista de entrada aceita JPG, JPEG, PNG, WebP e BMP.

O programa também cria um sufixo baseado na data e hora:

string sufixoDataHora =
    DateTime.Now.ToString(
        "_yyyyMMdd_HHmm");

Esse valor será utilizado nos nomes dos arquivos.

Por exemplo, uma imagem chamada:

banner.png

poderá gerar algo semelhante a:

banner_20260831_1534.webp

Isso ajuda a evitar conflitos quando existem arquivos com o mesmo nome.

O processamento acontece dentro de um foreach:

foreach (string caminho in arquivos)
{
    FileInfo info =
        new FileInfo(caminho);

    ResultadoItem item =
        new ResultadoItem
        {
            NomeArquivo = info.Name,
            TamanhoOriginalBytes = info.Length
        };

    // processamento...
}

Antes de processar o arquivo, o programa já registra seu nome e seu tamanho original.

Isso será importante posteriormente para apresentar ao usuário o resultado da conversão.

O código pega o nome original sem a extensão:

string nomeSemExtensao =
    Path.GetFileNameWithoutExtension(
        info.Name);

Depois descobre qual será a extensão do formato escolhido:

string extensao =
    ObterExtensao(opcoes.FormatoSaida);

Finalmente, cria o novo nome:

string novoNomeArquivo =
    $"{nomeSemExtensao}" +
    $"{sufixoDataHora}" +
    $"{extensao}";

E monta o caminho completo:

string caminhoDestino =
    Path.Combine(
        opcoes.PastaDestino,
        novoNomeArquivo);

O método ObterExtensao retorna .jpg, .png ou .webp de acordo com o formato escolhido.

Agora chegamos ao processamento propriamente dito:

using (Image imagem =
    Image.Load(caminho))
{
    // processamento
}

O Image.Load carrega a imagem para que possamos trabalhar com ela em memória.

O using garante que o objeto seja descartado ao final do processamento daquele arquivo.

O redimensionamento é opcional.

O código verifica:

if (opcoes.LarguraPx.HasValue ||
    opcoes.AlturaPx.HasValue)
{
    // redimensionamento
}

Isso significa que basta o usuário informar largura ou altura para o processo de redimensionamento ser executado.

As opções são montadas assim:

ResizeOptions resizeOptions =
    new ResizeOptions
    {
        Size = new Size(
            opcoes.LarguraPx ?? 0,
            opcoes.AlturaPx ?? 0),

        Mode = ResizeMode.Max
    };

Depois:

imagem.Mutate(x =>
    x.Resize(resizeOptions));

Um detalhe importante aqui é o uso de ResizeMode.Max. A intenção é trabalhar com as dimensões informadas sem simplesmente distorcer a imagem para preencher obrigatoriamente os dois valores.

Esse trecho é o responsável pelo redimensionamento da imagem no projeto real.

Depois do redimensionamento, precisamos informar ao ImageSharp como a imagem deverá ser salva.

Para isso, o projeto utiliza o método:

IImageEncoder encoder =
    ObterEncoder(
        opcoes.FormatoSaida,
        opcoes.Qualidade,
        opcoes.Comprimir);

Esse método centraliza a escolha do encoder.

Encoder JPEG

Para JPEG, temos:

case FormatoImagem.Jpeg:
    return new JpegEncoder
    {
        Quality = qualidade
    };

A qualidade recebida pelo encoder é aquela definida nas opções da conversão.

Encoder PNG

Para PNG, o comportamento é um pouco diferente:

case FormatoImagem.Png:
    return new PngEncoder
    {
        CompressionLevel =
            comprimir
                ? PngCompressionLevel.BestCompression
                : PngCompressionLevel.NoCompression
    };

Quando a opção de compressão está ativada, o código utiliza BestCompression. Caso contrário, utiliza NoCompression.

Isso mostra uma diferença interessante entre os formatos: o conceito de "qualidade" e o mecanismo de compressão não precisam ser tratados exatamente da mesma maneira para todos os tipos de imagem.

Encoder WebP

No WebP, o projeto utiliza:

case FormatoImagem.Webp:
default:
    return new WebpEncoder
    {
        Quality = qualidade,

        FileFormat =
            comprimir
                ? WebpFileFormatType.Lossy
                : WebpFileFormatType.Lossless
    };

Aqui temos uma decisão particularmente interessante.

Quando a compressão está ativada, o arquivo é salvo como Lossy. Quando não está, o projeto utiliza Lossless.

Assim, a opção escolhida pelo usuário interfere diretamente na forma como o WebP será gerado.

Depois que o encoder foi definido, finalmente salvamos o arquivo:

imagem.Save(
    caminhoDestino,
    encoder);

É neste ponto que a imagem processada efetivamente é gravada na pasta de destino.

O fluxo completo dentro do serviço é, portanto:

1. localizar a imagem;
2. carregar a imagem;
3. redimensionar se necessário;
4. escolher o encoder;
5. salvar no formato escolhido;
6. registrar o tamanho final;
7. mover o arquivo original para a pasta de processados.

Essa é basicamente a lógica central do conversor.

Depois que a imagem foi salva, o código cria um novo FileInfo:

FileInfo infoDestino =
    new FileInfo(caminhoDestino);

item.TamanhoFinalBytes =
    infoDestino.Length;

item.Sucesso = true;

Agora temos os dois valores necessários:

• tamanho original;
• tamanho final.

Isso permite apresentar ao usuário uma comparação do resultado.

Depois de gerar a nova imagem, o arquivo original é movido para a pasta de processados:

if (!string.IsNullOrEmpty(
        opcoes.PastaProcessados)
    && File.Exists(caminho))
{
    string nomeOriginalComData =
        $"{nomeSemExtensao}" +
        $"{sufixoDataHora}" +
        $"{info.Extension}";

    string caminhoProcessado =
        Path.Combine(
            opcoes.PastaProcessados,
            nomeOriginalComData);

    File.Move(
        caminho,
        caminhoProcessado);
}

Esse comportamento é importante para o funcionamento em lote.

Depois que uma imagem foi processada, ela deixa de estar na pasta de origem.

Assim, se eu executar o programa novamente, as imagens que já foram processadas não ficam novamente na fila.

O código real utiliza exatamente essa estratégia de mover o arquivo original para a pasta configurada como PastaProcessados.

Como estamos trabalhando com arquivos, imagens e diretórios, erros podem acontecer.

Por isso, o processamento de cada imagem está protegido por try/catch:

catch (Exception ex)
{
    item.Sucesso = false;
    item.MensagemErro = ex.Message;
}

Em vez de interromper necessariamente todo o processamento ao encontrar um problema, o erro é registrado no resultado daquele arquivo.

Isso é bastante útil quando temos várias imagens para processar.

Imagine, por exemplo, que existam 50 arquivos na pasta e apenas um deles apresente algum problema. O modelo de resultado permite identificar qual arquivo falhou.

A aplicação registra a mensagem de exceção em MensagemErro.

Depois que o serviço termina o processamento, o Program.cs percorre os resultados:

foreach (var item in resultados)
{
    if (item.Sucesso)
    {
        // resultado positivo
    }
    else
    {
        // erro
    }
}

Para arquivos processados com sucesso, o programa converte os tamanhos para KB:

double origKb =
    item.TamanhoOriginalBytes / 1024.0;

double finalKb =
    item.TamanhoFinalBytes / 1024.0;

Depois calcula a porcentagem de alteração:

double reducao =
    100.0 -
    ((double)item.TamanhoFinalBytes /
     item.TamanhoOriginalBytes * 100.0);

E finalmente mostra o resultado:

Console.WriteLine(
    $"[OK] {item.NomeArquivo} | " +
    $"{origKb:F1} KB -> " +
    $"{finalKb:F1} KB " +
    $"({reducao:F1}% alteração)");

O próprio programa real utiliza esses dados para mostrar no console o tamanho antes e depois do processamento.

Imagine que eu coloque na pasta Origem uma imagem chamada:

banner.png

Ao iniciar o programa, ele pergunta:

Formato de saída (png, webp ou jpeg): webp

Deseja comprimir as imagens? (S/N): S

Informe a LARGURA em Px
(ou aperte ENTER para tamanho original): 1200

Informe a ALTURA em Px
(ou aperte ENTER para tamanho original): 800

O programa então passa essas informações para o serviço.

A imagem será carregada, redimensionada conforme as opções, convertida para WebP e salva na pasta de destino.

O arquivo original será movido para a pasta de processados.

Ao final, o console apresenta o resultado do processamento.

Uma das coisas que considero interessantes nesse projeto é justamente sua simplicidade.

Eu poderia ter começado tentando criar uma aplicação desktop completa, com botões, campos, seleção de arquivos e uma interface gráfica.

Mas isso aumentaria bastante a quantidade de coisas que precisariam ser resolvidas.

Como o objetivo inicial era descobrir se eu conseguia resolver o problema com C#, uma aplicação de console já era suficiente.

Primeiro eu precisava provar a ideia.

Depois poderia pensar na interface.

Essa abordagem também é interessante para quem está estudando programação: muitas vezes não precisamos começar pelo projeto mais sofisticado possível.

Podemos começar pequeno, fazer funcionar e evoluir.

Apesar de ser uma aplicação pequena, ela reúne vários conceitos interessantes.

• leitura de arquivos JSON;
• configuração externa da aplicação;
• classes e propriedades;
• enum;
• nullable types;
• listas;
• LINQ;
• manipulação de arquivos;
• manipulação de diretórios;
• tratamento de exceções;
• processamento em lote;
• uso de bibliotecas externas;
• separação de responsabilidades;
• processamento e conversão de imagens.

Por isso, mesmo sendo um projeto pequeno, ele pode ser um exercício interessante para quem está aprendendo C#.

Existe uma diferença importante entre a necessidade que motivou o projeto e a versão atual do código.

Uma das dificuldades que me levou a pensar nessa ferramenta foi justamente a necessidade de trabalhar com recortes de imagens.

Porém, a versão do código apresentada neste artigo ainda não implementa um recurso de recorte manual da imagem.

O que já está implementado é o redimensionamento, conversão e compressão.

E isso é propositalmente interessante de mostrar.

NÃO precisamos fingir que o projeto está pronto ou que possui todos os recursos imaginados inicialmente. Ele resolveu uma parte do problema e ainda pode evoluir.

Se eu continuasse evoluindo esse projeto, o próximo passo provavelmente seria justamente transformar essa aplicação de console em uma ferramenta mais amigável.

Algumas possibilidades seriam:

• criar uma interface desktop;
• adicionar seleção visual de arquivos;
• permitir arrastar e soltar imagens;
• criar um recurso visual de recorte;
• permitir processar imagens individualmente;
• criar processamento em lote mais configurável;
• permitir escolher manualmente a qualidade;
• mostrar uma prévia da imagem;
• mostrar o tamanho original e o final;
• criar presets para banners e cards;
• criar uma versão web.

Como esse projeto nasceu justamente da necessidade de preparar imagens para publicação, uma evolução que faria bastante sentido seria criar configurações prontas.

Por exemplo:

1 - Card do artigo
2 - Banner
3 - Imagem interna
4 - Imagem otimizada para Web
5 - Personalizado

Ao escolher Card do artigo, a aplicação poderia automaticamente aplicar as dimensões e o formato definidos para esse tipo de imagem.

Assim, eu não precisaria lembrar das configurações todas as vezes que fosse preparar uma nova imagem.

É exatamente esse tipo de melhoria que pode transformar um pequeno script criado para resolver uma necessidade pessoal em uma ferramenta realmente útil.

Outra evolução possível seria transformar o projeto em uma aplicação web.

O usuário poderia acessar uma página, enviar uma ou várias imagens, escolher o formato, definir as dimensões e selecionar o nível de compressão.

O servidor faria o processamento e disponibilizaria os arquivos convertidos.

Outra possibilidade seria transformar a lógica existente em uma API, permitindo que outros sistemas enviem imagens para processamento.

Ou seja, a aplicação de console atual poderia ser encarada como o primeiro estágio de um projeto muito maior.

No meu caso, valeu como experiência.

Eu estava enfrentando um problema real e repetitivo. Em vez de continuar procurando uma ferramenta gratuita na internet toda vez que precisava preparar uma imagem, resolvi testar se conseguiria criar algo próprio.

O resultado não é uma ferramenta profissional de edição de imagens.

E nem precisa ser.

Ela resolve algumas tarefas específicas que eu precisava realizar e, principalmente, me deu uma base para continuar evoluindo.

Esse é um dos aspectos da programação que mais gosto: uma necessidade pequena pode ser o começo de um projeto interessante.

Criar esse conversor de imagens em C# começou como uma tentativa de resolver uma dificuldade que encontrei durante a produção dos meus próprios conteúdos.

Eu precisava lidar constantemente com imagens, encontrar ferramentas para redimensioná-las, convertê-las e reduzir seu tamanho. Em vez de depender sempre de serviços online, resolvi experimentar uma solução própria.

A aplicação atual é simples, mas já consegue realizar um fluxo bastante útil: encontrar imagens em uma pasta, redimensioná-las quando necessário, convertê-las para JPG, PNG ou WebP, aplicar as opções de compressão, salvar o resultado e mover os arquivos originais para uma pasta de processados.

Além disso, o projeto mostra como podemos separar responsabilidades em uma aplicação pequena: o Program.cs cuida da interação com o usuário, os modelos armazenam as opções e resultados e o ConversorServico concentra a lógica de processamento.

Para mim, esse é justamente o valor desse tipo de projeto. Não é necessário criar uma aplicação gigantesca para aprender alguma coisa ou resolver um problema real.

Às vezes, basta olhar para uma tarefa repetitiva e perguntar:

"Será que eu consigo automatizar isso?"

Foi exatamente essa pergunta que deu origem ao projeto.

E você, já criou uma ferramenta para resolver um problema do seu dia a dia? Conte nos comentários. Pode ser justamente uma dessas pequenas automações que acabam virando um projeto muito maior.

Desafio para você

Se você gostou da ideia, tente pegar esse projeto e evoluí-lo. Que tal transformar o console em uma aplicação desktop? Ou adicionar um sistema visual de recorte? Outra possibilidade é criar uma versão web para processar imagens diretamente pelo navegador.

Quer mais projetos práticos de C#?

No Nerd Cult, compartilho conhecimento prático baseado em projetos reais. Assine nossa newsletter e receba conteúdos sobre desenvolvimento, carreira e cultura geek.

Quer colaborar com o Nerd Cult?

Se você também criou uma ferramenta, automação ou projeto interessante para resolver um problema real, entre em contato com o Nerd Cult. Projetos simples podem render ótimos conteúdos quando existe uma história real por trás deles.

Nerd Cult — onde o código encontra o rock, o cinema e a cultura geek. Porque ser nerd é transformar o medo em curiosidade, e a curiosidade em poder.

#CSharp #ImageSharp #Programacao #ProjetosPraticos #NerdCult