Hace ya mucho tiempo que C# inició un interesante camino para conseguir reducir la cantidad de código necesario para hacer cosas frecuentes, introduciendo la capacidad de hacer implícitas determinadas construcciones y, por tanto, ahorrándonos tiempo y pulsaciones de teclas innecesarias.

En esta línea, todos recordaréis el tipado implícito, que tanto debate abrió en el lanzamiento de C# 3, hace ya casi quince años:

// Antes de C# 3
List<string> strings = new List<string>();

// Usando tipado implícito
var strings = new List<string>();

Bastante tiempo después, ya con C# 10, el lenguaje nos regaló una nueva característica que iba en la misma dirección, las expresiones new con el tipo destino. Éstas permitían construir objetos usando tipado implícito, aunque esta vez en el lado derecho de las expresiones:

// Antes de C# 10
public class MyClass
{
    private Invoice invoice = new Invoice(123);
    private Dictionary<string, Person> people = new Dictionary<string, Person>();
    ...
}

// Ahora
public class MyClass
{
    private Invoice invoice = new (123);
    private Dictionary<string, Person> people = new ();
    ...
}

También en C# 10 nos hemos encontrado con los using globales y using implícitos, características ambas que nos permiten economizar esfuerzos evitando la introducción repetitiva de directivas para la importación de namespaces en el código.

Pues bien, aquí viene la siguiente vuelta de tuerca :) Unas semanas atrás, Immo Landwerth (Program manager de .NET en Microsoft) sorprendía a todos con esta afirmación sobre una de las características principales del próximo C# 11:

Immo Landwerth announcing implicit dots

Ante todo, espero que estés pasando unas muy felices fiestas y con buena salud, a pesar de las circunstancias complicadas que nos rodean. Espero que pronto podamos salir de todo esto y volver a la normalidad.

Y mientras tanto, os paso algunos enlaces recopilados durante la semana pasada, que espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Generación de rutas con parámetros de query string en Blazor 6
  José María Aguilar
• Constructores con parámetros en entidades EF Core
  José María Aguilar

.NET Core / .NET

• Microsoft .NET History
  Lazie Wouters
