Hago una ligera interrupción de mis vacaciones blogueras para compartir con todos vosotros que, por decimocuarto año consecutivo, he sido reconocido por Microsoft como Most Valuable Professional (MVP) en la categoría .NET ¡¡Hurra!! 😀
Aunque ya debería estar acostumbrado, siempre es un honor y un privilegio recibir este galardón que, de alguna forma, reconoce mis aportaciones a la comunidad de desarrolladores, esa comunidad con la que sigo estando en deuda por lo que he recibido de ella durante tanto tiempo.
Muchas gracias al equipo de Microsoft que hace esto posible, con nuestra querida Cristina González a la cabeza, por la dedicación y esfuerzo que ponen en este programa. Muchas gracias también a todos los compañeros MVPs que hacen que esta comunidad sea tan especial.
Y, por supuesto, agradeceros a todos vosotros, queridos amigos y amigas, por seguir ahí, porque vuestras visitas, lecturas y comentarios son los que me animan a seguir compartiendo experiencias y conocimientos en este pequeño rinconcito de la web.
¡Nos vemos a la vuelta!
Publicado en Variable not found.
Foto: Atardecer en la playa en Costa Ballena, por Eugenio Sánchez. Original: foro.ojodigital.com
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Inyección de dependencias en ASP.NET Core(actualizado)
José M. Aguilar - Añadir al routing de Blazor páginas definidas en otros proyectos o ensamblados
José M. Aguilar
.NET Core / .NET
- Flexible PDF Reporting in .NET Using Razor Views
Milan Jovanović - MemoryCache in C#: A Practical Guide
Metalama Team - Local Functions vs Lambda Expressions in C#
Bozo Spoljaric - Creating hashes in .NET
Damien Bowden - How to find a client's geolocation in .NET with IP lookup
David Grace - Publish a console app as a single executable
Bart Wullems - How to output a SARIF file from a .NET project
Gérald Barré - An immutable priority collection
Mark Seemann - Exploring the generated code: the spread element
Andrew Lock - Readonly, Immutable, and Frozen Collections in .NET
NDepend Team - How to Read appsettings.json in a .NET Console Application
Matheus Dasuke - Scan HTML faster with SIMD instructions: .NET/C# Edition
Daniel Lemire
Cuando en un bucle for necesitamos más de una variable de control, lo habitual es inicializarlas fuera del bucle y luego usarlas en su interior, por ejemplo, como en el siguiente código:
int j = 0;
for (int i = 0; i < 10 && j < 100; i++)
{
Console.WriteLine($"i = {i}, j = {j}");
j+= 10;
}
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Miembros de inicialización obligatoria en C#11 (required members)
José M. Aguilar - Tag helpers en ASP.NET Core MVC: Introducción
José M. Aguilar
.NET Core / .NET
- Primary constructors
Mark Downie - Proxy Design Pattern in C#
Ahsan Ullah - How to Generate Large Datasets in .NET for Excel With OpenXML
Artem Rudiakov - Exploring the generated code: T[], Span<T>, and Immutable collections
Andrew Lock - When to create a new .csproj?
NDepend Team - ReadOnlySet<T> in .NET 9
Steven Giesel - C# Tip: Path.Combine and Path.Join are similar but way different.
Davide Bellone
Blazor ha venido en ASP.NET Core 8 cargadito de novedades, aunque probablemente la más destacable sea la introducción de las Blazor Web Apps como modelo de proyecto que unifica los distintos modos de renderizado de componentes. Aunque se trata de un cambio positivo, la realidad es que ha complicado algunas cosas que antes, con unos modelos de proyecto más sencillos, eran más fáciles de implementar.
Un ejemplo claro lo tenemos en las páginas de error 404 (not found): con este nuevo modelo unificado no hay una fórmula trivial o integrada de serie en el framework para implementar esta funcionalidad, tan habitual en nuestras aplicaciones.
En este post vamos a ver un posible enfoque para conseguir que si un usuario introduce una ruta inexistente en el navegador o bien pulsa un enlace interno que no exista, podamos mostrarle una página de error 404 totalmente personalizada, implementada como componente Blazor, e integrada en nuestra Blazor Web App.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¡No uses ToLower() o ToUpper() para comparar cadenas en C#!
José M. Aguilar - El archivo _ViewImports en ASP.NET Core MVC
José M. Aguilar
.NET Core / .NET
- Refactor your code with default lambda parameters
David Pine - Cancellation Tokens in C#
Rasheed K Mozaffar - When does the try, catch and finally blocks run in C#?
David Grace - Collection Performance: Introducing FrozenSet in .NET 8: Benefits and Benchmark PerformanceCollection Performance
David McCarter - Privacy and security improvements in .NET modernization tooling
Mike Rousos - How to Cast an Int to an Enum in C#
Chris Pietschmann - Exploring the generated code: List<T> and fallback cases
Andrew Lock - How to Ignore a Property in AutoMapper
Żaneta Borowska - C#: Read Text and JSON File Contents into Variable in Memory
Chris Pietschmann - How to Use FakeLogger to Test Logging Code in .NET
Osman Sokuoglu - How to Use C# to Properly Follow OAuth Authentication Flows
Peter Smulovics - C# 13 params collections
NDepend Team - What Does the null! Statement Do?
Januarius Njoku - Announcing Third Party API and Package Map Support for .NET Upgrade Assistant
Marco Goertz - The Best Way To Map Objects in .Net in 2024
Anton Martyniuk
Llevamos ya varias entregas de la serie C# bizarro, donde, como sabéis, ponemos a prueba nuestros conocimientos de C# llevando al extremo el uso de algunas de sus características, lo que de paso nos ayuda a conocer mejor aún el lenguaje.
Hoy vamos a proponer un nuevo reto, mostrando un comportamiento que quizás muchos conozcáis, pero seguro que otros nunca habéis tenido ocasión de verlo. A ver qué tal se os da ;)
Observad atentamente esta sencilla aplicación de consola:
int i = 1;
int accum = 0;
while (i <= 5)
{
accum += i;
Debug.WriteLine($"Adding {i++}, Accumulated = {accum}");
}
Console.WriteLine($"Total: {accum}");
A la vista del código, las preguntas son dos: ¿Qué resultado obtenemos al ejecutar la aplicación? ¿Será siempre así?
Obviamente, tiene algo de truco, pero si lo pensáis un poco seguro que podéis responder a las preguntas. Y si no, pulsad aquí para ver la solución; 👇👇
En principio, lo lógico es pensar que deberíamos ver en el canal de depuración (la ventana Output>Debug en Visual Studio) el valor actual y el total acumulado en cada iteración, lo que nos permite ir siguiendo en detalle el funcionamiento interno:
Adding 1, Accumulated = 1
Adding 2, Accumulated = 3
Adding 3, Accumulated = 6
Adding 4, Accumulated = 10
Adding 5, Accumulated = 15
Finalmente, se mostrará por consola el valor definitivo:
Total: 15
Esto será justamente lo que obtengamos si copiamos el código en Visual Studio y lo ejecutamos pulsando F5 o el botón correspondiente del IDE. Hasta ahí, perfecto ;)
Sin embargo, este código tiene una trampa oculta. Si desde Visual Studio cambiamos el modo de compilación a "Release" y lo lanzamos, o bien si lanzamos directamente el ejecutable que encontraremos en la carpeta bin/Release/net8.0 (o la versión de .NET que uses, da igual), veremos que la aplicación no se detiene nunca (?!)
El motivo de este extraño comportamiento lo explicamos hace ya bastantes años por aquí, en el post métodos condicionales en C#.
Estos métodos, presentes desde las primeras versiones de .NET (pre-Core), se decoran con el atributo [Conditional] para hacer que éstos y todas las referencias a los mismos sean eliminadas del ensamblado resultante de la compilación si no existe una constante de compilación determinada.
De hecho, si acudimos al código fuente de la clase estática Debug, veremos que su método WriteLine() está definido de la siguiente manera:
public static partial class Debug
{
...
[Conditional("DEBUG")]
public static void WriteLine(string? message)
=> s_provider.WriteLine(message);
}
Cuando compilamos en modo depuración, la constante DEBUG estará definida, por lo que este método podrá ser invocado con normalidad y todo funcionará bien. Sin embargo, si compilamos en Release o cualquier otra configuración que no incluya la constante, este método desaparecerá del ensamblado, junto con las referencias que lo utilicen.
Es decir, si usamos el modo Release, el código que hemos escrito antes quedará tras la compilación como el siguiente:
int i = 1;
int accum = 0;
while (i <= 5)
{
accum += i;
// La siguiente llamada será eliminada en compilación:
// Debug.WriteLine($"Adding {i++}, Accumulated = {accum}");
}
Console.WriteLine($"Total: {accum}");
Fijaos que, al eliminar la llamada, con ella desaparecerá también la expresión de autoincremento del índice del bucle i++, por lo que nunca se alcanzará la condición de salida y quedará iterando de forma indefinida.
Bonito, ¿eh? ;)
Publicado en Variable not found.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- El nuevo modificador "file" de C# 11: tipos visibles exclusivamente en el archivo en el que se definen
José M. Aguilar - La carpeta wwwroot en ASP.NET Core
José M. Aguilar
.NET Core / .NET
- Retrying Failed HttpClient Requests in .NET Using Polly
Gergő Vándor - Does an HttpClient await the Header and the body?
Steven Giesel - Frozen Collections in .NET 8
Sharmila Subbiah - How to Use the LINQ ToDictionary Method in C#
Januarius Njoku - Introducing collection expressions in C#12
Andrew Lock - Differences Between Span and Memory in C#
Bozo Spoljaric - 5 Practical Ways to Add Polly to Your C# Application
Metalama Team - C# Array and List Fastest Loop in 2024
NDepend Team - Weak Events in C#
Satya Prakash - What’s New in C# 13 for Developers?
Vinoth Kumar Sundara Moorthy - C# Version String Formatting
Rick Strahl - Weak Events in C#
Satya Prakash - Creating Custom Attributes in C#
Anton Martyniuk
Este post pertenece a una serie de tres partes donde estamos viendo cómo renderizar componentes Blazor en el interior de vistas MVC de ASP.NET Core. Hasta ahora, hemos visto cómo renderizar desde vistas MVC componentes Blazor usando los siguientes modos de renderización:
En esta entrega final veremos cómo renderizar componentes Blazor ejecutados por completo en el lado cliente (WebAssembly).
Este post pertenece a una serie de tres partes donde estamos viendo cómo renderizar componentes Blazor en vistas MVC de ASP.NET Core.
En la primera parte de la serie vimos cómo renderizar componentes estáticos (SSR) en servidor, y ahora vamos a centrarnos en hacerlo con componentes con interactividad también en el lado servidor (Blazor Server), dejando para una siguiente entrega los componentes interactivos ejecutados por completo en cliente con WebAssembly.
Hace no demasiado, mientras analizábamos la posibilidad de que Blazor acabara en algún momento sustituyendo a MVC como tecnología "por defecto" para el desarrollo de aplicaciones web en .NET, comentaba que técnicamente no hay nada que impida a ambas tecnologías convivir pacíficamente en una misma aplicación. De hecho, están diseñadas para trabajar juntas :)
En este sentido, uno de los escenarios soportados es la inserción de componentes Blazor en el interior de vistas de una aplicación ASP.NET Core MVC. Esto puede ser muy interesante, entre otros casos, si queremos ir introduciendo Blazor progresivamente en aplicaciones MVC existentes o para reutilizar componentes entre distintos proyectos.
En esta miniserie vamos a ver cómo conseguirlo con los distintos modos de renderizado de Blazor, porque cada uno tiene sus particularidades:
- Renderizado estático (SSR), lo que veremos en este post.
- Renderizado en servidor (Blazor Server), en un futuro post.
- Renderizado en cliente (Blazor WebAssembly), también en un artículo posterior.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¿Cómo se llama el operador "-->" de C#?
José M. Aguilar - ¿Se pueden lanzar dos aplicaciones ASP.NET Core desde el mismo host?
José M. Aguilar
.NET Core / .NET
- Top 10 C# Recent Improvements
NDepend Team - How to Print a 2D Array to the Console in C#
Ellie Zubrowski - How to use C# async/await for API calls & to stop blocking
David Grace - Refactor your code using alias any type
David Pine - MSTest 3.4 is here with WinUI support and new analyzers!
Amaury Levé & Marco Rossignoli - State Machines, Light Switches, and Space Travel with Stateless and .NET 8
Khalid Abuhakmeh - Fast and Compact Structured Logging in C# Using String Interpolation
Metalama team - Automate your .NET SDK updates for consistent and reproducible builds with global.json and Renovate
Anthony Simmon - StringBuilders magic for very large strings
Steven Giesel - .NET Core–Check if console app is running with administrative privileges
Bart Wullems - New And Proposed Changes For C# 13
Peter Ritchie - Bouncy Castle Cryptography Library for .NET
Alvaro Montoya - Async Await Mastery: Handling Exceptions Like a Pro in C#
Kons Fedorov - IDisposable: What Your Mother Never Told You About Resource Deallocation
Stephen Cleary - How To Write Elegant Code with C# Switch Expressions
Anton Martyniuk
El espacio de nombres System.IO de .NET proporciona clases para trabajar con archivos y directorios, algo que, a priori, no tendría demasiado sentido en componentes Blazor WebAssembly, ya que éstos se ejecutan en el navegador del cliente y, por motivos de seguridad, no tienen acceso al sistema de archivos del servidor, ni tampoco a los archivos del dispositivo del usuario que está ejecutando la aplicación.
El primero de los casos es salvable: si desde un componente Blazor WebAssembly quisiéramos leer o escribir archivos en el servidor, podríamos hacerlo a través de una API que, ejecutada en el servidor, tuviera acceso a este tipo de recursos.
Sin embargo, técnicamente no hay forma de acceder a los archivos locales del usuario, dado que los componentes Blazor WebAssembly se ejecutan en el sandbox del navegador, que impide acceder a los recursos del sistema.
Pues bien, a pesar de ello, y de forma totalmente contraria a lo que podríamos intuir, desde Blazor WebAssembly sí que se pueden usar los componentes de System.IO (bueno, o muchos de ellos) para leer o escribir archivos y directorios, aunque con algunas peculiaridades que veremos a continuación.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Personalizar restricciones de ruta en línea en ASP.NET Core
José M. Aguilar - Inyección de dependencias en filtros ASP.NET Core MVC
José M. Aguilar
.NET Core / .NET
- ¿.NET 7 no soportado, pero .NET 6 sí? - Cómo funcionan las versiones en .NET
José Manuel Alarcón - .NET Workloads 101
Miguel Angel Martín Hernández - Introducing links to source code for .NET API Docs
Min Huang - How to test a Roslyn analyzer
Gérald Barré - How to Compare Two Dictionaries in C#
Januarius Njoku - Blocking primary constructor member capture using a Roslyn Analyzer
Andrew Lock - Fastest Ways to Perform Base 10 Conversions in C#
Martin Chege - What's New in C# 13: Enhanced Params, Performance Boosts, and New Extension Types
Almir Vuk - .NET Core Configuration in .NET 8
Dhananjeyan Balaretnaraja - Introduction to the StronglyTypedId Package in .NET
Caleb Okechukwu - Running a Hosted Service in a Console Application
Bryan Hogan - Cancel WhenAny - linked CancellationTokenSource
Steven Giesel - Metadata Consulting [dot] ca: C# dotNet The fastest way to check if a file is a PDF file or not
Metadata Consulting - Lookup in C#
Januarius Njoku - ASP.NET Core Basics: Getting Started with GraphQL
Assis Zang - Using thread-safe classes doesn’t make your code thread-safe
Henrique Dalcin Dalmas - How to Set the Exit Code for a Console Application in .NET
Stefan Cruz
Me da la impresión de que el operador with de C# no es demasiado conocido, y creo que vale la pena echarle un vistazo porque puede resultarnos útil en nuestro día a día.
Introducido con C# 9, allá por 2020, las expresiones with proporcionan una forma sencilla de crear nuevas instancias de objetos "copiando" las propiedades de otro objeto, pero con la posibilidad de modificar algunas de ellas sobre la marcha. Esto, aunque puede usarse con varios tipos de objeto, es especialmente interesante cuando estamos trabajando con componentes inmutables, como son los records, porque la única posibilidad que tenemos de alterarlos es creando copias con las modificaciones que necesitemos.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Los diez mandamientos del egoless programming
José M. Aguilar - Cadenas de texto con ayudas sintácticas en .NET 7 (y anteriores)
José M. Aguilar
.NET Core / .NET
- .NET Announcements & Updates from Microsoft Build 2024
.NET Team - Announcing NuGet 6.10
The NuGet Team - How to use HttpClient correctly to avoid socket exceptions
David Grace - .NET 7 Support Just Ended, Here's How to Upgrade to .NET 8
David Ramel - MemoryCache, DistributedCache and HybridCache
Steven Giesel - Roslyn analyzers: How to
Gérald Barré - How to Deal With NullReferenceException? Object reference not set to an instance of an object.
Metalama team - Thoughts about primary constructors: 3 pros and 5 cons
Andrew Lock
Revisando código ajeno, me he encontrado con un ejemplo de uso del operador null coalescing assignment de C# que me ha parecido muy elegante y quería compartirlo con vosotros.
Como recordaréis, este operador, introducido en C# 8, es una fórmula muy concisa para asignar un valor a una variable si ésta previamente es null, una mezcla entre el operador de asignación y el null coalescing operator que disfrutamos desde C# 2:
// C# "clásico":
var x = GetSomething();
...
if(x == null) {
x = GetSomethingElse();
}
// Usando null coalescing operator (C# 2)
var x = GetSomething();
...
x = x ?? GetSomethingElse();
// Usando null coalescing assignment (C# 8)
var x = GetSomething();
...
x ??= GetSomethingElse();
Pero, además, al igual que otras asignaciones, este operador retorna el valor asignado, lo que nos permite encadenar asignaciones y realizar operaciones adicionales en la misma línea.
Por ejemplo, observad el siguiente código:
Console.WriteLine(y ??= "Hello, World!");
Aquí, básicamente lo que hacemos es asignar el valor "Hello, World!" a la variable si ésta contiene un nulo, y luego imprimirlo por consola. Y si no es nulo, simplemente se imprime su valor actual.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Cómo contar y enumerar los items almacenados en un objeto MemoryCache en .NET 6
José M. Aguilar - Interpolación de cadenas en C# 6, a fondo
José M. Aguilar
.NET Core / .NET
- .NET: Eligiendo el framework de Interfaz de Usuario más adecuado para crear aplicaciones de escritorio
José Manuel Alarcón - Read and Write Azure Blob Storage with C#
Chris Pietschmann - What’s new in Orleans 8 for Scalable Distributed Applications
Mike Kistler - C# .NET 8 — MediatR Pipelines
Gabriele Tronchin - How to Find the Latitude and Longitude of a Location in C#
Ellie Zubrowski - An introduction to primary constructors in C#12
Andrew Lock - Mastering Exception Handling in C#: A Comprehensive Guide
Anton Martyniuk - Modeling: Date vs. DateTime
Oren Eini - How to avoid conflicts when testing your dotnet templates locally
Gérald Barré - Scheduled Message Delivery with Wolverine
Jeremy D. Miller - The .NET Generic Math Library
NDepend Team - How to Generate a Random Color Name in C#
Ellie Zubrowski - Collection Performance: Exercise Caution When Using Take() with a Basic Count
David McCarter
Cuando trabajamos con diccionarios en .NET, es muy común comprobar si existe un elemento con una clave determinada antes de obtenerlo para evitar una excepción KeyNotFoundException:
var numbers = new Dictionary<int, string>()
{
[1] = "One",
[2] = "Two",
[3] = "Three"
};
// Aseguramos que el elemento existe antes de obtenerlo
if (numbers.ContainsKey(3))
{
Console.WriteLine(numbers[3]);
}
Sin embargo, esta comprobación tiene coste. Es decir, aunque el acceso a los diccionarios sea muy rápido -O(1)-, no quiere decir que no consuma tiempo, por lo que es interesante conocer alternativas más eficientes para estos escenarios.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Cómo modificar la reason phrase en una respuesta HTTP de ASP.NET Core
José M. Aguilar - 101 citas célebres más del mundo de la informática (¡505 ya!)
José M. Aguilar
.NET Core / .NET
- C#: How to Enumerate over Enum values and names
Chris Pietschmann - .NET Core - View outdated packages
Bart Wullems - .NET 8 — Frozen Collections
Henrique Siebert Domareski - 7 Most Common Mistakes in C# Programming
Konstantin Fedorov - How to check if a DLL and an exe is a .NET assembly
Gérald Barré - Serialization and Deserialization with YamlDotNet
Muhammad Afzal Qureshi - C# Discriminated Union: What’s Driving the C# Community’s Inquiries?
NDepend Team - String Performance: Checking for a Character
David McCarter - Refactor your code with C# collection expressions
David Pine - Enforce architectural constrains using NetArchTest
Dennis Frühauff - .NET 9 LINQ Performance Edition
Steven Giesel - General Performance Tip: Type Conversion
David McCarter - Generate QR Codes With QRCoder in .NET
Ryan Miranda - Fast Search and Replace in Large Number of Files: A Practical Guide
Brian C Hart - Support Corner: Dotfuscator and Strong Named Assemblies
Ben Nettleton
Buah, siempre se dice que el tiempo pasa volando, pero es que es verdad. Parece que fue ayer cuando decidí comenzar a escribir en este blog, y hoy hace 18 años de eso. ¡El blog ya es mayor de edad! 🎉
Cuando empecé a escribir por aquí, aún bajo el dominio de Blogger jmaguilar.blogspot.com y con un nombre ligeramente más largo (Variable not found, 0:1, como homenaje a mi querido ZX Spectrum), Windows XP aún llenaba de color las pantallas de nuestros vetustos PC, aunque empezábamos a oír hablar de un nuevo sistema operativo llamado Windows Vista.
Programábamos aplicaciones ASP.NET 2.0 en Visual Studio 2005, usando un C# que apenas acababa de incorporar el soporte para generics o tipos anulables, y las desplegábamos por FPT a hostings o servidores on-premise, porque las nubes eran simplemente algo con formas caprichosas que veíamos en el cielo.
Los teléfonos móviles no eran nada inteligentes, eso de los smartphones llegó más tarde. En aquellos tiempos estos dispositivos sólo servían para hacer llamadas y enviar SMS. A lo sumo, podíamos jugar al Snake, pero poco más. Nada que ver con los dispositivos que llevamos en el bolsillo en este momento, ni las herramientas que éstos han propiciado.
El código fuente de los proyectos lo guardábamos donde podíamos, muchas veces incluso sin usar sistema de gestión de código o control de versiones, o utilizando herramientas poco amigables (¿alguien tiene todavía pesadillas con Source Safe? 😉)
Internet era muy distinto. Aunque las ADSL ya habían llegado a muchos hogares, la velocidad de conexión era mucho menor que la que disfrutamos ahora. Servicios, que ahora son indispensables para nuestro trabajo, como Stack Overflow o GitHub aún no existían, como tampoco (o estaban muy en pañales) las redes y aplicaciones sociales que hoy en día nos mantienen informados y en contacto, como Twitter (creo que nunca me acostumbraré a llamarlo "X" 🤦♂️), Instagram, Facebook, WhatsApp, Youtube, Twitch o TikTok.
Y por supuesto, esto de la inteligencia artificial tal y como la estamos conociendo en este momento era absolutamente impensable. Los que no trabajábamos en ese campo, apenas empezábamos a oír hablar de cosas como el machine learning o redes neuronales, y no tenían aplicación en aplicaciones, digamos, "normales".
Las cosas han cambiado mucho desde entonces, pero una sigue igual: mi pasión por la tecnología y por compartir lo que voy aprendiendo siguen intactos. Por eso, aunque a veces cueste encontrar tiempo para escribir, sigo aquí, en este rincón de la red, compartiendo con vosotros lo que voy aprendiendo, lo que me parece interesante o lo que creo que puede ser útil para alguien.
Pero todos es gracias a vosotros, esa pequeña pero fiel pandilla de amigos que me lee, me comenta y me anima a seguir adelante. ¡Muchas gracias a todos!
Y como todos los años por estas fechas, vamos a hacer balance de cómo han ido las cosas en el blog, que ya os adelanto que regular 😔
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Validación de servicios en entornos distintos a "Development" en ASP.NET Core 6
José M. Aguilar - La nueva directiva @inject de ASP.NET Core MVC
José M. Aguilar
.NET Core / .NET
- Adventures serializing absolutely everything in C#
Isadora Sophia Rodopoulos - Switch expression for void methods
Bart Wullems - Introducing OpenSilver 2.2 with LightSwitch Support
OpenSilver - Creating a .NET AsciiMath parser and using it in a Markdig extension
Andrew Lock - Secure your container build and publish with .NET 8
Richard Lander - Working with Rust Libraries from C# .NET Applications
Khalid Abuhakmeh - Some more C# 12
Tom Deseyn - How does a List know that you changed it while enumerating it?
Steven Giesel - Checking your solution for NuGet vulnerabilities or deprecated packages
Steven Giesel - Generate Images in C# Using ImageMagick & Generate Images in C# Using ImageSharp
Emmanuel Adom - General Performance Tip: Choosing Between Conditional Statements – If, Switch, and Switch Expression Performance in C#
David McCarter
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Retornar archivos estáticos desde una carpeta distinta a "wwwroot" en ASP.NET Core 6
José M. Aguilar - Filtros asíncronos en ASP.NET Core MVC
José M. Aguilar
.NET Core / .NET
- Getting Started with Primary Constructors in .NET 8 and C# 12
Anton Martyniuk - Don't Do This With Extension Methods
Adam Storr - C# 12: Collection expressions and primary constructors
Tom Deseyn - How to Convert a String to Byte Array in C#
Nick Cosentino - Using type aliases to make code clearer with generics
Gérald Barré - XML External Entity Attack and .NET Core
Bart Wullems - Hacking together an AsciiMath parser for .NET
Andrew Lock - C#: How to iterate over a dictionary?
Chris Pietschmann - Does readonly make your code faster?
Steven Giesel - Refactor your C# code with primary constructors
David Pine - C#: Console App that Accepts Command-Line Arguments
Chris Pietschmann - Try Catch in C#: The Basics You Need to Know
Nick Cosentino - .NET JsonElement and Schema Validation
Ian Griffiths - What’s new for .NET in Ubuntu 24.04
Richard Lander - Unit Testing with Semantic Kernel
Sophia Lagerkran - C# 13 Params Collections
Fons Sonnemans - Working with IAsyncEnumerable in C#
Camilo Reyes - Code It Any Way You Want: Comparison of Passing Parameters in Methods
David McCarter - How to Create a Zip File in Memory In C#
Matjaz Prtenjak - C# DateTime Format In A Nutshell
Ndepend Team - Type pattern matching in C# and TypeScript
Bart Wullems
Cuando tenemos una colección de datos para procesar, es relativamente habitual tener que hacerlo por lotes, es decir, dividir la colección en partes más pequeñas e irlas procesando por separado.
Para ello, normalmente nos vemos obligados a trocear los datos en lotes o chunks de un tamaño determinado, y luego procesar cada uno de ellos.
Por ejemplo, imaginad que tenemos un método que recibe una lista de objetos a procesar y, por temas de rendimiento o lo que sea, sólo puede hacerlo de tres en tres. Si la lista de elementos a procesar es más larga de la cuenta, nos veremos previamente obligados a trocearla en lotes de tres para ir procesando cada uno de ellos por separado.
Tradicionalmente, es algo que hemos hecho de forma manual con un sencillo bucle for que recorre la lista completa, y va acumulando los elementos en un nuevo lote hasta que alcanza el tamaño deseado, momento en el que lo procesa y lo vacía para empezar de nuevo.
Pero otra posibilidad bastante práctica, y probablemente más legible, sería pasar la lista de elementos previamente por otro proceso que retorne una lista de chunks, o pequeñas porciones de la lista original, para que luego simplemente tengamos que ir procesándolos secuencialmente. Es decir, algo así:
private char[] array = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'];
private int chunkSize = 3;
var chunks = GetChunks(array, chunkSize); // [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i'], ['j']
foreach (var chunk in chunks)
{
ProcessChunk(chunk); // 'chunk' sería un array de 3 elementos
}
Y la pregunta es, ¿cómo podríamos implementar ese método GetChunks() en C#? Vamos a ver varias opciones.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Omisión condicional de propiedades al serializar con System.Text.Json
José M. Aguilar - Interpolación de cadenas en C# 6
José M. Aguilar
.NET Core / .NET
- Automated NuGet package version range updates in .NET projects using Renovate
Anthony Simmon - Improvements in the Using Directive for Additional Types in C#
Georgios Panagopoulos - The New C# Interceptors vs. AOP.
Marek Sirkovský - C# Optional Parameters Explained
NDepend Team - Linting and Code Formatting in .NET Projects
Hamed Shirbandi - 10 Advanced C# Tricks for Developers
Konstantin Fedorov - .NET 8 and C# 12 — Interceptors
Henrique Siebert Domareski - Streamline your container build and publish with .NET 8
Richard Lander - How to Use HttpOnly Cookie in .NET Core for Authentication and Refresh Token Actions
Marinko Spasojević - C# URI Concatenation
Bill Boga - Code It Any Way You Want: Checking Strings for Null
David McCarter - Computing code coverage for a .NET project
Gérald Barré - C# Regular Expression Benchmarks – How To Avoid My Mistakes!
Nick Cosentino - What’s New in .NET 8 for Developers?
Vinoth Kumar Sundara Moorthy - The Difference Between Invariance, Contravariance and Covariance in Generics in C#
Georgi Georgiev - Baseline Styling in BenchmarkDotNet
Januarius Njoku
Hace poco vimos cómo serializar y deserializar datos en JSON de forma personalizada usando custom converters e implementamos un ejemplo simple capaz de introducir en campos de tipo int de .NET casi cualquier valor que pudiera venir en un JSON.
Pero como comentamos en su momento, la serialización y deserialización de objetos más complejos no es una tarea tan sencilla y requiere algo más de esfuerzo. En este post vamos a ver la solución para un escenario que creo que puede ser relativamente habitual: deserializar un objeto JSON a un diccionario Dictionary<string, object>.
En otras palabras, queremos que funcione algo como el siguiente código:
using static System.Console;
...
var json = """
{
"name": "Juan",
"age": 30
}
""";
var dict = ... // Código de deserialización
WriteLine($"{dict["name"]} tiene {dict["age"]} años"); // --> Juan tiene 30 años
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Breakpoints temporales y dependientes en Visual Studio 2022
José M. Aguilar - Expresiones lambda en miembros de función de C# 6
José M. Aguilar
.NET Core / .NET
- .NET 9 Preview 3
James Montemagno - Introducing MSTest SDK – Improved Configuration & Flexibility
Marco Rossignoli - Integer Overflow Vulnerabilities in .NET
Jason Sultana - Creating ico files from multiple images in .NET
Gérald Barré - The Best Way to Assign an Initial Value to Auto-Properties in C#
Kundar Kumar - C# Regex Performance: How To Squeeze Out Performance
Nick Cosentino - How to Retrieve the Number of CPU Cores in C#
Lennart Pries - Handling Circular References When Working With JSON in .NET
Georgios Panagopoulos - Equip 3rd party types with a deconstructor
Steven Giesel - How to Set a Default User-Agent on an HttpClient in ASP.NET Core
Mandar Dharmadhikari
Este tema lo he debatido con colegas en varias ocasiones y creo que abordarlo aquí puede resultar interesante para algunos más que os estéis preguntando lo mismo a raíz de la tracción que, poco a poco, va tomando Blazor entre los desarrolladores web que trabajamos con el stack de tecnologías de Microsoft.
Voy a explicar mi punto de vista al respecto contemplando dos aspectos distintos, que creo que son los fundamentales para poder responder apropiadamente a esta pregunta:
- Si técnicamente sería posible reemplazar MVC por Blazor, esto es, si Blazor dispone de mecanismos suficientes para cubrir las necesidades de una aplicación que tradicionalmente se desarrollaría con MVC.
- Si la popularidad y difusión de Blazor podría llegar a alcanzar las cotas suficientes para convertirse en una alternativa completa y segura a MVC, en términos de madurez, estabilidad, soporte y tamaño de la comunidad. O en otras palabras, si Blazor como producto llegará a estar lo suficientemente consolidado como para poder reemplazar a MVC.
Vamos a analizar cada una de ellas.
Disclaimer: obviamente, todo lo que veréis a continuación son opiniones personales y, como tales, pueden ser discutibles. Si tenéis una opinión diferente, estaré encantado de leerla en los comentarios.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¿No te gusta que tus nuevos proyectos .NET usen top level statements? Pues Visual Studio y la CLI te lo ponen fácil
José María Aguilar - Interpolación de cadenas en C# 6
José María Aguilar
.NET Core / .NET
- Leer mensajes de un buzón de Office 365 con C# & Console application vs worker service
Sergio León - Getting the Method Name from a Task in C#
Bryan Hogan - Fastest Way to Check if a List is in Order in C#
Jeff Shergalis - Collection Initializer Performance in C#
Nick Cosentino - Easily navigate code delegates
Mark Downie - The .editorconfig files for .NET developers
NDepend - Json schema validation in .NET
Gérald Barré - Pattern matching and the compiler can be surprising
Steven Giesel - How to use xUnit to run unit testing in .NET and C#
David Grace - How to Validate a GUID in C#
Osman Sokuoglu - Enable tab completion for the .NET CLI in your terminal
Anthony Simmon - Testing Your Native AOT Applications
Marco Rossignoli - 24 Essential Async/Await Best Practices for Basic to Advanced C# Developers
Sukhpinder Singh - Just for Fun: A Five-Card Poker Library Using C#
James McCaffrey - Convert Excel to PDF in Just 5 Steps Using C#
Mohan Chandran - Examples of Composition in C# – A Simple Guide for Beginners
Nick Cosentino - Primary Constructor and Logging Don't Mix
Adam Storr
Hoy va un post rápido sobre una característica de C# 12 que, aunque pequeña, nos puede resultar interesante en determinadas situaciones y puede pasar fácilmente desapercibida entre todas las demás novedades de esta versión del lenguaje.
Hasta C# 11 (.NET 7), no teníamos forma de definir una expresión lambda con parámetros opcionales y valores por defecto, como podemos hacer en los métodos o funciones normales, lo que complicaba la implementación de algunos escenarios.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Añadir filas de datos a Google Sheets desde .NET
José María Aguilar - Expresiones lambda en miembros de función de C# 6
José María Aguilar
.NET Core / .NET
- .NET 7 will reach End of Support on May 14, 2024
Rahul Bhandari - C# 13: Allow ref and unsafe in iterators and async
Steven Giesel - How to Convert ReadOnlyMemory to a Byte Array in C#
Robinson Small - .NET 9: LINQ Enhancements: A Detailed Introduction
Sukhpinder Singh - Best Practices for Logging With Serilog
Ivan Gechev - Implementing Dijkstra's algorithm for finding the shortest path between two nodes using PriorityQueue in .NET 9
Andrew Lock - Programmatic Html to PDF Generation using the WebView2 Control
Rick Strahl - C# - Tips and Tricks 03 - Use static initialization
Josef Ottosson - Bing on .NET 8: The Impact of Dynamic PGO
Ben Watson
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Entender código imposible mediante troceado y refactorización
José María Aguilar - Mejoras en bloques try/catch de C# 6
José María Aguilar
.NET Core / .NET
- Introducing .NET Smart Components - AI-powered UI controls
Daniel Roth - Working with yield in C#: Enhancing Efficiency and Code Clarity
A. Yohan Malshika - Why Should We Avoid Using Await in a Loop in C#
Anaedobe Nneka - How to Resolve IOptions Instance Inside Program Class in C#
Georgi Georgiev - Difference Between await and Task.Wait in C#
Georgios Panagopoulos - .NET Developers Begging for Ecosystem Destruction
Aaron Stannard - NCronJob - Scheduling made easy
Steven Giesel - Conventional Message Routing in Wolverine
Jeremy D. Miller - Execute the SELECT WHERE NOT EXIST SQL Query Using LINQ
Karthikeyan N. S. - C# 12: Collection Expressions
Thomas Claudius Huber - General Performance Tip: Logging
David McCarter - Generate a Word document in ASP.NET
John Reilly - Building Interactive Blazor Apps with WebAssembly
Ed Charbeneau - How to Convert IAsyncEnumerable to List
Caleb Okechukwu - Benchmark a Method’s Performance on Different .NET Versions
Januarius Njoku
Como sabéis, con ASP.NET Core 8 se ha incluido la posibilidad de que una página Blazor sea capaz de procesar directamente una petición HTTP, renderizando sus componentes y retornando el resultado HTML completo al lado cliente de forma estática. Es ya lo vimos hace algún tiempo cuando hablamos de Server-Side Rendering (SSR), una de las piezas clave para conseguir que Blazor sea un framework fullstack.
En la práctica, esta opción posibilita la implementación de sitios estáticos completos, como los que construiríamos con ASP.NET Core MVC, Razor Pages o cualquier otro tipo de tecnología de servidor, pero con la gran ventaja de que en este caso estaremos beneficiándonos del fantástico modelo de componentes Blazor, que es una gozada en términos de productividad y facilidad de uso, y sin perder la posibilidad de activar la interactividad de los componentes (su capacidad para reaccionar ante eventos del usuario), una vez que el HTML ha sido descargado en el navegador.
En aquél momento vimos que SSR no requiere una programación específica: los mismos componentes interactivos que luego podemos ejecutar en el lado cliente o servidor pueden ser renderizados mediante SSR de forma estática en el backend. Sin embargo, en algunos momentos nos podría resultar interesante saber si un componente está funcionando en modo estático (SSR) o interactivo (los tradicionales Blazor WebAssembly o Blazor Server).
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Constructores estáticos, inicializadores de módulos y startup hooks: tres formas de ejecutar código antes que Program.Main()
José María Aguilar - Inicialización de diccionarios en C# 6
José María Aguilar
.NET Core / .NET
- Measuring .NET Performance: Unleashing the Power of BenchmarkDotNet
Antão Almada - Fastest Way to Get the First N Characters of a String in C#
Januarius Njoku - Understanding System.Diagnostics DiagnosticSource and DiagnosticListener (Part 1)
Steve Gordon - How to Automatically Cast Between Types in C#
Nick Cosentino - Behind the implementation of .NET's PriorityQueue
Andrew Lock - C# 12: Primary Constructors
Thomas Claudius Huber - Mocking HttpClient requests for C# unit tests
Thomas Ardal - Get started with .NET 8 and AI using new quickstart tutorials
Jordan Matthiesen - Fastest Way to Generate a Random Boolean in C#
Matjaz Prtenjak - How to Use StringPool to Reduce String Allocations in C#
Osman Sokuoglu - Plugin Architecture in C# for Improved Software Design
Nick Cosentino - Why I Don't Use AutoMapper in .Net
Grant Riordan - LINQ Query Improvements in Marten 7
Jeremy D. Miller - Async Event Handlers in C#: What You Need to Know
Nick Cosentino - Comparing Performance of the switch and if-else Statements in C#
Michal Kaminski - Activator.CreateInstance vs Type.InvokeMember – A Clear Winner?
Nick Cosentino
Los que llevamos muchos años programando con ASP.NET/ASP.NET Core y todos los frameworks que han ido surgiendo en su ecosistema, estamos familiarizados con el concepto de "contexto HTTP".
Materializado en forma de objeto de tipo HttpContext, el contexto HTTP es una de las piezas fundamentales de la infraestructura de ASP.NET Core, y nos permite acceder a información sobre la petición HTTP que se está procesando, como los encabezados, el cuerpo de la petición, las cookies, etc., así como base para la generación de la propia respuesta a través de su propiedad Response. En muchos escenarios, se trata de un recurso imprescindible para procesar la petición de la forma adecuada, por lo que estamos acostumbrados a usarlo cuando es conveniente.
Sin embargo, cuando saltamos a Blazor, pronto nos llama la atención que HttpContext no está disponible. Y si lo pensamos, esto tiene bastante sentido en los dos modos de renderización clásicos:
-
En Blazor WebAssembly, dado que el código .NET se ejecuta directamente en el cliente, no existen peticiones que procesar y, por tanto, no existe
HttpContext. Se trata de una abstracción que sólo existe en el backend. -
En Blazor Server, aunque el código se está ejecutando en el servidor, tampoco tenemos disponible
HttpContextporque realmente no existen peticiones: el lado cliente y servidor se comunican mediante un canal websockets implementado con SignalR, que es por donde viajan ascendentemente las acciones realizadas por el usuario y descendentemente las actualizaciones del DOM de la página.
Con la llegada de Blazor 8, ha tomado relevancia el nuevo modo de renderizado, llamado Server-Side Rendering (SSR) o renderización en el lado servidor, que ya vimos por aquí hace algún tiempo.
Como ya sabemos, el funcionamiento de Blazor SSR es similar al de otros frameworks de backend puros, como MVC o Razor Pages: el servidor recibe la petición, la procesa y genera una respuesta HTML que se envía al cliente. En este escenario, durante el proceso del componente Blazor sí existe un contexto HTTP.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Requerir parámetros de la query string en ASP.NET Core
José María Aguilar - Rendimiento de nameof en C#
José María Aguilar
.NET Core / .NET
- Key derivation in .NET using HKDF
Anthony Simmon - An introduction to the heap data structure and .NET's priority queue
Andrew Lock - How To Use Polly In C#: Easily Handle Faults And Retries
Nick Cosentino - ConfigureAwaitOptions in .NET 8
Bart Wullems - Introduction to Brighter in .NET
Code Maze - Unveiling Spargine 8: A Comprehensive Guide to .NET 8 Integration and Exciting Feature Updates
David McCarter - Implicit Operators in C#: How To Simplify Type Conversions
Nick Cosentino - Optional parameters may appear in the middle of the parameter list
Gérald Barré - From SerilogTimings to SerilogTracing
Nicholas Blumhardt - Read a Text File Without Specifying the Full Path in C#
Aneta Muslic - Typesafety in xUnit with TheoryData<T>
Steven Giesel - Using parameters in BenchmarkDotNet
Bart Wullems - Extract Method Refactoring Technique in C# – What You Need To Know
Nick Cosentino - Stop Using string.ToLowerInvariant() to Compare Strings. InvariantCulture Comparisons are Slow
Darren Horrocks - Difference Between Abstraction and Encapsulation in C#
Almir Tihak - General Performance Tip: Hashing Data
David McCarter - R3 — A New Modern Reimplementation of Reactive Extensions for C#
Yoshifumi Kawai
En Blazor es posible acceder a valores de parámetros de la query string exclusivamente desde componentes de tipo página, es decir, aquellos definidos con la directiva @page.
Para ello, bastaba con declarar una propiedad pública y decorarla con los atributos [Parameter] y [SupplyParameterFromQuery]. Por ejemplo, si desde una página quisiésemos obtener el valor del parámetro term de la query string, podríamos hacerlo de la siguiente forma:
@page "/search"
<p>Searching term: @Term</p>
@code {
[Parameter]
[SupplyParameterFromQuery]
public string Term { get; set; }
}
Sin embargo, como sabéis, esto no funcionaba si intentábamos acceder así a estos parámetros desde componentes que no fueran páginas, es decir, que no fueran instanciados por el sistema de routing.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Una forma más eficiente de comprobar si un texto es un JSON válido
José María Aguilar - El operador nameof de C# 6
José María Aguilar
.NET Core / .NET
- String Performance: Comparing Strings with Globalization
David McCarter - A C# LINQ one-liner to check if exactly one of a set of conditions is met
Raymond Chen - Testing exceptions
Mark Seemann - Parallel.ForEachAsync and Exceptions
Jeremy Clark - C# Tip: IFormattable interface, to define different string formats for the same object
Davide Bellone - Reflection in C#: 4 Simple But Powerful Code Examples
Nick Cosentino - Lock statement patterns
Steven Giesel - async await in C#: 3 Beginner Tips You Need to Know
Nick Cosentino - MoaidHathot/Dumpify: Adding
.Dump()extension methods to Console Applications, similar to LinqPad's.
Moaid Hathot - Continue Processing with Parallel.ForEachAsync (even when exceptions are thrown)
Jeremy Clark - Mocking authorization tokens with WireMock.NET
Cezary Piątek - Activator.CreateInstance in C# – A Quick Rundown
Nick Cosentino
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Verificar si una cadena de texto es un JSON válido
José María Aguilar - Uso de miembros estáticos en C# 6, ¿una buena idea?
José María Aguilar
.NET Core / .NET
- How to Check if a Number Is Positive or Negative in C#
Code Maze - Developing Optimized GitHub Actions with .NET and Native AOT
David Pine - Getting all exceptions thrown from Parallel.ForEachAsync
Gérald Barré - C# System.Text.Json
Karen Payne - How to Get the Number of Lines in a Text File in C#
Karthikeyan N. S. - A Detailed Guide to String Concatenation in .NET
Aleksei - The case for an application-level tracing API in .NET
Nicholas Blumhardt - WinForms in a 64-Bit world - our strategy going forward
Klaus Loeffelmann - AddConsole is obsolete: This method is retained only for compatibility
Bart Wullems - C# for Beginners – 5 Simplified Concepts in C#
Nick Cosentino - .NET JsonElement Error Handling
Ian Griffiths
