Como criar um blog em C# em 2026: blog técnico com ASP.NET Core e Minimal APIs
Blog em C# no .NET 10 com Minimal APIs do ASP.NET Core: posts em Markdown com front matter, repositório thread-safe com hot reload, páginas Razor, output caching e feed RSS.

Para ter um blog em C# no ar, não é preciso CMS nem banco de dados. Com as Minimal APIs do ASP.NET Core, poucos arquivos dão conta do recado: posts em Markdown salvos em disco, um repositório singleton que faz o parsing deles uma única vez, alguns endpoints que devolvem HTML e um feed RSS. No .NET 10, a versão com suporte de longo prazo (LTS) lançada em novembro de 2025, cada peça dessa stack vem do próprio framework ou de dois pacotes NuGet bem mantidos.
Projeto web em .NET 10, Markdig para converter Markdown em HTML, YamlDotNet para o front matter, um repositório de posts imutável em memória recarregado a cada alteração de arquivo, endpoints Minimal API que retornam páginas RazorComponentResult, output caching com invalidação por tag e um feed RSS 2.0 gerado com System.ServiceModel.Syndication. O motor inteiro fica abaixo de 300 linhas de C#.
Por que um blog em Minimal API em vez de um gerador de site estático
Geradores como Hugo e Jekyll produzem arquivos HTML no momento do build. São rápidos e baratos de hospedar, mas qualquer comportamento que vá além dos templates (posts agendados, uma API JSON para um app mobile, feeds por tag, integração com analytics) acaba virando um plugin escrito em uma linguagem que o desenvolvedor .NET não usa no dia a dia.
Um blog em ASP.NET Core mantém o conteúdo como arquivos Markdown versionados no Git, renderiza tudo na primeira requisição e, dali em diante, serve o resultado a partir da memória. Com output caching na frente, o custo por requisição fica muito próximo ao de um arquivo estático, e o código executado é C# comum, que pode ser depurado, testado e estendido sem trocar de ferramenta. O projeto ainda passa por injeção de dependência, pipeline de requisições, cache e concorrência, exatamente os assuntos que caem em uma entrevista técnica de .NET.
| Critério | Gerador de site estático | Blog com Minimal APIs do ASP.NET Core |
|---|---|---|
| Formato do conteúdo | Markdown + front matter | Markdown + front matter |
| Momento da renderização | No build | Na primeira requisição, depois em cache |
| Lógica customizada | Plugins, templates | Endpoints em C# |
| Hospedagem | Qualquer host estático ou CDN | Container, App Service, qualquer VPS |
| Atualização de conteúdo | Novo build e deploy | O file watcher recarrega o repositório |
Criando o projeto de blog ASP.NET Core no .NET 10
O ponto de partida é o template web vazio. dotnet new web gera um projeto sobre o SDK Microsoft.NET.Sdk.Web, que já compila componentes .razor sem configuração extra. Três pacotes completam o conjunto: Markdig para o parsing de CommonMark, YamlDotNet para o front matter e System.ServiceModel.Syndication para o feed.
# terminal
dotnet new web -n CSharpBlog --framework net10.0
cd CSharpBlog
dotnet add package Markdig
dotnet add package YamlDotNet
dotnet add package System.ServiceModel.Syndication
mkdir posts Posts Endpoints ComponentsO Program.cs liga todas as partes. O repositório de posts é registrado como singleton porque os posts já processados são compartilhados por todas as requisições, e o middleware de output caching entra no pipeline antes dos endpoints, para que uma resposta em cache pule por completo a execução do handler.
var builder = WebApplication.CreateBuilder(args);
// Site settings bound from the "Blog" section of appsettings.json
builder.Services.Configure<BlogOptions>(builder.Configuration.GetSection("Blog"));
builder.Services.AddSingleton<PostStore>(); // one parsed snapshot shared by all requests
builder.Services.AddRazorComponents(); // enables RazorComponentResult rendering
builder.Services.AddOpenApi(); // OpenAPI 3.1 document for the JSON API
builder.Services.AddOutputCache(options =>
options.AddBasePolicy(policy => policy.Expire(TimeSpan.FromHours(1))));
var app = builder.Build();
app.MapStaticAssets(); // CSS and images from wwwroot, fingerprinted since .NET 9
app.UseOutputCache(); // must run before the endpoints it caches
app.MapOpenApi();
app.MapBlogEndpoints();
app.MapFeedEndpoints();
app.Run();
public sealed class BlogOptions
{
public string Title { get; set; } = "C# Notes";
public string SiteUrl { get; set; } = "https://localhost:5001/";
}A configuração SiteUrl faz diferença mais adiante: links canônicos e URLs do feed são montados a partir da configuração, nunca a partir do header Host da requisição recebida.
Fazendo o parsing de posts Markdown com front matter em C#
Cada post é um arquivo como posts/output-caching-dotnet-10.md. O nome do arquivo vira o slug, e um bloco YAML no topo guarda os metadados:
---
title: Output caching in .NET 10
summary: How tag-based eviction keeps cached pages fresh.
date: 2026-11-10
tags: [aspnet-core, performance]
draft: false
---
Output caching stores the full response on the server...O parser separa o bloco YAML do corpo, desserializa os metadados em uma classe pequena e converte o corpo em HTML. As quebras de linha são normalizadas antes de tudo; sem isso, um post salvo no Windows quebra a busca pelo delimitador ---.
using Markdig;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;
public sealed record Post(string Slug, string Title, string Summary,
DateTime PublishedOn, IReadOnlyList<string> Tags, bool Draft, string Html);
public static class PostParser
{
// Built once and reused by every reload
private static readonly MarkdownPipeline Pipeline =
new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
private static readonly IDeserializer Yaml = new DeserializerBuilder()
.WithNamingConvention(CamelCaseNamingConvention.Instance)
.IgnoreUnmatchedProperties() // unknown keys do not crash the reload
.Build();
public static Post Parse(string slug, string text)
{
text = text.ReplaceLineEndings("\n");
if (!text.StartsWith("---\n"))
throw new FormatException($"{slug}: missing front matter");
var end = text.IndexOf("\n---", 4, StringComparison.Ordinal);
if (end < 0)
throw new FormatException($"{slug}: unterminated front matter");
var meta = Yaml.Deserialize<FrontMatter>(text[4..end]);
var html = Markdown.ToHtml(text[(end + 4)..], Pipeline);
return new Post(slug, meta.Title, meta.Summary, meta.Date, meta.Tags, meta.Draft, html);
}
private sealed class FrontMatter
{
public string Title { get; set; } = "";
public string Summary { get; set; } = "";
public DateTime Date { get; set; }
public List<string> Tags { get; set; } = [];
public bool Draft { get; set; }
}
}UseAdvancedExtensions() ativa tabelas, notas de rodapé, listas de tarefas, IDs automáticos nos títulos e as demais extensões do Markdig que um blog técnico precisa. Por padrão, o Markdig deixa HTML bruto passar. Isso é aceitável para posts escritos pelo dono do site, mas qualquer Markdown enviado por usuários (comentários, posts de convidados) precisa de DisableHtml() no pipeline para evitar XSS armazenado.
Um repositório singleton thread-safe com hot reload
Na inicialização, o repositório lê todos os arquivos e guarda o resultado em um FrozenDictionary (disponível desde o .NET 8), otimizado para cenários com muita leitura. Quando um arquivo muda, ele monta um dicionário inteiramente novo e troca a referência em uma única atribuição. Quem lê nunca pega lock: cada requisição enxerga o snapshot antigo ou o novo, nunca uma coleção pela metade.
using System.Collections.Frozen;
using Microsoft.AspNetCore.OutputCaching;
using Microsoft.Extensions.FileProviders;
using Microsoft.Extensions.Primitives;
public sealed class PostStore
{
private readonly PhysicalFileProvider _files;
private readonly IOutputCacheStore _cache;
private readonly ILogger<PostStore> _logger;
private volatile FrozenDictionary<string, Post> _bySlug = FrozenDictionary<string, Post>.Empty;
public PostStore(IWebHostEnvironment env, IOutputCacheStore cache, ILogger<PostStore> logger)
{
(_cache, _logger) = (cache, logger);
_files = new PhysicalFileProvider(Path.Combine(env.ContentRootPath, "posts"));
Reload();
ChangeToken.OnChange(() => _files.Watch("*.md"), Reload); // re-registers after each change
}
public Post? Find(string slug) => _bySlug.TryGetValue(slug, out var post) ? post : null;
public IReadOnlyList<Post> Latest(int count) =>
_bySlug.Values.OrderByDescending(p => p.PublishedOn).Take(count).ToList();
private void Reload()
{
try
{
var snapshot = _files.GetDirectoryContents("")
.Where(f => !f.IsDirectory && f.Name.EndsWith(".md", StringComparison.Ordinal))
.Select(f => PostParser.Parse(Path.GetFileNameWithoutExtension(f.Name), File.ReadAllText(f.PhysicalPath!)))
.Where(p => !p.Draft)
.ToFrozenDictionary(p => p.Slug);
_bySlug = snapshot; // atomic reference swap
_ = _cache.EvictByTagAsync("posts", CancellationToken.None).AsTask();
_logger.LogInformation("Loaded {Count} posts", snapshot.Count);
}
catch (Exception ex)
{
_logger.LogError(ex, "Reload failed, keeping the previous snapshot"); // a typo never takes the site down
}
}
}Três detalhes deixam esse código pronto para produção. O campo volatile garante que as outras threads leiam a referência mais recente depois da troca. O try/catch mantém o último snapshot válido quando um post tem YAML inválido, então um erro de digitação em um arquivo não esvazia o blog. E a chamada a EvictByTagAsync descarta todas as páginas em cache com a tag posts, fazendo o conteúdo novo aparecer já na próxima requisição, e não só depois da expiração de uma hora.
O FileSystemWatcher depende de notificações do sistema operacional que não atravessam de forma confiável bind mounts do Docker nem compartilhamentos de rede. Em um container que monta a pasta posts, vale definir a variável de ambiente DOTNET_USE_POLLING_FILE_WATCHER=true ou PhysicalFileProvider.UsePollingFileWatcher = true. Os editores também salvam um arquivo em várias gravações, então Reload pode disparar duas ou três vezes a cada salvamento: inofensivo aqui, já que cada execução gera o mesmo snapshot.
Endpoints Minimal API com grupos de rotas e TypedResults
As páginas públicas ficam agrupadas sob /blog com MapGroup, o que aplica a política de output caching e sua tag a todos os endpoints de uma vez. Os handlers retornam RazorComponentResult<T>, disponível desde o .NET 8, que renderiza um componente Razor como resposta HTTP completa, sem MVC, sem Razor Pages e sem o router do Blazor.
using CSharpBlog.Components; // namespace of PostPage and PostListPage
using Microsoft.AspNetCore.Http.HttpResults;
public static class BlogEndpoints
{
public static IEndpointRouteBuilder MapBlogEndpoints(this IEndpointRouteBuilder app)
{
var blog = app.MapGroup("/blog").CacheOutput(p => p.Tag("posts"));
blog.MapGet("/", (PostStore store) =>
new RazorComponentResult<PostListPage>(new { Posts = store.Latest(20) }));
blog.MapGet("/{slug:regex(^[a-z0-9-]+$)}", GetPost); // rejects odd slugs before the handler
app.MapGet("/api/posts", (PostStore store) =>
TypedResults.Ok(store.Latest(50).Select(p => new PostSummary(p.Slug, p.Title, p.Summary, p.PublishedOn))))
.CacheOutput(p => p.Tag("posts"))
.WithName("ListPosts");
return app;
}
// The union return type documents both outcomes for OpenAPI and for unit tests
private static Results<RazorComponentResult<PostPage>, NotFound> GetPost(string slug, PostStore store) =>
store.Find(slug) is { } post
? new RazorComponentResult<PostPage>(new { Post = post })
: TypedResults.NotFound();
}
public sealed record PostSummary(string Slug, string Title, string Summary, DateTime PublishedOn);O tipo de retorno Results<T1, T2> é o que diferencia TypedResults dos antigos helpers Results. O compilador confere se o handler só retorna os resultados declarados, o gerador de OpenAPI lê os dois status codes direto da assinatura, e um teste unitário consegue verificar result.Result is NotFound sem subir um servidor. O endpoint JSON fica fora do grupo /blog para que sua URL não colida com os slugs dos posts.
A página do post é um componente Razor comum. MarkupString instrui o Razor a emitir a saída do Markdig como HTML em vez de codificá-la, e a URL canônica vem de BlogOptions.
@* Components/PostPage.razor *@
@using Microsoft.Extensions.Options
@inject IOptions<BlogOptions> Options
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8" />
<title>@Post.Title | @Options.Value.Title</title>
<meta name="description" content="@Post.Summary" />
<link rel="canonical" href="@(new Uri(new Uri(Options.Value.SiteUrl), $"blog/{Post.Slug}"))" />
<link rel="alternate" type="application/rss+xml" title="@Options.Value.Title" href="/feed.xml" />
<link rel="stylesheet" href="/site.css" />
</head>
<body>
<article>
<h1>@Post.Title</h1>
<time datetime="@(Post.PublishedOn.ToString("yyyy-MM-dd"))">@(Post.PublishedOn.ToString("d MMMM yyyy"))</time>
@((MarkupString)Post.Html)
</article>
</body>
</html>
@code {
[Parameter, EditorRequired] public Post Post { get; set; } = default!;
}PostListPage.razor segue o mesmo padrão, com um parâmetro Posts e um loop sobre títulos e resumos. O objeto anônimo passado para RazorComponentResult mapeia os nomes das propriedades para os parâmetros do componente, por isso new { Post = post } precisa bater exatamente com o parâmetro Post.
Pronto para mandar bem nas entrevistas de .NET?
Pratique com nossos simuladores interativos, flashcards e testes tecnicos.
Output caching para as páginas de um blog ASP.NET Core
O output caching, introduzido no ASP.NET Core 7, armazena a resposta completa no servidor e a reproduz sem executar o handler nem renderizar o componente de novo. Ele é diferente do antigo middleware de response caching, que segue a semântica HTTP de Cache-Control e permite que um cliente ignore o cache com um header no-cache. A documentação de output caching no Microsoft Learn descreve as regras padrão: só entram em cache requisições GET e HEAD que retornam 200, e respostas que definem cookies ou que vêm de requisições autenticadas ficam de fora.
São as tags que tornam o output caching adequado para um site de conteúdo. Todo endpoint do blog carrega a tag posts, e o repositório invalida essa tag após cada recarga. A política base de uma hora funciona só como rede de segurança; na prática, as páginas continuam em cache até o conteúdo mudar.
Em um deploy com várias instâncias, o cache em memória é exclusivo de cada processo: invalidar em uma instância deixa as outras servindo conteúdo desatualizado. O ASP.NET Core oferece um armazenamento baseado em Redis pelo pacote Microsoft.AspNetCore.OutputCaching.StackExchangeRedis e pelo método AddStackExchangeRedisOutputCache, que compartilha entradas e invalidações entre as instâncias. Uma única instância pequena não precisa disso.
Gerando um feed RSS em C# com SyndicationFeed
O público técnico ainda assina conteúdo por leitores de feed, e os agregadores descobrem posts novos pelo feed, não pelo sitemap. SyndicationFeed e Rss20FeedFormatter geram um feed que segue a especificação RSS 2.0 sem escrever XML à mão.
using System.ServiceModel.Syndication;
using System.Text;
using System.Xml;
using Microsoft.Extensions.Options;
public static class FeedEndpoints
{
public static IEndpointRouteBuilder MapFeedEndpoints(this IEndpointRouteBuilder app)
{
app.MapGet("/feed.xml", (PostStore store, IOptions<BlogOptions> options) =>
{
var site = new Uri(options.Value.SiteUrl); // never built from the Host header
var items = store.Latest(20).Select(p =>
{
var date = new DateTimeOffset(DateTime.SpecifyKind(p.PublishedOn, DateTimeKind.Utc));
return new SyndicationItem(p.Title, p.Summary, new Uri(site, $"blog/{p.Slug}"), p.Slug, date)
{
PublishDate = date // RSS pubDate comes from PublishDate, not LastUpdatedTime
};
});
var feed = new SyndicationFeed(options.Value.Title, "Articles on C# and .NET", site, items);
using var buffer = new MemoryStream();
using (var writer = XmlWriter.Create(buffer, new XmlWriterSettings { Encoding = new UTF8Encoding(false) }))
new Rss20FeedFormatter(feed).WriteTo(writer); // writer flushes on dispose
return TypedResults.Bytes(buffer.ToArray(), "application/rss+xml; charset=utf-8");
}).CacheOutput(p => p.Tag("posts"));
return app;
}
}Montar as URLs absolutas a partir de BlogOptions.SiteUrl em vez de HttpContext.Request.Host fecha a porta para uma injeção de header Host: sem esse cuidado, uma única requisição com um valor Host forjado entraria no cache e seria servida a todos os assinantes com links apontando para outro domínio. O argumento UTF8Encoding(false) remove o byte order mark (BOM), que alguns leitores de feed rejeitam.
Deploy do blog técnico em C# e os limites do Native AOT
dotnet publish -c Release gera um build dependente de framework que roda em qualquer host com o runtime do .NET 10. Desde o .NET 8, o SDK também cria imagens de container sem Dockerfile: dotnet publish -c Release /t:PublishContainer produz uma imagem baseada na imagem oficial do runtime do ASP.NET Core. A pasta posts pode ir embutida na imagem (qualquer mudança de conteúdo exige novo deploy) ou ser montada como volume (o file watcher capta as alterações).
O Native AOT atrai pelo tempo de inicialização e pelo consumo de memória, mas este projeto não é um bom candidato. A tabela de compatibilidade de Native AOT do ASP.NET Core lista as Minimal APIs com suporte parcial e o Blazor Server como não suportado, e o desserializador padrão do YamlDotNet depende de reflection. Um blog serve páginas em cache a partir de um processo de longa duração, então o tempo de inicialização quase não pesa. Migrar para AOT significaria trocar os componentes Razor por templates de string e o YAML por um front matter em JSON com source generators, com ganho pequeno.
Perguntas de entrevista .NET que este projeto ajuda a preparar
Cada parte do motor corresponde a uma pergunta frequente em entrevistas de ASP.NET Core. As perguntas de entrevista de .NET no SharpSkill cobrem todas elas a fundo, e o módulo de Minimal APIs foca na parte de endpoints.
"Um serviço singleton é seguro se muitas requisições o leem ao mesmo tempo?" Só se o estado dele for imutável ou sincronizado. O repositório deste artigo usa um snapshot imutável e uma troca de referência volatile, então leitores nunca travam e escritas nunca bloqueiam leitores. A armadilha clássica é um singleton com uma List<T> alterada durante a recarga, que sob carga lança InvalidOperationException no meio de uma enumeração. O módulo de injeção de dependência também trata do problema da dependência cativa: um singleton que recebe um serviço scoped, como um DbContext, o mantém vivo durante toda a vida da aplicação.
"Qual a diferença entre output caching e response caching?" O output caching é controlado pelo servidor, suporta tags e invalidação e ignora os headers de cache do cliente. O response caching segue a semântica HTTP e funciona principalmente como uma indicação para proxies e navegadores.
"Por que retornar TypedResults em vez de Results?" Tipos de resultado concretos trazem verificação em tempo de compilação dos resultados possíveis, metadados OpenAPI automáticos e handlers testáveis como métodos comuns. A comparação aprofundada com controllers está no artigo sobre arquitetura e performance das Minimal APIs.
"Onde a ordem dos middlewares importa nesta aplicação?" UseOutputCache precisa ser registrado antes dos endpoints que ele coloca em cache, e depois de UseCors quando o CORS está ativo. Quem também consegue explicar por que a política padrão nunca guarda requisições autenticadas, e o que uma IOutputCachePolicy customizada deve checar antes de fazer isso, mostra que entende o pipeline em vez de repetir uma ordem decorada.
Blog em C# com ASP.NET Core: o que levar deste tutorial
- Começar com
dotnet new webno .NET 10 e adicionar apenas Markdig, YamlDotNet eSystem.ServiceModel.Syndication; um blog técnico dispensa CMS e banco de dados. - Fazer o parsing dos posts uma única vez em um
FrozenDictionaryimutável e trocar o snapshot inteiro na recarga, para que leitores nunca travem e um arquivo quebrado nunca esvazie o site. - Renderizar o HTML com
RazorComponentResult<T>nos handlers Minimal API e declarar tipos de retornoResults<T1, T2>para que o OpenAPI e os testes unitários enxerguem todos os resultados. - Colocar todo endpoint de conteúdo atrás do output caching com uma tag compartilhada e chamar
EvictByTagAsyncapós cada recarga, em vez de depender de expirações curtas. - Montar as URLs canônicas e do feed a partir da configuração, nunca do header
Host, e ativarDisableHtml()em qualquer pipeline que renderize Markdown vindo de usuários. - Definir
DOTNET_USE_POLLING_FILE_WATCHER=truequando a pasta de posts for montada em um container. - Usar o projeto como treino para entrevistas: estar pronto para explicar em voz alta a segurança do singleton entre threads, a escolha do cache e a ordem dos middlewares.
Comece a praticar!
Teste seus conhecimentos com nossos simuladores de entrevista e testes tecnicos.
Você saberia encontrar o bug em .NET?
Um trecho real, um bug escondido, uma tentativa por dia. Sem conta para testar.

Escrito por
Anthony Fillion-MailletFundador da SharpSkill
Desenvolvedor fullstack há mais de 10 anos. Dirige a SharpSkill e responde por tudo o que é publicado aqui.
Atualizado em 17 de novembro de 2026
Tags
Compartilhar
Artigos relacionados

Tempo de Vida do DbContext no ASP.NET Core: Performance vs Segurança de Threads em Operações Async
Domine o gerenciamento do tempo de vida do DbContext no ASP.NET Core. Aprenda quando usar scoped vs transient, como lidar com operações async de forma segura e otimizar performance com pooling de DbContext.

LINQ Avançado em C# em 2026: Operadores, Performance e Perguntas de Entrevista
Dominar operadores LINQ avançados, otimizar a performance de consultas e se preparar para entrevistas técnicas C# com exemplos práticos.

.NET 9 Blazor: Desenvolvimento Full-Stack com Blazor United em 2026
.NET 9 Blazor United combina renderização estática SSR, Server e WebAssembly em um framework full-stack unificado. Tutorial prático cobrindo modos de renderização, streaming, injeção por construtor e padrões prontos para produção.