• Ensuring Santa’s Success With Automated Tests (C# Advent 2021)
  Sean Killeen
• Reentrant (Recursive) Async Lock is Impossible in C#
  Max Fedotov
• Third-Party DI Container And Autofac
  Marinko Spasojevic
• Getting Roslyn (C# compiler) and Language versions
  Gérald Barré
• AutoMapper runtime mapping control via IMappingOperationOptions
  Adam Flow
• Cancelling IAsyncEnumerable in C#
  Jeremy Clark
• How to compare two files using .NET, really really fast!
  Sungu, Hasan Emrah
• Why C# goes well with TypeScript
  Nate Hill
• How to Convert Char Array to String in C#
  Marinko Spasojevic
• Integration testing and NuGet packaging: Creating a source generator
  Andrew Lock
• Refactoring with C# 10
  Jonathan Danylko
• Using DateOnly and TimeOnly in .NET 6 to Simplify Your Code
  Christopher C. Johnson
• gRPC client-side load balancing in .NET
  Rebin Qadir
• How to Generate Random Numbers From a Range in C#
  Marinko Spasojevic
• 5 Easy Ways to Protect Excel Data in C#
  Mohan Chandran
• As and Is Operators in C#
  Marinko Spasojevic

Parece que uno de los objetivos de C#10 es eliminar código de los archivos de código fuente de C#, simplificando su codificación y lectura. Lo hemos visto con la introducción de características como directivas using globales o los using implícitos: en ambos casos se ahorraba espacio en vertical sustituyendo los using declarados individualmente en cada archivo por directivas aplicadas de forma global al proyecto, bien de forma explícita o implícita.

En cambio, los espacios de nombre con ámbito de archivo o namespace declarations permiten ahorrar espacio en horizontal, evitando un nivel de indentación en el código que la mayoría de las veces es innecesario.

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

Por si te lo perdiste...

• ¿Por qué no compila este código C#?
  José María Aguilar
• Backing fields en Entity Framework Core
  José María Aguilar

.NET Core / .NET

• C# 10: "usings" globales e implícitos
  José Manuel Alarcón
• .NET 6 Networking Improvements
  Máňa Píchová
• How to Upgrade a Codebase from .NET Framework to .NET 6
  Christian Findlay
• Parallel.ForEachAsync Deep Dive
  Greg Bair
• .NET 6 vs .NET 4.8 GC stats - ~64% shorter max GC pause times (due to 1 letter removed in runtime)
  Niels Rasmussen
• How to Run Code in a New Thread in C#
  Marinko Spasojevic
• Testing an incremental generator with snapshot testing: Creating a source generator
  Andrew Lock
• Remove those useless File.Exists calls
  Gérald Barré
• How to Check if a StringBuilder Is Empty
  Marinko Spasojevic
• C# Tip: use yield return to return one item at the time
  Davide Bellone
• Send Emails using the SendGrid API with .NET 6 and C#
  Niels Swimberghe
• Getting Started With .NET IL
  Mike James
• How to Get an Item by Index From Dictionary in C#
  Marinko Spasojevic
• 7 Ways to Find and Highlight Text in a PDF Using .NET C#
  Mackenzie Albitz
• Collection Performance: How Do You LINQ?
  David McCarter
• Send Emails using the SendGrid API with .NET 6 and C#
  Niels Swimberghe
• String Interpolation Trickery and Magic with C# 10 and .NET 6
  Brant Burnett
• Unit Testing ILogger
  Jonathan Danylko
• Syncfusion Essential Studio 2021 Volume 4 Is Here!
  Suresh M.

Como sabemos, en las peticiones HTTP se envían al servidor un conjunto de “parámetros” o encabezados que añaden información extra para que la solicitud pueda ser procesada correctamente. Ahí encontramos información sobre el lado cliente, como la cadena de agente de usuario (encabezado user-agent), información sobre la propia petición, como el host al que se dirige la petición (encabezado host) o los idiomas que se aceptan para el contenido (accept-language), e incluso información contextual como las cookies del usuario (cookie) o información de autorización (authorization), entre muchos otros.

Hoy vamos a detenernos en una curiosidad histórica sobre el protocolo HTTP y uno de sus más célebres encabezados :)

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

Por si te lo perdiste...

• Crear proyectos usando versiones específicas del SDK de .NET Core
  José María Aguilar
• Implicit usings en C#10
  José María Aguilar

.NET Core / .NET

• What's new for gRPC in .NET 6
  James Newton-King
• An optimization story:–27% runtime costs for 8 lines of code
  Oren Eini
• Fastest way to enumerate a List<T>
  Gérald Barré
• What’s New in C# 10: Simplify Nested Property Pattern Code
  Jason Roberts
• Cancellation Tokens with IAsyncEnumerable
  Marinko Spasojevic
• Profiling .NET code with MiniProfiler
  Davide Bellone
• Could .NET Source Generator Attacks Be A Danger To Your Code?
  Steve Collins
• Don't Do That, Do This: The .NET 6 Edition
  Dave Brock
• Creating an incremental generator: Creating a source generator
  Andrew Lock
• Traversing the C# syntax tree with F#
  Jason Rametta
• Digging into the .NET Dictionary implementation
  Oren Eini
• Syncfusion Controls Support .NET 6 and Visual Studio 2022
  Mohamed Samsudeen
• Custom JSON Serialisation with System.Text.Json Converters
  Steve Gordon
• Async Disposables The Easy Way
  Phil Haack

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

Por si te lo perdiste...

• Directivas using globales en C# 10
  José María Aguilar
• Antipatrones de asincronía en C#
  José María Aguilar

.NET Core / .NET

• Difference Between "throw" vs "throw ex" in C#
  Marinko Spasojevic
• What’s New in C# 10: Take Control of Interpolated String Handling
  Jason Roberts
• Not So Complex Numbers in C#
  Mike James
• Polymorphic Serialization with .NET System.Text.Json
  Khalid Abuhakmeh
• Fun with Flags, Enums and Bit Shifting
  James Turner
• What’s New in C# 10: Value Type Records
  Jason Roberts
• How Rider Hot Reload Works Under the Hood
  Maarten Balliauw
• .NET 6 Has Arrived: Here Are a Few of My Favorite Things
  Dave Brock
• The shortest quine in C# 9 and 10
  Martin Zikmund
• Windows Forms Lives On in .NET 6
  David Ramel

Cuando aparece una nueva versión de C# o .NET, los titulares de las noticias, tweets y posts suelen girar en torno a las novedades más destacadas, aquellas que suponen cambios importantes respecto a versiones anteriores. Pero es habitual que, aparte de éstas, se añadan otras características más pequeñas que muchas veces pasan desapercibidas.

Esto es lo que ocurre con al atributo [CallerArgumentExpression], una joyita de C#10 que puede ayudarnos a hacer más descriptivos los mensajes de error y trazas que guardamos cuando aparece un error en nuestras aplicaciones.

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

Por si te lo perdiste...

• ¿Por qué llamamos "uppercase" y "lowercase" a mayúsculas y minúsculas?
  José María Aguilar
• ¿Se pueden asociar varias interfaces a la misma instancia en el contenedor de servicios de ASP.NET Core?
  José María Aguilar

.NET Core / .NET

• DateOnly and TimeOnly support with System.Text.Json
  Marco Minerva
• Updating your project to use File Scoped Namespaces
  Gérald Barré
• Best keyboard shortcuts for .NET development
  Piotr Bach
• What’s New in C# 10: Simplify Argument Null Checking Code & Easier Lambda Expressions & New Possibilities for Validation and Logging Methods
  Jason Roberts
• Bending .NET - Common Flat Build Output
  Niels Rasmussen
• What’s New in C# 10: Write Less Code and Reduce Repeated Using Directives
  Jason Roberts
• [CallerArgumentExpression] and throw helpers: Exploring .NET Core 6
  Andrew Lock
• A .NET 5.0 Guide: From Idea To NuGet Package
  Khalid Abuhakmeh
• Modern C# Hello World
  Patrick Smacchia
• How to parse JSON Lines (JSONL) with C#
  Davide Bellone
• Named Pipes in .NET 6 with Tray Icon and Service
  Erik Engberg
• dotnet-script 1.3 is out with .NET 6.0 support
  Filip Woj
• When String.GetHashCode() in .NET C# Drives You Crazy
  Ahmed Tarek
• Everything That Every .NET Developer Needs to Know About Disposable Types: Using Tools to Find Issues
  David McCarter
• C# 10 Record Structs
  Joe Mayo
• Creating an Async Web API with ASP.NET Core
  Pro Code Guide
• Windows Authentication with HttpClient
  Rick Strahl

Estamos muy acostumbrados a comenzar nuestros métodos realizando comprobaciones para evitar que pasen a nuestro código valores nulos que pudieran romper la aplicación.

Desde el principio de los tiempos, estas guardas han presentado el siguiente aspecto:

public class MyService
{
    public void MyMethod(object first, object second)
    {
        if(first == null) 
        {
            throw new ArgumentNullException("first");
        }
        if(second == null) 
        {
            throw new ArgumentNullException("second");
        }        
        // ...
    }
}    

¿Todo bien, verdad? El código es aparentemente correcto y fácil de comprender, pero... ¡demasiado extenso! Hemos consumido casi diez líneas de código sólo realizando comprobaciones de "fontanería", y ni siquiera hemos empezado a plantear la funcionalidad real del método.

Afortunadamente, con el tiempo C# ha ido evolucionando y mejorando sucesivamente este escenario tan frecuente.

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

Por si te lo perdiste...

• Publicando nuestra web sobre Azure Web Apps
  Jorge Turrado
• 5 motivos por los que tus acciones MVC reciben objetos vacíos o nulos en ASP.NET Core
  José María Aguilar

.NET Core / .NET

• Más novedades de .NET 6, PriorityQueue
  Javier Suárez
• 1.0 stable release of Windows App SDK is now LIVE!
  Dina Ayman
• Infer# v1.2: Interprocedural Memory Safety Analysis For C#
  Xin Shi
• The Case for C# and .NET
  Charles Chen
• What's new in Windows Forms in .NET 6.0
  Igor Velikorossov
• Setting up Serilog in .NET 6
  Nicholas Blumhardt
• C# 10 new feature CallerArgumentExpression, argument check and more
  Dixin Yan
• Azure Active Directory's gateway is on .NET 6.0!
  Avanindra Paruchuri
• Monitoring a .NET application using OpenTelemetry
  Gérald Barré
• New dependency injection features in .NET 6: Exploring .NET Core 6
  Andrew Lock
• C# Tip: Use a SortedSet to avoid duplicates and sort items
  Davide Bellone
• Exploring C# 10: Use Extended Property Patterns to Easily Access Nested Properties
  Dave Brock
• .NET 6 vs .NET 5: up to 40% speedup!
  Alex Yakunin

Hasta Blazor 6, daba la impresión de que la query string era un ciudadano de segunda clase en el sistema de routing, pues no se ofrecían mecanismos sencillos para la obtención de parámetros suministrados a través de esta vía, ni tampoco para la generación de URI que los utilizaran. De hecho, estas tareas teníamos que solucionarlas manualmente, aunque fuera con ayuda de paquetes externos como Microsoft.AspNetCore.WebUtilities.

Ya con la llegada de esta versión, Blazor incorpora de serie herramientas que nos harán esto más llevadero, como su integración con el binding o, lo que veremos en este post, la posibilidad de generar direcciones que incluyan este tipo de parámetros.

Ahí van los enlaces recopilados durante la semana pasada, obviamente muy condicionados por la oleada de lanzamientos de nuevas versiones de casi todo. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Si las shadow properties no existen como propiedades en la entidad, ¿cómo podemos inicializarlas en el seed de Entity Framework Core?
  José María Aguilar
• CRUD en Blazor usando el componente DataGrid de Syncfusion
  José María Aguilar

.NET Core / .NET

• Announcing .NET 6 - The Fastest .NET Yet
  Richard Lander
• Welcome to C# 10
  Kathleen Dollard
• What’s New for Visual Basic in Visual Studio 2022
  Kathleen Dollard
• F# is officially here!
  Kathleen Dollard
• Announcing dotnet monitor in .NET 6
  Sourabh Shirhatti
• How to Fully Cover .NET C# Console Application With Unit Tests
  Ahmed Tarek
• Executing ad hoc C# code snippets
  Dominique St-Amand
• Bite-Size .NET 6 - UnionBy, IntersectBy, ExceptBy, and DistinctBy
  Matthew Jones
• Asynchronous Programming in .NET Core C#
  Pro Code Guide
• Top 6 Features in the new .NET Version & Top 5 Features in the new C# Version
  Nikola M. Zivkovic
• Source generator updates: incremental generators: Exploring .NET Core 6
  Andrew Lock
• GIFs in Console Output Using ImageSharp and Spectre.Console
  Khalid Abuhakmeh
• C# Delegates
  Marinko Spasojevic
• WhenAny and Pattern Matching with Different Types of Task
  Bryan Hogan
• C# 10 Falls Just a Bit Short
  Matthew MacDonald
• Single File Apps In .NET 6
  Wade Gausden
• How C# 10.0 and .NET 6.0 improve ArgumentExceptions
  Ian Griffiths
• Dissecting Interpolated Strings Improvements in C# 10
  Sergey Teplyakov
• Building a project that target .NET Framework 4.5 in Visual Studio 2022
  Thomas Levesque
• Why Does x = ++x + x++ Give Me the Wrong Answer?
  OriginalGriff
• Overriding Sealed Methods in C#
  Adam Furmanek

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

Por si te lo perdiste...

• Shadow properties en Entity Framework Core
  José María Aguilar
• ¿Se pueden crear componentes Blazor que no hereden de ComponentBase o alguno de sus descendientes?
  José María Aguilar

.NET Core / .NET

• .NET 6: DateOnly y TimeOnly & File Scoped Namespaces & Global Usings
  Javier Suárez
• Enums in C#: hidden pitfalls
  Sergey Vasiliev
• ICYMI C# 9 New Features: Create Immutable Objects with Records
  Jason Roberts
• .NET Collections - IEnumerable, IQueryable, ICollection
  Marinko Spasojevic
• Bite-Size .NET 6 - MaxBy() and MinBy() in LINQ
  Matthew Jones
• Diagnostics tools for App Service on Linux
  Mark Downie
• Improving logging performance with source generators: Exploring .NET Core 6
  Andrew Lock
• A quick review of C# 10 new language features
  Thomas Levesque
• String Performance: Concatenating Strings
  David McCarter
• Discovering new C# String Pattern Matching Features
  Rick Strahl
• Caller Argument Expressions – A Look at New Language Features in C# 10
  Rachel Appel

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

Por si te lo perdiste...

• Cómo crear un paquete NuGet y publicarlo en Nuget.org
  Jorge Turrado
• Expresiones new con el tipo de destino en C# 9
  José María Aguilar

.NET Core / .NET

• Calendario común de comunidades .NET de España
  Javier Suárez
• Google Sheets API with .NET Core
  Marinko Spasojevic
• Making Sense of Common C# Compiler Errors
  Matt Eland
• Parallel.ForEachAsync in .NET 6
  Scott Hanselman
• Bite-Size .NET 6 - PriorityQueue<T, N>
  Matthew Jones
• Dotnet Format and File Scoped Namespaces
  Steve Smith
• How to Get Rid of the INotifyPropertyChanged Boilerplate
  Gael Fraiteur
• How to test HttpClientFactory with Moq
  Davide Bellone
• Pattern Matching in C# for Beginners
  Sowmiya V.
• 5x Lessons Learned from Migrating a Large Legacy to .NET 5/6
  Patrick Smacchia
• Immutable C#
  Sam Williams
• Moq vs NSubstitute: syntax cheat sheet
  Davide Bellone
• File-Scoped Namespaces – A Look at New Language Features in C# 10
  Khalid Abuhakmeh
• What's new in .NET 6 and C# 10. Everything you wanted to know.
  Oleksii Nikiforov
• Everything That Every .NET Developer Needs to Know About Disposable Types: Properly Implementing the IDisposable Interface
  David McCarter
• Sorting large CSV files by multiple columns using C#
  Josef Ottosson

Hoy va un post rapidito sobre un curioso detalle sintáctico de C# que me llamó la atención hace algún tiempo, mientras leía el artículo How to Stress the C# Compiler, donde Henning Dieterichs comenta varias formas de estresar (¡literalmente!) al compilador de C# utilizando construcciones admitidas por el lenguaje.

La cuestión es: ¿por qué no compila el siguiente código?

class Program {
    public static void Main() {
        int f = 0; int x = 0; int y = 0;
        System.Console.WriteLine(
            "{0} {1}",
            f < x,   // is f smaller than x?
            y > (-1) // is y greater than -1?
        );
    }
}

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

Por si te lo perdiste...

• Crear manualmente instancias de clases usando el proveedor de servicios de .NET
  José María Aguilar
• Invalidar el contenido cacheado por el tag helper "cache" de ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• What’s new in F#
  Kathleen Dollard
• Prefer using Stream to byte[]
  Bohdan Stupak
• Supporting integration tests with WebApplicationFactory in .NET 6: Exploring .NET Core 6
  Andrew Lock
• Bite-Size .NET 6 - LINQ OrDefault() Overloads
  Matthew Jones
• IAsyncEnumerable with yield in C#
  Marinko Spasojevic
• C# Tip: use the Ping class instead of an HttpClient to ping an endpoint
  Davide Bellone
• Exploring C# 10: Global Using Declarations
  Dave Brock
• C# 10.0: Extended Property Patterns – Use the Dot Token to Access Nested Members
  Thomas Claudius Huber
• How to Create a PNG File with Transparent Background from a Powerpoint Slide in C#
  Roland Weigelt
• C# Records - The good, bad & ugly
  Gary Woodfine

Hace unos días hablábamos de las directivas using globales, un interesante añadido a C# 10 que permite importar espacios de nombres en todos los archivos de código del proyecto, sin necesidad de repetir cientos de veces las mismas líneas en sus encabezados. Simplemente, si un namespace es interesante para nuestro proyecto, lo declaramos como global en algún punto y será lo mismo que si lo hubiéramos hecho en cada uno de los archivos .cs:

global using System;
global using System.Text;
global using System.Text.Json;
global using MyProject.Model;
...

Bien podían haberlo dejado aquí porque ya es una mejora sustancial respecto a lo que tenemos, pero no, el equipo de diseño de C# sigue introduciendo detalles que pueden hacernos la vida más sencilla. Es el caso de los implicit usings que, de la misma forma, acompañan a .NET 6 y C# 10.

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

Por si te lo perdiste...

• 3 formas de saber si un componente se está ejecutando en Blazor Server o WebAssembly
  José María Aguilar
• Registro y obtención de múltiples implementaciones de servicios en ASP.NET Core, y un caso práctico
  José María Aguilar

.NET Core / .NET

• Announcing .NET 6 Release Candidate 2
  Richard Lander
• CQRS Validation Pipeline with MediatR and FluentValidation
  Marinko Spasojevic
• Downloading a SSL/TLS certificate in .NET
  Gérald Barré
• World's Smallest C# Program (featuring N)
  Niels Rasmussen
• Updating NuGet packages from command-line
  Thomas Ardal
• The Problem with C# 10 Implicit Usings
  Muhammad Rehan Saeed
• Hot Reload in .NET 6- An Overview
  Mohamed Yasir Kader Sha
• Bite-Size .NET 6 - Chunk() in LINQ
  Matthew Jones
• Dotnet could not execute because the application was not found or a compatible .NET SDK is not installed
  Scott Hanselman
• Enable .NET CLI Tab Completion
  Cody Merritt Anhorn

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

Por si te lo perdiste...

• La interfaz IMiddleware: Middlewares tipados per request en ASP.NET Core
  José María Aguilar
• Un vistazo a los patrones relacionales y combinadores, lo nuevo de C# 9 para exprimir el pattern matching
  José María Aguilar

.NET Core / .NET

• Code Coverage in .NET
  Marinko Spasojevic
• WebView2 Flashing when changing TabControl Tabs
  Rick Strahl
• Bite-Size .NET 6 - DateOnly and TimeOnly
  Matthew Jones
• Everything That Every .NET Developer Needs To Know About Disposable Types
  David Mccarter
• Exploring C# 10: Save Space with File-Scoped Namespaces
  Dave Brock
• Unit Testing Legacy Applications with JustMock
  Peter Vogel
• 6 Tips for Writing Elegant C# Code
  Assis Zang

Seguro que estáis acostumbrados a ver y escribir las, a veces extensas, listas de directivas using encabezando vuestros archivos de código fuente C#. Aunque ciertamente los entornos de desarrollo actuales son de bastante ayuda a la hora de introducirlos e incluso a veces nos permiten colapsarlos, son unos grandes consumidores del valioso espacio vertical de nuestros monitores:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// ... (muchos using más)

namespace MyApplication
{
    public class MyClass
    {
        ...
    }
}

Pero si habéis trabajado con Razor, ya sea para crear vistas MVC/Razor Pages o bien desde Blazor, seguro que os habrán encantado los archivos tipo _ViewImports.cshtml o _Imports.razor, pues permiten introducir directivas que se apliquen a todos los archivos Razor del proyecto. 

¿No sería buena idea llevar esto mismo a nivel del lenguaje?

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

Por si te lo perdiste...

• Cómo saber si un objeto no es nulo (edición C# 9)
  José María Aguilar
• El hosting in-process de ASP.NET Core 2.2
  José María Aguilar

.NET Core / .NET

• Is C# Getting Too Complex?
  Michael Moreno
• J4JLogger: A Serilog Wrapper that Provides Source Code Information
  Mark Olbert
• Grouping Assertions in Tests
  Steve Smith
• Events in C#
  Marinko Spasojevic
• Compress Strings With .NET and C#
  Khalid Abuhakmeh
• Remove all event handlers from an event in C#
  Rod Stephens
• C# 10.0: Global Using Directives – Make Important Namespaces Available in Your Whole Project
  Thomas Claudius Huber
• Differences between Hashtable vs Dictonary vs ConcurrentDictionary vs ImmutableDictionary
  Scott Hanselman

Como en otras ocasiones, seguro que debía ser de los pocos que quedaban en este planeta sin saber esto, pero me lo he encontrado mientras pululaba por internet y me ha parecido de lo más curioso. Y como con toda probabilidad habrá por ahí algún despistado más, me ha parecido interesante comentar por aquí mi último gran descubrimiento ;)

La cuestión es que en nuestro mundillo solemos utilizar frecuentemente los términos uppercase y lowercase para referirnos a mayúsculas y minúsculas. Pensaba, erróneamente, que los prefijos upper y lower tenían que ver con el tamaño de los caracteres, y jamás me había dado por preguntarme el por qué de este sufijo "case" tan caprichoso que estas palabras comparten.

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

Por si te lo perdiste...

• Crear bloques de código Razor reutilizables en Blazor con Render Fragments
  José María Aguilar
• Crear y utilizar librerías multiplataforma con C++ y .NET Core (Parte 2)
  Jorge Turrado

.NET Core / .NET

• Adiciones a LINQ en .NET 6.0
  Octavio Hernandez
• 6 Essential Tools to Detect and Fix Performance Issues in .NET
  Michael Shpilt
• Generate PDF files using an html template and Playwright
  Gérald Barré
• How to sign XML using RSA in .NET & ECDSA and Custom XML Signatures in .NET
  Scott Brady
• Source Generator For INotifyPropertyChanged
  Anu Viswan
• A look at the upcoming improvements to LINQ in .NET 6
  Matt Eland
• C# tip: define Using Aliases to avoid ambiguity
  Davide Bellone
• C# XML Comments in Visual Studio Code
  Dennes Torres
• C# 10.0 implicit global using directives
  Ian Griffiths
• C# 10.0: File Scoped Namespaces – Get More Space For Your Code
  Thomas Claudius Huber
• .NET 6 / C# 10 Top New Features Recap
  Wade Gausden
• Implicit Usings in .NET 6
  Scott Hanselman

Si trabajáis con ASP.NET Core MVC, seguro que con frecuencia implementaréis acciones que reciben como argumento objetos complejos, que normalmente vendrán serializados en el cuerpo de la petición como JSON.

Y probablemente, lo habréis hecho esperando que el binder obre su magia y sea capaz de transformar esas secuencias de caracteres procedentes de la red en flamantes instancias de objetos del CLR, listas para ser consumidas desde las aplicaciones. Un ejemplo de acción de este tipo es la siguiente (aunque no funcionaría, luego vemos por qué):

public class FriendsController: Controller
{
    [HttpPost]
    public string Hello(Friend friend)
    {
        return $"Hola {friend.Name}, tienes {friend.Age} años";
    }
}

public class Friend
{
    public int Age { get; set; }
    public string Name { get; set; }
}

Sin embargo, a veces nos encontramos con que, a pesar de que la petición contiene en su body los datos JSON esperados, el objeto que recibimos es nulo o tiene todas sus propiedades sin inicializar.

¿Por qué ocurre esto? En este post vamos a ver distintos motivos que podrían llevar a este comportamiento, y cómo solucionar cada caso.

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

Por si te lo perdiste...

• Cómo mostrar por consola las líneas que se van añadiendo a logs o archivos de texto, en tiempo real
  José María Aguilar
• ¿Se pueden introducir directivas o lógica de inicialización en todas las vistas y páginas sin duplicar código?
  José María Aguilar

.NET Core / .NET

• Announcing .NET 6 Release Candidate 1
  Richard Lander
• Introduction to System.Text.Json Through Examples
  Marinko Spasojevic
• Investigating an infinite loop in Release configuration
  Gérald Barré
• Getting Started Tweetinvi .NET Twitter
  Bradley Wells
• Looking inside ConfigurationManager in .NET 6: Exploring .NET Core 6
  Andrew Lock
• CoreWCF 0.3.0 Release
  Matt Connew
• Deep C#: Strong Typing
  Mike James
• Using .NET To Validate JSON with JSON Schema
  Khalid Abuhakmeh
• What I Like About C# 9
  Joseph Guadagno
• Introducing Package Source Mapping
  Nikolche Kolev
• Debugging a .NET App on Linux from Windows Visual Studio with WSL
  Patrick Smacchia
• HTTP/3 support in .NET 6
  Sam Spencer

El timeout que dejé programado semanas atrás ya ha finalizado, por lo que hay que ponerse de nuevo las pilas. Y sin duda, ningún día mejor para hacerlo que el Día Internacional del Programador, celebrado de forma más o menos consensuada el día 13 de septiembre (12 si el año es bisiesto), al ser el día 256º de cada año :)

