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 HttpContext porque 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

Hace poco, andaba enfrascado en el proceso de modernización de una aplicación antigua que, entre otras cosas, guardaba datos en formato JSON en un repositorio de archivos. Dado que se trataba de una aplicación creada con .NET "clásico", la serialización y deserialización de estos datos se realizaba utilizando la popular biblioteca Newtonsoft.Json.

Al pasar a versiones modernas de .NET, esta biblioteca ya no es la mejor opción, pues ya el propio framework nos facilita las herramientas necesarias para realizar estas tareas de forma más eficiente mediante los componentes del espacio de nombres System.Text.Json. Y aquí es donde empiezan a explotar las cosas 😉.

Si habéis trabajado con este tipo de asuntos, probablemente habréis notado que, por defecto, los componentes de deserialización creados por James Newton-King son bastante permisivos y dejan pasar cosas que System.Text.Json no permite. Por ejemplo, si tenemos una clase .NET con una propiedad de tipo string y queremos deserializar un valor JSON numérico sobre ella, Newtonsoft.Json lo hará sin problemas, pero System.Text.Json nos lanzará una excepción. Esa laxitud de Newtonsoft.Json es algo que en ocasiones nos puede venir bien, pero en otras puede puede hacer pasar por alto errores en nuestros datos que luego, al ser procesados por componentes de deserialización distintos, podrían ocasionar problemas.

Por ejemplo, observad el siguiente código:

var json = """
           {
              "Count": "1234"
           }
           """;

// Deserializamos usando Newtonsoft.Json:
var nsj = Newtonsoft.Json.JsonConvert.DeserializeObject<Data>(json);
Console.WriteLine("Newtonsoft: " + nsj.Count);

// Intentamos deserializar usando System.Text.Json
// y se lanzará una excepción:
var stj = System.Text.Json.JsonSerializer.Deserialize<Data>(json);
Console.WriteLine("System.Text.Json: " + stj.Count);
Console.Read();

// La clase de datos utilizada
record Data(int Count);

Para casos como este, nos vendrá bien conocer qué son los custom converters y cómo podemos utilizarlos.

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Cómo saber dónde se está gestionando una petición en ASP.NET Core
  José María Aguilar
• Inicialización de propiedades en C# 6.0
  José María Aguilar

.NET Core / .NET

• .NET 9 Preview 1
  Rich Lander
• Announcing NuGet 6.9
  Allie Barry
• Our Vision for .NET 9
  .NET Team
• Hello, Redis - Getting Started with Redis and dotnet 8
  Steve Smith
• Garbage Collector (over)simplified & The garbage collector in .NET - Part 2: Compacting
  Steven Giesel
• Convert Between Hexadecimal and Decimal in C#
  Martin Chege
• Creating an HttpClient that uses DNS over Https
  Gérald Barré
• What Is the Difference Between Properties and Fields in C#
  Code Maze
• LINQ MindMap: .NET 9 Edition
  Steven Giesel
• Creating custom PowerToys Run plugins
  Henrik Lau Eriksson
• How to Overwrite DateTime.Now During Testing in .NET
  Ivan Gechev
• Is Random.GetItems the best way to get random items in C# 12?
  Davide Bellone
• New Features in C# 12
  Bozo Spoljaric
• How to Log a Class and Method Names Using Serilog
  Muhammad Afzal Qureshi
• Enumerating over Select’s index
  Jiří Činčura
• Weak Events in C# – How to Avoid Nasty Memory Leaks
  Nick Cosentino
• Polly Core Rate Limiter
  Bryan Hogan
• An Introduction to the World of Containers with .NET 8
  James Montemagno

Como seguramente sabréis, Blazor es la gran apuesta de Microsoft para el desarrollo de aplicaciones web con .NET. Sólo hay que ver la cantidad de novedades que han introducido en la última versión para darse cuenta de que están poniendo toda la carne en el asador y, de alguna forma, está convirtiéndose en la opción preferida para el desarrollo de este tipo de aplicaciones.

Pues bien, es un placer anunciaros que, tras varios meses de preparación, hace unos días hemos puesto en marcha el nuevo curso de desarrollo de aplicaciones Web con Blazor en .NET 8, como siempre, en CampusMVP.

Ha sido un trabajo duro, porque esta última versión ha venida cargada de novedades (sobre todo en lo relativo al nuevo modelo unificado propuesto por las Blazor Web Apps) y hemos tenido que revisar en profundidad y reescribir parte del contenido del curso, rehacer ejemplos y regrabar material audiovisual, todo con el objetivo de seguir siendo el mejor y más completo curso de Blazor del mercado.

En este post voy a intentar responder a las siguientes preguntas:

• ¿Qué es Blazor?
• ¿Por qué es interesante aprender a desarrollar con Blazor?
• Si ya hemos trabajado con ASP.NET Core y MVC, ¿siguen valiendo estos conocimientos?
• ¿En qué consiste el curso de desarrollo con Blazor?
• ¿Cuáles son los contenidos del curso?
• ¿Qué conocimientos previos se necesitan para seguir el curso?
• Me convence, ¿cuándo empezamos?

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Evitar que código de pruebas llegue a producción usando directivas de compilación de C#
  José María Aguilar
