# Cómo crear un blog en C# en 2026: blog técnico con ASP.NET Core y Minimal APIs > Un blog en C# sobre .NET 10 con Minimal APIs de ASP.NET Core: publicaciones Markdown con front matter, almacén thread-safe con recarga en caliente, páginas Razor, output caching y 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 --- Montar un blog en C# no exige un CMS ni una base de datos. Con las Minimal APIs de ASP.NET Core alcanzan unos pocos archivos: publicaciones en Markdown guardadas en disco, un almacén singleton que las procesa una sola vez, un par de endpoints que devuelven HTML y un feed RSS. En .NET 10, la versión de soporte extendido (LTS) lanzada en noviembre de 2025, todas las piezas vienen incluidas en el framework o en dos paquetes NuGet con mantenimiento activo. > **El stack completo en un párrafo** > > Proyecto web en .NET 10, Markdig para pasar de Markdown a HTML, YamlDotNet para el front matter, un almacén de publicaciones inmutable en memoria que se recarga cuando cambia un archivo, endpoints Minimal API que devuelven páginas `RazorComponentResult`, output caching con desalojo por etiquetas y un feed RSS 2.0 generado con `System.ServiceModel.Syndication`. El motor entero ocupa menos de 300 líneas de C#. ## Minimal API frente a un generador de sitios estáticos Herramientas como Hugo o Jekyll generan los archivos HTML durante el build. Son rápidas y el hosting sale barato, pero cualquier comportamiento que vaya más allá de las plantillas (publicaciones programadas, una API JSON para una app móvil, feeds por etiqueta, integración con analítica) termina en un plugin escrito en un lenguaje que el desarrollador .NET no usa a diario. Un blog con ASP.NET Core mantiene el contenido como archivos Markdown versionados en Git, los convierte a HTML en la primera solicitud y a partir de ahí los sirve desde memoria. Con output caching por delante, el costo de cada solicitud queda muy cerca del de un archivo estático, y lo que se ejecuta es C# común y corriente: se puede depurar, probar y extender con las herramientas de siempre. Además, el proyecto recorre inyección de dependencias, el pipeline de solicitudes, caché y concurrencia, justo los temas que aparecen en una entrevista técnica de .NET. | Aspecto | Generador de sitios estáticos | Blog con Minimal APIs de ASP.NET Core | |---|---|---| | Formato del contenido | Markdown + front matter | Markdown + front matter | | Momento del renderizado | Durante el build | En la primera solicitud, luego desde caché | | Lógica personalizada | Plugins, plantillas | Endpoints en C# | | Hosting | Cualquier hosting estático o CDN | Contenedor, App Service, cualquier VPS | | Actualización del contenido | Nuevo build y despliegue | El observador de archivos recarga el almacén | ## Configuración del proyecto de blog ASP.NET Core en .NET 10 El punto de partida es la plantilla web vacía. `dotnet new web` crea un proyecto sobre el SDK `Microsoft.NET.Sdk.Web`, que ya compila componentes `.razor` sin configuración adicional. Tres paquetes resuelven el resto: [Markdig](https://github.com/xoofx/markdig) para procesar CommonMark, YamlDotNet para el front matter y `System.ServiceModel.Syndication` para el 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 ``` `Program.cs` conecta todas las piezas. El almacén de publicaciones se registra como singleton porque todas las solicitudes comparten las publicaciones ya procesadas, y el middleware de output caching se ubica antes de los endpoints para que una respuesta en caché evite por completo la ejecución del 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/"; } ``` La opción `SiteUrl` cobra importancia más adelante: los enlaces canónicos y las URL del feed se construyen a partir de la configuración y nunca a partir del encabezado `Host` de la solicitud. ## Cómo procesar publicaciones Markdown con front matter en C# Cada publicación es un archivo como `posts/output-caching-dotnet-10.md`. El nombre del archivo funciona como slug y un bloque YAML al inicio contiene los metadatos: ```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... ``` El parser separa el bloque YAML del cuerpo, deserializa los metadatos en una clase pequeña y convierte el cuerpo a HTML. Primero normaliza los saltos de línea; de lo contrario, una publicación guardada en Windows rompe la búsqueda del 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()` habilita tablas, notas al pie, listas de tareas, identificadores automáticos en los encabezados y el resto de las extensiones de Markdig que un blog técnico necesita. Por defecto, Markdig deja pasar el HTML sin procesar. Eso no es un problema cuando quien escribe es el dueño del sitio, pero cualquier Markdown aportado por usuarios (comentarios, artículos invitados) requiere `DisableHtml()` en su pipeline para evitar un XSS almacenado. ## Almacén singleton thread-safe con recarga en caliente Al arrancar, el almacén lee todos los archivos y guarda el resultado en un `FrozenDictionary` (disponible desde .NET 8), optimizado para escenarios de lectura intensiva. Cuando un archivo cambia, arma un diccionario completamente nuevo y reemplaza la referencia con una sola asignación. Los lectores nunca toman un lock: cada solicitud ve la instantánea anterior o la nueva, jamás una colección a medio construir. ```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 } } } ``` Tres detalles hacen que este código esté listo para producción. El campo `volatile` garantiza que los demás hilos lean la referencia más reciente después del intercambio. El `try/catch` conserva la última instantánea válida cuando una publicación tiene YAML mal formado, así que un error de tipeo en un archivo no deja el blog vacío. Y la llamada a `EvictByTagAsync` elimina todas las páginas en caché con la etiqueta `posts`, de modo que el contenido nuevo aparece en la siguiente solicitud y no recién cuando vence la hora de expiración. > **Observación de archivos dentro de contenedores** > > `FileSystemWatcher` depende de notificaciones del sistema operativo que no atraviesan de forma confiable los bind mounts de Docker ni las carpetas compartidas en red. En un contenedor que monta la carpeta `posts`, conviene definir la variable de entorno `DOTNET_USE_POLLING_FILE_WATCHER=true` o `PhysicalFileProvider.UsePollingFileWatcher = true`. Además, los editores guardan un archivo en varias escrituras, por lo que `Reload` puede dispararse dos o tres veces por guardado: algo inofensivo en este caso, ya que cada ejecución produce la misma instantánea. ## Endpoints Minimal API con grupos de rutas y TypedResults Las páginas públicas se agrupan bajo `/blog` con `MapGroup`, lo que aplica la política de output caching y su etiqueta a todos los endpoints desde un único lugar. Los handlers devuelven `RazorComponentResult`, disponible desde .NET 8, que renderiza un componente Razor como respuesta HTTP completa sin necesidad de MVC, Razor Pages ni el router de 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); ``` El tipo de retorno `Results` es lo que distingue a `TypedResults` de los antiguos helpers `Results`. El compilador verifica que el handler solo devuelva los resultados declarados, el generador de OpenAPI lee ambos códigos de estado desde la firma y una prueba unitaria puede comprobar `result.Result is NotFound` sin levantar un servidor. El endpoint JSON queda fuera del grupo `/blog` para que su URL no choque con los slugs de las publicaciones. La página de cada publicación es un componente Razor convencional. `MarkupString` le indica a Razor que emita la salida de Markdig como HTML en lugar de codificarla, y la URL canónica sale 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` sigue el mismo patrón con un parámetro `Posts` y un bucle sobre títulos y resúmenes. El objeto anónimo que recibe `RazorComponentResult` asigna los nombres de sus propiedades a los parámetros del componente, por eso `new { Post = post }` tiene que coincidir exactamente con el parámetro `Post`. ## Output caching para las páginas de un blog en ASP.NET Core El output caching, incorporado en ASP.NET Core 7, guarda la respuesta completa en el servidor y la reproduce sin ejecutar el handler ni volver a renderizar el componente. No hay que confundirlo con el middleware de response caching, más antiguo, que sigue la semántica HTTP de `Cache-Control` y permite que un cliente esquive la caché con un encabezado `no-cache`. La [documentación de output caching en Microsoft Learn](https://learn.microsoft.com/en-us/aspnet/core/performance/caching/output) detalla las reglas por defecto: solo se guardan las solicitudes `GET` y `HEAD` que responden 200, y se omiten las respuestas que establecen cookies o que provienen de solicitudes autenticadas. Las etiquetas son lo que vuelve al output caching ideal para un sitio de contenido. Todos los endpoints del blog llevan la etiqueta `posts`, y el almacén desaloja esa etiqueta después de cada recarga. La política base de una hora funciona apenas como red de seguridad; en la práctica, las páginas permanecen en caché hasta que el contenido cambia. En un despliegue con varias instancias, la caché en memoria es independiente por proceso: desalojar en una instancia deja a las demás sirviendo contenido desactualizado. ASP.NET Core ofrece un almacenamiento respaldado por Redis mediante el paquete `Microsoft.AspNetCore.OutputCaching.StackExchangeRedis` y el método `AddStackExchangeRedisOutputCache`, que comparte entradas y desalojos entre instancias. Una única instancia pequeña no lo necesita. ## Generar un feed RSS desde C# con SyndicationFeed El público técnico sigue suscribiéndose mediante lectores de feeds, y los agregadores detectan las publicaciones nuevas en el feed antes que en el sitemap. `SyndicationFeed` y `Rss20FeedFormatter` generan un feed que cumple la [especificación RSS 2.0](https://www.rssboard.org/rss-specification) sin escribir XML a mano. ```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; } } ``` Construir las URL absolutas a partir de `BlogOptions.SiteUrl` en lugar de `HttpContext.Request.Host` cierra la puerta a una inyección de encabezado Host: sin esa precaución, una sola solicitud con un valor `Host` falsificado quedaría en caché y se serviría a todos los suscriptores con enlaces hacia otro dominio. El argumento `UTF8Encoding(false)` quita la marca de orden de bytes (BOM), que algunos lectores de feeds rechazan. ## Despliegue del blog técnico en C# y los límites de Native AOT `dotnet publish -c Release` genera un build dependiente del framework que corre en cualquier host con el runtime de .NET 10. Desde .NET 8, el SDK también crea imágenes de contenedor sin Dockerfile: `dotnet publish -c Release /t:PublishContainer` produce una imagen basada en la imagen oficial del runtime de ASP.NET Core. La carpeta `posts` puede incluirse dentro de la imagen (cada cambio de contenido requiere un nuevo despliegue) o montarse como volumen (el observador de archivos detecta los cambios). Native AOT resulta atractivo por el tiempo de arranque y el consumo de memoria, pero este proyecto no es un buen candidato. La [tabla de compatibilidad de Native AOT en ASP.NET Core](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/native-aot) marca las Minimal APIs con soporte parcial y Blazor Server como no soportado, y el deserializador por defecto de YamlDotNet depende de reflexión. Un blog sirve páginas en caché desde un proceso de larga duración, así que el tiempo de arranque casi no pesa. Pasar a AOT implicaría reemplazar los componentes Razor por plantillas de texto y el YAML por un front matter en JSON con source generators, a cambio de una ganancia mínima. ## Preguntas de entrevista .NET que este proyecto ayuda a preparar Cada parte del motor se corresponde con una pregunta habitual en entrevistas de ASP.NET Core. Las [preguntas de entrevista de .NET en SharpSkill](https://sharpskill.dev/es/technologies/dotnet) las cubren a fondo, y el [módulo de Minimal APIs](https://sharpskill.dev/es/technologies/dotnet/preguntas-entrevista/minimal-apis) se enfoca en la parte de endpoints. **"¿Un servicio singleton es seguro si muchas solicitudes lo leen al mismo tiempo?"** Solo si su estado es inmutable o está sincronizado. El almacén de este artículo usa una instantánea inmutable y un intercambio de referencia `volatile`, de modo que los lectores nunca bloquean y las escrituras nunca frenan a los lectores. La trampa clásica es un singleton con una `List` que se modifica durante la recarga y que, bajo carga, lanza `InvalidOperationException` en medio de una enumeración. El [módulo de inyección de dependencias](https://sharpskill.dev/es/technologies/dotnet/preguntas-entrevista/dependency-injection) también aborda el problema de la dependencia cautiva: un singleton que recibe un servicio scoped, como un `DbContext`, lo mantiene vivo durante toda la vida de la aplicación. **"¿Cuál es la diferencia entre output caching y response caching?"** El output caching lo controla el servidor, admite etiquetas y desalojo, e ignora los encabezados de caché del cliente. El response caching sigue la semántica HTTP y funciona sobre todo como una indicación para proxies y navegadores. **"¿Por qué devolver `TypedResults` en lugar de `Results`?"** Los tipos de resultado concretos aportan verificación en tiempo de compilación de los resultados posibles, metadatos OpenAPI automáticos y handlers que se prueban como métodos comunes. La comparación detallada con los controladores está en el artículo sobre [arquitectura y rendimiento de las Minimal APIs](https://sharpskill.dev/es/blog/dotnet/aspnet-core-minimal-apis-architecture-performance-interview). **"¿Dónde importa el orden de los middlewares en esta aplicación?"** `UseOutputCache` debe registrarse antes de los endpoints que pone en caché, y después de `UseCors` cuando CORS está habilitado. Quien además sabe explicar por qué la política por defecto nunca guarda solicitudes autenticadas, y qué debería verificar una `IOutputCachePolicy` personalizada antes de hacerlo, demuestra que entiende el pipeline y no que memorizó un orden. ## Blog en C# con ASP.NET Core: puntos clave - Arrancar con `dotnet new web` sobre .NET 10 y sumar únicamente Markdig, YamlDotNet y `System.ServiceModel.Syndication`; un blog técnico no necesita CMS ni base de datos. - Procesar las publicaciones una sola vez en un `FrozenDictionary` inmutable y reemplazar la instantánea completa en cada recarga, para que los lectores nunca bloqueen y un archivo roto nunca vacíe el sitio. - Renderizar el HTML con `RazorComponentResult` desde los handlers de Minimal API y declarar tipos de retorno `Results` para que OpenAPI y las pruebas unitarias vean todos los resultados. - Poner cada endpoint de contenido detrás de output caching con una etiqueta compartida y llamar a `EvictByTagAsync` tras cada recarga, en lugar de depender de expiraciones cortas. - Construir las URL canónicas y las del feed desde la configuración, nunca desde el encabezado `Host`, y activar `DisableHtml()` en cualquier pipeline que renderice Markdown de usuarios. - Definir `DOTNET_USE_POLLING_FILE_WATCHER=true` cuando la carpeta de publicaciones se monta en un contenedor. - Aprovechar el proyecto como práctica para entrevistas: estar en condiciones de explicar en voz alta la seguridad del singleton entre hilos, la elección de caché y el orden de los middlewares. --- Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack. HTML version of this page: https://sharpskill.dev/es/blog/dotnet/csharp-blog-aspnet-core-minimal-apis-2026