Así que, para iniciar la temporada con buen pie, ahí va una colección de enlaces, que espero os resulten interesantes :-)

Por si te lo perdiste...

• Syncfusion Blazor UI components library: un primer vistazo
  José María Aguilar
• Otras formas de obtener dependencias en controladores ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• Launching Visual Studio Code cleanly from a .NET Application
  Rick Strahl
• File IO improvements in .NET 6
  Adam Sitnik
• How not to read a string from an UTF-8 stream
  Gérald Barré
• IntelliSense for Hosted C# Script
  Phil Haack
• C# static constructor called multiple times & Going deeper into static constructors hole
  Jiří Činčura
• Favorite improvements in .NET 6
  Mark Downie
• A neat Trick to Debug Exceptions in C#
  Simon Sutoris
• Manually Parsing a Json String Using System.Text.Json
  Paul Michaels
• C# Namespace Declarations
  Steve Fenton
• DateOnly And TimeOnly Types In .NET 6
  Wade Gausden
• How To Desktop in 2022
  Sam Basu

Como es habitual por estas fechas, me complace (seriamente) informaros de que a partir de la semana  el blog quedará en "modo verano" y dejaré de publicar nuevos contenidos hasta ya entrado septiembre. 

Durante este periodo procuraré desconectar totalmente durante un par de semanas, y el resto del tiempo al menos poder bajar un poco el ritmo, a ver si puedo disfrutar un poco de esas cosas que dicen que existen fuera de las pantallas ;)

