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.

Blog en C# construido con Minimal APIs de ASP.NET Core en .NET 10

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.

AspectoGenerador de sitios estáticosBlog con Minimal APIs de ASP.NET Core
Formato del contenidoMarkdown + front matterMarkdown + front matter
Momento del renderizadoDurante el buildEn la primera solicitud, luego desde caché
Lógica personalizadaPlugins, plantillasEndpoints en C#
HostingCualquier hosting estático o CDNContenedor, App Service, cualquier VPS
Actualización del contenidoNuevo build y despliegueEl 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 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.

Program.cscsharp
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/";
}

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 ---.

Posts/PostParser.cscsharp
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() 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.

Posts/PostStore.cscsharp
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
        }
    }
}

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<T>, disponible desde .NET 8, que renderiza un componente Razor como respuesta HTTP completa sin necesidad de MVC, Razor Pages ni el router de Blazor.

Endpoints/BlogEndpoints.cscsharp
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);

El tipo de retorno Results<T1, T2> 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<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 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.

¿Listo para aprobar tus entrevistas de .NET?

Practica con nuestros simuladores interactivos, flashcards y tests técnicos.

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 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 sin escribir XML a mano.

Endpoints/FeedEndpoints.cscsharp
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;
    }
}

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 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 las cubren a fondo, y el módulo de 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<T> 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 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.

"¿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<T> desde los handlers de Minimal API y declarar tipos de retorno Results<T1, T2> 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.

¡Empieza a practicar!

Pon a prueba tu conocimiento con nuestros simuladores de entrevista y tests técnicos.

Reto diario

¿Sabrías detectar el bug en .NET?

Un fragmento real, un bug oculto, un intento al día. Sin cuenta para probar.

Anthony Fillion-Maillet

Escrito por

Anthony Fillion-Maillet

Fundador de SharpSkill

Desarrollador fullstack desde hace más de 10 años. Dirige SharpSkill y responde por todo lo que se publica aquí.

Actualizado el 17 de noviembre de 2026

Etiquetas

#dotnet
#csharp
#aspnet-core
#minimal-apis
#output-caching
#tutorial

Compartir

Artículos relacionados