# 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. - Published: 2026-11-17 - Updated: 2026-11-17 - Author: Anthony Fillion-Maillet - Tags: dotnet, csharp, aspnet-core, minimal-apis, output-caching, tutorial - Reading time: 13 min --- 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. > **A stack em um parágrafo** > > 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](https://github.com/xoofx/markdig) para o parsing de CommonMark, YamlDotNet para o front matter e `System.ServiceModel.Syndication` para o feed. ```bash # 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 Components ``` O `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. ```csharp // Program.cs var builder = WebApplication.CreateBuilder(args); // Site settings bound from the "Blog" section of appsettings.json builder.Services.Configure(builder.Configuration.GetSection("Blog")); builder.Services.AddSingleton(); // 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: ```markdown --- 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 `---`. ```csharp // Posts/PostParser.cs using Markdig; using YamlDotNet.Serialization; using YamlDotNet.Serialization.NamingConventions; public sealed record Post(string Slug, string Title, string Summary, DateTime PublishedOn, IReadOnlyList 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(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 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. ```csharp // Posts/PostStore.cs 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 _logger; private volatile FrozenDictionary _bySlug = FrozenDictionary.Empty; public PostStore(IWebHostEnvironment env, IOutputCacheStore cache, ILogger 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 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. > **Monitoramento de arquivos dentro de containers** > > 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`, 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. ```csharp // Endpoints/BlogEndpoints.cs 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(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, NotFound> GetPost(string slug, PostStore store) => store.Find(slug) is { } post ? new RazorComponentResult(new { Post = post }) : TypedResults.NotFound(); } public sealed record PostSummary(string Slug, string Title, string Summary, DateTime PublishedOn); ``` O tipo de retorno `Results` é 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`. ```razor @* Components/PostPage.razor *@ @using Microsoft.Extensions.Options @inject IOptions Options @Post.Title | @Options.Value.Title

@Post.Title

@((MarkupString)Post.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`. ## 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](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output) 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](https://www.rssboard.org/rss-specification) sem escrever XML à mão. ```csharp // Endpoints/FeedEndpoints.cs 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 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](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot) 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](https://sharpskill.dev/pt/technologies/dotnet) cobrem todas elas a fundo, e o [módulo de Minimal APIs](https://sharpskill.dev/pt/technologies/dotnet/perguntas-entrevista/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` 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](https://sharpskill.dev/pt/technologies/dotnet/perguntas-entrevista/dependency-injection) 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](https://sharpskill.dev/pt/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview). **"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 web` no .NET 10 e adicionar apenas Markdig, YamlDotNet e `System.ServiceModel.Syndication`; um blog técnico dispensa CMS e banco de dados. - Fazer o parsing dos posts uma única vez em um `FrozenDictionary` imutá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` nos handlers Minimal API e declarar tipos de retorno `Results` 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 `EvictByTagAsync` apó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 ativar `DisableHtml()` em qualquer pipeline que renderize Markdown vindo de usuários. - Definir `DOTNET_USE_POLLING_FILE_WATCHER=true` quando 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. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/pt/blog/dotnet/csharp-blog-aspnet-core-minimal-apis-2026