¡Nos vemos a la vuelta!

Publicado en Variable not found.

Semanas atrás echamos un vistazo por encima a Blazor UI Components, los componentes profesionales para Blazor de Syncfusion, y algún tiempo después revisamos más en detalle uno de los grandes protagonistas en el mundo de los componentes, los de creación de gráficas estadísticas o Charts.

Sin embargo, si hay un tipo de componentes que todos usamos de forma frecuente en nuestras aplicaciones profesionales son, sin duda alguna, los grids o rejillas de datos. Por esa razón, los componentes que de alguna forma simplifican su creación son probablemente los más populares en todas las suites profesionales o gratuitas, sea cual sea la tecnología en la que trabajemos.

En este post centraremos el foco en Blazor DataGrid, la propuesta de Syncfusion para crear interfaces de rejillas de datos de forma sencilla y eficaz para Blazor Server y WebAssembly.

Pero antes de empezar, recordad que, aunque se trata de un producto comercial, dispone de una licencia community bastante permisiva, que permite que en muchos casos podamos utilizar los componentes de forma totalmente gratuita.

Nota: lo que estás leyendo es un post patrocinado por Syncfusion, pero en ningún momento han revisado previamente o condicionado de alguna forma su contenido.

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

Por si te lo perdiste...

• ¿Cuánto pesa realmente una aplicación Blazor WebAssembly recién creada?
  José María Aguilar
