.NET 11 en Azure Functions: qué cambia y cómo actualizar
.NET 11 ya está disponible en Azure Functions con el modelo aislado y un SDK de proyecto más simple. Qué cambia en el .csproj, quién puede actualizar y cómo.
Autor del blog
CEO y fundador de Nakanaba. Desarrollador de software y fundador de Nakanaba. Lidera la arquitectura de Vitrin: backend en .NET, aplicaciones en Angular y .NET MAUI, SQL Server y servicios en Cloudflare.
.NET 11 ya está disponible en Azure Functions con el modelo aislado y un SDK de proyecto más simple. Qué cambia en el .csproj, quién puede actualizar y cómo.
Agent Framework 1.0 hace fácil crear agentes de IA en C#. Qué es un agente, cómo darle herramientas, qué riesgos trae y cuándo basta una sola llamada.
C# 15 trae union types con switch exhaustivo. Cómo se declaran, qué genera el compilador, cuánto cuestan y por qué conviene esperar para producción.
Aspire ordena el arranque local de varios servicios, sus conexiones y su telemetría. Qué hace el AppHost, qué no hace y en qué proyectos sobra.
El mismo Where puede filtrar en SQL Server o en la memoria de tu API. Cómo distinguir IQueryable de IEnumerable en EF Core y dónde cortar la consulta.
Antes de cambiar código, mide. Una guía en orden: dónde se va el tiempo en una API ASP.NET Core, qué revisar primero y qué optimizaciones valen la pena.
Serverless promete pagar solo por uso y olvidar los servidores. En software empresarial también hay que sumar arranques en frío, límites y costos variables.
Los microservicios se presentan como el paso natural tras el monolito, pero muchas aplicaciones no tienen el problema que justifica ese salto. Cómo decidir.
Con 10 usuarios todo funciona; con 2.000 simultáneos aparecen pools agotados, datos pisados y bloqueos. Decisiones en .NET para soportar concurrencia real.
Los eventos desacoplan servicios y absorben picos, pero esconden el flujo y complican la consistencia. Eventos en .NET, patrón outbox y cuándo evitarlos.
Módulos con límites claros dentro de una sola aplicación: cómo separarlos en .NET, cómo se comunican y cómo proteger sus datos y hacer cumplir los límites.
INT es compacto y secuencial; GUID se genera en cualquier parte. Su efecto en índices y fragmentación, y por qué UUID v7 no basta en SQL Server.
Un BackgroundService resuelve tareas periódicas y colas internas sin infraestructura extra, pero tiene límites. Cómo hacerlo bien y cuándo ir más allá.
Una cola absorbe picos y fallos temporales; un topic reparte el mismo evento a varios consumidores. Cuándo usar cada uno en Service Bus y qué cuidar.
Guía práctica en .NET con un solo ejemplo: carpetas por funcionalidad, un caso de uso completo, cuándo abstraer, cómo probarlo y cuándo sumar estructura.
Un modelo normalizado evita inconsistencias; uno desnormalizado responde más rápido. Cuándo duplicar datos en SQL Server y cómo hacerlo con control.
Un cliente con un bucle mal escrito puede tumbar la API para todos. Rate limiting en ASP.NET Core: algoritmos, límites por cliente y errores con proxies.
Azure Functions parece más barato que una API en App Service hasta que aparecen arranques en frío, límites de tiempo y lógica repartida. Cómo decidir.
Interfaces con una sola implementación, capas que solo reenvían y genéricos que nadie entiende. Cuándo una abstracción ayuda y cuándo solo estorba.
La caché acelera todo hasta que muestra datos viejos o se desincroniza. Cuándo usar IMemoryCache, IDistributedCache o HybridCache y cómo invalidar.
El error 1205 aparece de vez en cuando y nadie logra reproducirlo. Cómo encontrar y leer el grafo del deadlock en SQL Server y corregir la causa real.
MediatR es casi estándar en .NET, pero agrega una indirección en cada llamada. Qué aporta, qué cuesta, su nueva licencia y qué alternativas más simples hay.
Un health check que siempre responde 200 no sirve, y uno que revisa todo puede tumbar la aplicación. Cómo diseñar health checks útiles en ASP.NET Core.
READ COMMITTED, SNAPSHOT, SERIALIZABLE y el famoso NOLOCK: qué anomalías evita cada nivel en SQL Server, cuánto bloquea y cuál conviene en cada caso.
CQRS no es MediatR ni dos bases de datos. Qué resuelve separar lecturas y escrituras, sus tres niveles de adopción y cuándo solo agrega complejidad.
Logs que no sirven para diagnosticar, que cuestan más que el servidor o que guardan contraseñas. Qué registrar en .NET, con qué nivel y en qué formato.
Transacciones que no hacen rollback, que duran minutos o que llaman a una API en medio: los errores más frecuentes con transacciones en SQL Server y .NET.
Un try/catch por endpoint no escala y uno mal hecho filtra detalles internos. Errores centralizados con IExceptionHandler y ProblemDetails, sin perder logs.
SOLID se enseña como cinco reglas y se aplica como cinco excusas para crear interfaces. Qué principios aportan valor a diario y cuáles se malinterpretan.
Tres formas de interceptar una petición en ASP.NET Core que se confunden a menudo: qué ve cada una, en qué orden se ejecutan y cuál elegir en cada caso.
DbContext ya es un repositorio y una unidad de trabajo. Cuándo un repositorio sobre EF Core aporta valor, cuándo es una capa vacía y qué alternativas hay.
Ya encontraste la consulta lenta; ahora corrígela desde EF Core: índices en el modelo, tipos correctos, consultas compiladas, SQL directo y pooling.
Antes de optimizar hay que saber qué consulta optimizar. Query Store, DMVs y Extended Events para encontrar lo que más cuesta en tu SQL Server de producción.
Clean Architecture resuelve problemas reales, pero aplicada sin contexto multiplica capas y archivos. Cuándo ayuda, cuándo sobra y qué hacer en medio.
Devolver la entidad de EF Core en la API ahorra un archivo hoy y trae overposting, ciclos y contratos frágiles mañana. Cuándo usar DTOs y cómo mapear.
Una consulta para la lista y otra por cada elemento. Por qué el N+1 se escapa en desarrollo y cómo detectarlo y resolverlo en EF Core y en Dapper.
Una API se diseña en semanas y se mantiene durante años. Rutas, errores, paginación, versiones e idempotencia para no romper a los clientes después.
AsNoTracking acelera las lecturas, pero ponerlo en todas partes rompe actualizaciones de forma silenciosa. Qué hace realmente el change tracker y cómo decidir.
El plan de ejecución dice por qué una consulta es lenta si sabes dónde mirar: qué operadores revisar primero, qué advertencias importan y cuáles ignorar.
Con pocos datos EF Core es rápido. Con millones de filas aparecen consultas que traen todo, explosiones cartesianas y paginaciones lentas. Cómo corregirlos.
Dependencias cautivas, DbContext compartido entre hilos y constructores con diez parámetros: errores de inyección de dependencias que fallan en producción.
Qué cambia entre un índice clustered y uno nonclustered, cómo elegir columnas e INCLUDE con ejemplos, y por qué más índices no siempre aceleran la aplicación.
La API es asíncrona de punta a punta y aun así se queda sin hilos bajo carga. Los errores con async/await que más vemos en producción y cómo corregirlos.
La consulta es la misma de siempre y de un día para otro tarda segundos. Las causas más comunes en SQL Server y cómo distinguir una de otra antes de tocar nada.