• Ejecutar tareas en segundo plano en ASP.NET 4.5.2
  José María Aguilar

.NET Core / .NET

• Volcados de memoria en Kubernetes para depurar aplicaciones .NET
  CampusMVP
• Enable the new TerminalLogger in .NET 8 SDK automatically
  Gérald Barré
• How to Correctly Implement IDisposable Interface in C#
  Code Maze
• General Performance Tip: Optimizing Attributes
  David McCarter
• Exploring .NET frozen segments
  Kevin Gosse
• Using default interface methods for performance gains in IHeaderDictionary
  Andrew Lock
• How to Pass Complex Parameters to Theory in xUnit
  Code Maze
• How to Get appsettings.json Content as a Dictionary in .NET Core
  Code Maze
• .NET 8–It’s time to get rid of these flaky tests!
  Bart Wullems
• Resilience and chaos engineering
  Martin Tomka

Hace unos días, veíamos por aquí los constructores primarios de C#, una característica recientemente introducida en el lenguaje que permite omitir el constructor si en éste lo único que hacemos es asignar los valores de sus parámetros a campos de la clase.

Veamos un ejemplo a modo de recordatorio rápido:

// Clase con constructor tradicional
public class Person
{
    private readonly string _name;
    public Person(string name)
    {
        _name = name;
    }
    public override string ToString() => _name;
}

// La misma clase usando el constructor primario:
public class Person(string name)
{
    public override string ToString() => name;
}

Como comentamos en el post, los parámetros del constructor primarios eran internamente convertidos en campos privados de la clase, generados automáticamente e inaccesibles desde el código.

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Modificar en tiempo de ejecución el valor de los settings de una aplicación ASP.NET Core
  José María Aguilar
• Eager loading en Entity Framework: mejora drástica del rendimiento en acceso a datos
  José María Aguilar

.NET Core / .NET

• Thread.Sleep vs Task.Delay en .NET: cómo introducir retardos en tu código correctamente
  José Manuel Alarcón
• The fastest way to create WireMock.NET mappings
  Cezary Piątek
• How to Create XML Files in C#
  Matjaz Prtenjak
• GetHashCode() in .NET Core
  Bart Wullems
• Consuming WCF Services in .NET 8 (.NET Core is no more!)
  DeeDee Walsh
• Tales from the .NET Migration Trenches - Hangfire
  Jimmy Bogard
• Checking if a collection is empty in C#
  Gérald Barré
• From Hours to Seconds: The Journey to a 630x Faster Batch Job
  Fati Iseni
• How to Build a URL Shortener With .NET
  Milan Jovanović
• Understanding C# 8 default interface methods
  Andrew Lock
• .NET Tasks, List’s ForEach, and Problems
  Khalid Abuhakmeh
• How to Select Multiple Records Based on a List of IDs Using LINQ
  Bozo Spoljaric
• How to Properly Create Message Templates for Logging in C#
  Vadzim Zylevich
• .NET 8–Refresh memory limit
  Bart Wullems
• How To Use ArraySegment in C#
  Kamil Pakula
• Using Azure OpenAI Service to generate images with DALL-E in .NET
  Daniel Gomez
• HigLabo.Mapper, Creating Fastest Object Mapper in the world with Expression Tree in 10 Days
  Higty
• Matrix Inverse from Scratch Using SVD Decomposition with C#
  James McCaffrey
• SearchValues object become better with .NET 9
  Steven Giesel

Hace ya algunos años, con la llegada de C# 9, los records nos mostraron otra forma de crear objetos distinta a los clásicos constructores. Ya entonces, y únicamente en aquél ámbito, se comenzó a hablar de primary constructors, pero no ha sido hasta C# 12 cuando se ha implementado de forma completa esta característica en el lenguaje.

En este post vamos a ver de qué se trata, cómo podemos utilizarlos y peculiaridades que hay que tener en cuenta.

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• ¿Usar booleanos? ¿Sí, no, a veces?
  José María Aguilar
• Generar archivos Excel como un señor con ClosedXml
  José María Aguilar

.NET Core / .NET

• A Practical Guide to Modular Monoliths with .NET
  Charles Chen
• How To Remove HTML Tags From a String in C#
  Code Maze
• Fortifying Your .NET Project
  Dick van Straaten
• To Upgrade or Not to Upgrade: Is .NET 8 Worth the Leap from .NET 6?
  DeeDee Walsh
• SerilogTracing
  Nicholas Blumhardt
• How to get assembly code generated by the JIT for a C# method
  Gérald Barré
• How to Truncate a String in .NET
  Code Maze
• How to Escape Curly Brackets and Special Characters in C#
  Lennart Pries
• A Range kata implementation in C#
  Mark Seemann
• How to Maximize the Browser Window With Selenium in C#
  Semir Teskeredzic
• Testing your incremental generator pipeline outputs are cacheable: Creating a source generator
  Andrew Lock