• Mi controlador tiene muchos parámetros en el constructor, ¿estoy haciendo algo mal?
  José María Aguilar

.NET Core / .NET

• .NET 6 LINQ New Features
  Satish Yadav
• ICYMI C# 9 New Features: Adding foreach Support To Any Type
  Jason Roberts
• How Does the StringBuilder Work in .NET? Part 1 & Part 2
  Steve Gordon
• Supporting Hot Reload in your .NET application
  Gérald Barré
• C# 10 - Top 5 New Features in the Upcoming C# Version
  Nikola M. Zivkovic
• Taking Your Brain To Another Dimension - A C# library for physical units
  Keith Barrett
• C# tip: String.IsNullOrEmpty or String.IsNullOrWhiteSpace?
  Davide Bellone
• Rediscovering implicit casting
  Ken Bonny
• Zero to Hero: Containerizing .NET 5.0 WebApis
  David Kröll
• Thoughts on Async/Await Conversion in a Desktop App
  Rick Strahl
• How to Use Custom Comparers in NUnit
  Sean Killeen

Como sabéis, a no ser que se especifique lo contrario mediante la directiva @inherits, los componentes Blazor heredan de Microsoft.AspNetCore.Components.ComponentBase. Esta clase abstracta proporcionada por el framework hace que podamos centrarnos en escribir nuestro código, al encargarse de gestionar aspectos básicos de los componentes como su creación, inicialización, renderizado, el ciclo de vida u otros aspectos de infraestructura.

Pero aunque heredar de ComponentBase es la inmensa mayoría de las veces la mejor opción, no tiene por qué ser así necesariamente. Blazor reconoce como componente cualquier clase que implemente IComponent, una pieza mucho más pequeña.

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

Por si te lo perdiste...

• Ver el código fuente generado por source generators
  José María Aguilar
• Establecer textos por defecto y localizados en validaciones de ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• ¿Qué es la carpeta "ref" que hay en los resultados de compilar un proyecto con .NET?
  José Manuel Alarcón
• Cost of exceptions
  Gunnar Peipman
• ICYMI C# 9 New Features: Reducing Code with Target-typed New Expressions
  Jason Roberts
• Test Your .NET HttpClient Based Strongly Typed Clients Like a Boss
  Adam Storr
• How to Compare Performance between .NET 5 and .NET Framework Controls
  Denis Zmitrichenko
• Functional monads in C#
  Camilo Reyes
• Conditional compilation for ignoring method calls with the ConditionalAttribute
  Andrew Lock
• Stop Saving to Disk with C# Asynchronous Streams
  Lee Richardson
• C sharp or B flat? Experiments in self-contained native executables in .NET
  Scott Hanselman
• A Practical Guide to Higher Order Functions in C#
  Sam Walpole
• Why is there a difference between decimal 0 and 0.0?
  Colin Mackay

Es una gran alegría poder compartir con todos vosotros que Microsoft me ha reconocido por undécimo año consecutivo como Most Valuable Professional (MVP) en la comunidad de tecnologías para desarrolladores.

En esta ocasión, la notificación del nombramiento me pilló completamente desprevenido, apagando un fuego de los gordos provocado por un error en un servidor de producción, por lo que el fragor de la batalla no me dejó celebrar apropiadamente el momento, ni disfrutar la tensa espera que lo precede. Pero ya al llegar la calma, sí que he podido sentir de nuevo la emoción y orgullo que supone seguir perteneciendo un año más a este selecto grupo de locos por el software y la tecnología. ¡Once años ya, uau!

Muchas gracias a todos los que hacéis esto posible: a los que me estáis leyendo, porque sois los que día a día me dais motivos para continuar con este proyecto. No dudéis que sin vuestras visitas, comentarios y mensajes esto no tendría sentido. 

Muchas gracias también al equipo del programa MVP, por su incansable labor en beneficio de la comunidad y su inestimable ayuda a los miembros del programa. 

Y como no podía ser de otra forma, un agradecimiento infinito para mi mujer e hijas, por cederme el tiempo y espacio que necesito para desarrollar mi pasión.