• C# Tip: ObservableCollection - a data type to intercept changes to the collection
  Davide Bellone
• How to Check if Items of a List Exist in Another List in C#
  Martin Chege
• Microsoft Office's RTC (Real-Time Channel) migration to modern .NET
  Gilad Oren
• Three new LINQ methods in .NET 9
  Steven Giesel
• Fastest Way to Convert a JObject to a Dictionary in C#
  Code Maze

Como sabemos, gran parte de las validaciones en formularios Blazor las implementamos usando anotaciones de datos, o data annotations. Estas anotaciones nos permiten validar los datos de entrada antes de que ejecutemos la lógica de negocio, que normalmente se encontrará en el handler del evento OnValidSubmit del formulario.

Vemos un ejemplo de formulario Blazor aquí, y el código C# justo debajo:

@page "/friend"
<h3>FriendEditor</h3>

<EditForm Model="Friend" OnValidSubmit="Save">
    <DataAnnotationsValidator />
    <div class="form-group mb-2">
        <label for="name">Name:</label>
        <ValidationMessage For="()=>Friend.Name" />
        <InputText @bind-Value="Friend.Name" class="form-control" id="name" />
    </div>
    <div class="form-group mb-2">
        <label for="score">Score:</label>
        <ValidationMessage For="()=>Friend.Score" />
        <InputNumber @bind-Value="Friend.Score" class="form-control" id="score" />
    </div>
    <div class="form-group mb-2">
        <label for="birthDate">BirthDate:</label>
        <ValidationMessage For="()=>Friend.BirthDate" />
        <InputDate @bind-Value="Friend.BirthDate" class="form-control" id="birthDate" />
    </div>
    <div class="form-group mb-2">
        <button type="submit" class="btn btn-primary">Save</button>
    </div>
</EditForm>

@code {
    private FriendViewModel Friend = new();

    private async Task Save()
    {
        await Task.Delay(1000);
        Friend = new FriendViewModel();
    }

    public class FriendViewModel
    {
        [Required(ErrorMessage = "El nombre es obligatorio")]
        public string Name { get; set; }
        [Range(0, 10, ErrorMessage = "La puntuación debe estar entre {1} y {2}")]
        public int Score { get; set; }
        public DateTime BirthDate { get; set; }
    }
}

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Raw string literals en C# 11
  José María Aguilar
• Desacoplando controladores ASP.NET MVC, paso a paso
  José María Aguilar

.NET Core / .NET

• Avoiding performance pitfalls in incremental generators: Creating a source generator, part 9
  Andrew Lock
• Authenticating a .NET GitHub App using a JSON Web Token (JWT)
  Steve Gordon
• An alternative to AutoMapper
  Steven Giesel
• Difference between CultureInfo.Get and new CultureInfo
  Gérald Barré
• Converting String to Byte Array in C#
  Caleb Okechukwu
• Going Native
  Cory Smith
• How to Save a List to a Text File in C#
  Code Maze
• What Does yield Do In C#: A Simplified View For Beginners
  Nick Cosentino
• What We Are Doing Wrong with Logging in C#
  Mabrouk Mahdhi
• Interceptors – Using C# 12 in Rider and ReSharper
  Khalid Abuhakmeh
• Mocking GraphQL queries with WireMock.NET
  Cezary Piątek
• How to Ensure a String Is Valid JSON in C#
  Code Maze
• 3 Simple Steps to Split an Excel File into Multiple Excel Files in C#
  Mohan Chandran
• Plugin Architecture Pattern in C#
  Alvaro Montoya
• How to Create a Temp File in the Temp Folder in C#
  Code Maze
• A replacement for BinaryFormatter in .NET 8
  Steven Giesel

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• PeriodicTimer: Temporizadores asíncronos en .NET 6
  José María Aguilar
• 101 nuevas citas célebres del mundo de la informática (¡y van 404!)
  José María Aguilar

.NET Core / .NET

• GitHub - praeclarum/1brc: The One Billion Row Challenge
  Frank A. Krueger
• Making primary constructor parameters read-only
  Gérald Barré
• Consistent Byte Representation of Strings in C# Without Encoding
  Code Maze
• Throw ThrowIfCancellationRequested in a Method that Returns a Value when Using a Cancellation Token
  Bryan Hogan
• Coravel - Easy task scheduling for your .NET web apps
  Jon Hilton
• A brief look at StringValues
  Andrew Lock
• Const strings are not so const after all
  Steven Giesel
• Some Stream.Read Guidelines
  Mark Heath
• Using implicit conversion operators in C# to improve readability
  Henrique Dalcin Dalmas
• When to Use Thread.Sleep, When to Use Task.Delay?
  Code Maze
• How to Distribute Roslyn Analyzers via NuGet
  Aaron Stannard

Primero, espero que hayáis disfrutado las fiestas y que el 2024 que acabamos de estrenar venga bien cargado de cosas buenas 🙂

Y para inaugurar el año, como cada primer post de enero, aprovecharemos para revisar las diez publicaciones más leídas durante los últimos 365 días.