Por último, me gustaría aprovechar la ocasión para felicitar a los MVP que renuevan este año y animarlos a continuar regalándonos tanto conocimiento y entusiasmo. Y también, por supuesto, una afectuosa bienvenida a los que acabáis de recibir vuestro primer reconocimiento; disfrutad el momento, porque no lo vais a olvidar jamás :)

¡Nos vemos!

Publicado en Variable not found.

Me encanta que el lenguaje C# vaya introduciendo características que consiguen que cada vez tengamos que escribir menos para conseguir lo mismo, y, sobre todo, si la legibilidad posterior del código no se ve comprometida.

Uno de estos casos son los recientes target-typed new expressions, o expresiones new con el tipo del destino, que básicamente permite evitar la introducción del tipo de datos al usar el constructor de una clase, siempre que el compilador sea capaz de inferirlo por su contexto.

Vamos a echarle un vistazo en este post.

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

Por si te lo perdiste...

• Analiza tu código a fondo y desde distintas perspectivas con NDepend
  José María Aguilar
• Localizar errores de validación del binding en ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• What's new in Windows Forms in .NET 6.0 Preview 5
  Igor Velikorossov
• C# Type Conversion (and Coffee!) • Programming is Fun
  Janell Baxter
• What is the difference between Reflection and dynamic keyword in C#?
  Shivprasad Koirala
• Default Your FirstOrDefault in .NET 6.0
  Adam Storr
• Exploring Fluent Assertions
  Gérald Barré
• Abusing C# binding redirects for fun and profit - Injecting custom code without modifying files
  Bill Wilson
• Customized JSON formatting with Serilog
  Nicholas Blumhardt
• ICYMI C# 9 New Features: More Pattern Matching Features
  Jason Roberts
• Package Validation
  Anirudh Agnihotry
• Understanding async/await State Machine in .NET
  Mykhailo Konovalov
• CompactExifLib: Access to EXIF Tags in JPEG, TIFF and PNG Files
  Hanns-Peter Kalb

Hace algunas semanas echamos un vistazo rápido a Blazor UI Components, la suite de componentes profesionales para Blazor proporcionada por Syncfusion.

Como vimos, se trata de una completa colección que soluciona las necesidades más habituales durante la creación de la interfaz de usuario de aplicaciones Blazor, tanto Server como WebAssembly. Más de 70 componentes que incluyen controles de entrada de datos, botones, calendarios, layouts, rejillas de datos o gráficas estadísticas, entre otros. Y lo mejor es que, aunque se trata de un producto comercial, su generosa licencia community permite que muchos podamos utilizarlos de forma totalmente gratuita.

Hoy vamos a profundizar un poco en los componentes de presentación de datos estadísticos, o Chart Components, que por su potencia, versatilidad y calidad del resultado merece un post en sí mismos.

Nota: lo que estáis leyendo es un post patrocinado por Syncfusion, pero en ningún momento han revisado previamente o condicionado de alguna forma su contenido.

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

Por si te lo perdiste...

• C# Source generators: metaprogramación en tiempo de compilación
  José María Aguilar
• Cargar automáticamente objetos del modelo en acciones ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• Announcing .NET 6 Preview 5
  Richard Lander
• Making Your Life Easier with C# Scripting
  Peter Vogel
• Caching Enum.ToString to improve performance
  Gérald Barré
• Conversation about diagnostics
  Richard Lander
• Setting Content for HttpClient Testing with JSON.NET and System.Text.Json
  Adam Storr
• Hot Reload for .NET Developers
  Daniel Gomez Jaramillo
• Migration of Bing’s Workflow Engine to .NET 5
  Ben Watson
• dotnet repl
  Scott Hanselman
• Running .NET Core Apps on a Framework other than Compiled Version?
  Rick Strahl
• ICYMI C# 9 New Features: Top-level Statements
  Jason Roberts
• C# Pattern Matching Quick Guide And Examples
  Khalid Abuhakmeh
• Conversation about networking
  Richard Lander
• Show a name and profile photo with .NET and Gravatar
  Thomas Ardal
• Quick Noda Time Conversions
  Simon Timms
• C# 10 - record struct Deep Dive & Performance Implications
  Niels Rasmussen

No hace demasiado tiempo he descubierto en el framework la clase ActivatorUtilities, una pequeña joyita disponible en Microsoft.Extensions.DependencyInjection, que puede resultar interesante para implementar fácilmente factorías o cualquier tipo de código donde tengamos que instanciar manualmente clases con dependencias hacia servicios registrados en el contenedor de nuestra aplicación.

La clase estática ActivatorUtilities ofrece básicamente tres métodos públicos:

• CreateFactory(), para crear factorías de objetos.
• CreateInstance() / CreateInstance<T>(), para crear instancias de objetos.
• GetServiceOrCreateInstance() / GetServiceOrCreateInstance<T>(), para obtener una instancia desde el inyector, o bien crearla manualmente con CreateInstance().

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

Por si te lo perdiste...

• Cómo crear bibliotecas de clases o proyectos de consola .NET 5 en lugar de .NET Core 3.1
  José María Aguilar
• Quizás no estés comparando con null de forma totalmente correcta
  José María Aguilar

.NET Core / .NET

• Date, Time, and Time Zone Enhancements in .NET 6
  Matt Johnso
• Debugging C# Source Generators with Visual Studio 2019 16.10
  Steve Collins
• Different ways to check if a value is null in C#
  Gérald Barré
• Extending HttpClient Testing With Templating
  Adam Storr
• A Closer Look at 5 New Features in C# 10
  Matthew MacDonald
• Build apps for Microsoft Teams with .NET
  John Miller
• C# tip: how to get the index of an item in a foreach loop
  Davide Bellone
• In the Jungle of .NET Obfuscator Tools
  Patrick Smacchia
• Rediscovering implicit casting
  Ken Bonny
• Command Line Arguments and C# 9.0 Top Level Statement
  Abhijit Jana
• Show dotnet: Running my .NET nanoFramework for 8 years on a battery
  Laurent Ellerbach
• A C# Library to Implement Array Tries
  Jorge Luis Orejel

Blazor permite crear componentes que son ignorantes respecto al modelo de hosting que están utilizando en tiempo de ejecución. Es decir, si lo diseñamos apropiadamente, un componente podría funcionar indistintamente en Blazor Server y Blazor WebAssembly, lo cual sería ideal desde el punto de vista de su reutilización.

Sin embargo, desde el interior de estos componentes, a veces necesitaremos distinguir cuándo están siendo ejecutados en Blazor Server y cuándo en Blazor WebAssembly. ¿Cómo podemos conseguir esto? Pues tenemos muchas maneras...

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

Por si te lo perdiste...

• ¿Aplicar [Authorize] a todos los controladores MVC de una carpeta?
  José María Aguilar
• Radzen Blazor Components: ¡ahora open source!
  José María Aguilar

.NET Core / .NET

• New LINQ extensions in .NET 6 and benchmarks
  Kristoffer Strube
• Benchmarking 4 reflection methods for calling a constructor in .NET
  Andrew Lock
• Conversation about .NET interop
  Richard Lander
• Working With .NET 6’s PriorityQueue
  Khalid Abuhakmeh
• Quick Tip - Compiler Directives and Using Aliases to Ignore Tests
  Adam Storr
• Migrate or Port Your Old Legacy .net Projects to the .NET5
  Sibeesh Venu
• Interpreting async code in CPU traces
  Mark Downie
• Conversation about the .NET type system
  Richard Lander
• Customizing Serilog text output
  Nicholas Blumhardt
• The Roslyn analyzers I use in my projects
  Gérald Barré
• .NET 6: Collections Improvements
  Jonathan Allen

Desde C# 7 podemos emplear patrones en expresiones is o bloques switch para especificar las condiciones que deseamos comprobar, y cada nueva versión del lenguaje sigue introduciendo novedades al pattern matching, haciéndolo cada vez más sencillo y cómodo de utilizar.

En particular, C# 9 ha añadido un montón de características interesantes destinadas a facilitar el uso de patrones, pero en este post vamos a centrarnos en las dos más importantes: los combinadores de patrones y los patrones relacionales.

Ahí van los enlaces recopilados durante la semana pasada, con muchas novedades de la Build 2021. Espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Si usas [EmailAddress] y [Url] para validar datos de entrada, ojo: ¡que hace tiempo que ya no validan mucho!
  José María Aguilar
• BenchmarkDotNet: Arañando microsegundos en proyectos .NET Core o .NET Framework
  José María Aguilar

.NET Core / .NET

• Announcing .NET 6 Preview 4
  Richard Lander
• Introducing the .NET Hot Reload experience for editing code at runtime
  Dmitry Lyalin
• How to Easily Create Telegram Bot using C#
  Uladzislau Baryshchyk
• C# 9 init accessors and records
  Tom Deseyn
• .NET Basics
  Dustin Morris
• How to use MediatR Pipeline Behaviours
  Gary Woodfine
• Finding concurrency bugs in a .NET application using Coyote
  Gérald Barré
• Simple Example of Calling REST API with HttpClient in .NET 5.0
  Adam Storr
• OData In .NET 5
  Jay Krishna Reddy
• Running a .NET application as a service on Linux with Systemd
  Maarten Balliauw
• Using DateOnly and TimeOnly in .NET 6 - Steve Gordon
  Steve Gordon
• The Difference Between HTML and URL Encode In .NET
  Khalid Abuhakmeh
• Building a Source Generator for C#
  Jonathan Allen

Hace algunos años hablábamos de que la forma más correcta de determinar si un objeto es nulo en C# era utilizando el operador is:

var invoice = _invoiceRepository.GetById(18);
if(invoice is null) 
{
    // Hacer algo
}

Como vimos en su momento, esta opción era mejor que utilizar una comparación directa como invoice == null porque el operador de igualdad podía ser sobrecargado y, por tanto, su comportamiento podría ser modificado, mientras que el operador is no es sobrecargable.

Sin embargo, al comenzar al usar esta fórmula, encontrábamos un pequeño inconveniente cuando queríamos determinar justo lo contrario, es decir, saber cuándo un objeto no es nulo, pues la sintaxis se volvía algo más pesada:

var invoice = _invoiceRepository.GetById(18);
if(!(invoice is null)) 
{
    // Hacer algo
}

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

Por si te lo perdiste...

• Trimming de espacios no significativos en Blazor 5
  José María Aguilar
• Problem Details: una forma estándar de retornar errores desde APIs HTTP (y cómo usarlo desde ASP.NET Core)
  José María Aguilar

.NET Core / .NET

• Referencias anulables en C# 8.0 y posteriores (IV): el operador ! y las propiedades anulables
  Octavio Hernandez
• Async/Await Calls Gotcha with the CSharp ? Null Propagator
  Rick Strahl
• C# 9.0 Features and Expectations of C# 10
  Dotnetsafer
• CoreWCF Reached Its First GA Release
  Almir Vuk
• Introducing: C# Pipe Extensions!
  Winston Puckett
• Conversation about PGO
  Richard Lander
• Extending the calculator implementation: Creating a Simple Moving Average calculator in C#
  Andrew Lock
• Working With .NET Console Host Lifetime Events
  Khalid Abuhakmeh
• Defining HttpClient Test Requests by Using a Bundle
  Adam Storr
• Create a colored CLI with System.CommandLine and Spectre
  Thomas Ardal
• .NET - Personal Extensions
  Cody Merritt Anhorn
• Building an Event Driven .NET Application: Setting Up MassTransit and RabbitMQ – Wrapt
  Paul DeVito
• Conversation about ready to run
  Richard Lander
• Why should you care about .NET GC…?
  Konrad Kokosa
• Authenticated Encryption in .NET with AES-GCM
  Scott Brady
• Obtaining network usage information from the Windows Runtime & Obtaining attributed network usage information from the Windows Runtime
  Raymond Chen
• Show dotnet: Investigating Alpine Linux CVEs in .NET container images
  Richard Lander
• On replacing Thread.Abort() in .NET 6, .NET 5 and .NET Core
  Patrick Smacchia