Al comenzar con Blazor, seguro que veis en la mayoría de ejemplos que la implementación de la lógica (código C#) y de la pura interfaz de usuario (HTML) se encuentran en un bloque @code en el mismo archivo .razor, como en el siguiente bloque de código:

@* File: ~/Pages/HelloWorld.razor *@
@page "/hello"
<h1>Hello</h1>
<div>
    <label for="name">Your name:</label>
    <input id="name" @bind-value="Name" @bind-value:event="oninput"/>
</div>
@if (HasName)
{
    <h2>Hello, @Name!</h2>
}

@code
{
    public string Name { get; set; }
    public bool HasName => !string.IsNullOrWhiteSpace(Name);
}

Sin embargo, esto no tiene que ser necesariamente así. En tiempo de compilación, un archivo .razor genera una clase parcial C# con su mismo nombre, lo cual nos brinda la posibilidad de mover todo el código C# a otra porción de dicha clase.

Podéis ver las clases generadas para cada archivo .razor en la carpeta del proyecto obj\debug\netcoreapp3.1\Razor\Pages.

Ahí van los enlaces recopilados durante la semana pasada. Espero que os entretengan, al menos un ratillo, durante el confinamiento :-)

Por si te lo perdiste...

• Convenciones personalizadas en ASP.NET Core MVC
  José María Aguilar
• Etiquetado de consultas en Entity Framework 6
  José María Aguilar

.NET Core / .NET

• Cannot get the value of a token type ‘Number’ as a string con System.Text.Json
  Jorge Serrano
• El fin de Visual Basic .NET ya ha empezado
  José Manuel Alarcón
• Announcing .NET 5 Preview 1
  Scott Hunter
• Using Windows Antimalware Scan Interface in .NET
  Gérald Barré
• Introducing Clippit, get your slides out of PPTX.
  Sergey Tihon
• Translating C# Lambda Expressions to General Purpose Filter Descriptors & HTTP Query Strings
  Kamran Saeedi
• Immutable types in C# with Roslyn
  Cezary Piątek
• C# developers! Your scoped components are more dangerous than you think
  Jonathan George
• Async ValueTask Pooling in .NET 5
  Stephen Toub
• A couple of nice Tuple use cases | Joseph Woodward, Software Developer"
  Joseph Woodward
• Upgrading from ASP.NET Core 3.1 to 5.0 (Preview 1)
  Steve Gordon
• VB.NET is done, not dead
  Matt Lacey
• Is C# Slower Than C++?
  Michael Shpilt
• Lazily resolving services to fix circular dependencies in .NET Core
  Thomas Levesque
• Introducing Ais.Net – High-Performance Parsing in C#
  Ian Griffiths
• Lessons learned porting Octopus Server to .NET Core 3.1
  Rob Pearson
• C#: Why You Should Prefer the is Keyword Over the == Operator – Thomas Claudius Huber
  Thomas Claudius Huber

Hace unos días han anunciado la disponibilidad de una herramienta que os puede interesar si, como un servidor, acumuláis un gran número de versiones del SDK y runtimes de .NET Core que no váis a necesitar, algo muy propio de ese Diógenes digital que todos llevamos dentro ;)

El estado actual de acumulación de SDKs podéis conocerlo muy fácilmente desde línea de comandos utilizando la orden dotnet --list-sdks:

C:\>dotnet --list-sdks
1.1.11 [C:\Program Files\dotnet\sdk]
2.1.202 [C:\Program Files\dotnet\sdk]
2.1.503 [C:\Program Files\dotnet\sdk]
2.1.504 [C:\Program Files\dotnet\sdk]
2.1.505 [C:\Program Files\dotnet\sdk]
2.1.507 [C:\Program Files\dotnet\sdk]
2.1.508 [C:\Program Files\dotnet\sdk]
2.1.509 [C:\Program Files\dotnet\sdk]
2.1.511 [C:\Program Files\dotnet\sdk]
2.1.602 [C:\Program Files\dotnet\sdk]
2.1.604 [C:\Program Files\dotnet\sdk]
2.1.700 [C:\Program Files\dotnet\sdk]
2.1.701 [C:\Program Files\dotnet\sdk]
2.1.800-preview-009696 [C:\Program Files\dotnet\sdk]
2.1.801 [C:\Program Files\dotnet\sdk]
2.1.802 [C:\Program Files\dotnet\sdk]
2.2.102 [C:\Program Files\dotnet\sdk]
2.2.105 [C:\Program Files\dotnet\sdk]
2.2.202 [C:\Program Files\dotnet\sdk]
2.2.203 [C:\Program Files\dotnet\sdk]
2.2.204 [C:\Program Files\dotnet\sdk]
3.0.100-preview8-013656 [C:\Program Files\dotnet\sdk]
3.0.100-preview9-014004 [C:\Program Files\dotnet\sdk]
3.0.100 [C:\Program Files\dotnet\sdk]
3.1.100 [C:\Program Files\dotnet\sdk]
3.1.101 [C:\Program Files\dotnet\sdk]
3.1.102 [C:\Program Files\dotnet\sdk]

C:\>_

En mi caso, tengo aún por ahí el SDK de .NET Core 1.x, un par de decenas de .NET Core 2.x, y algunas previews, pero los he visto mucho peores ;) Obviamente, salvo dos o tres versiones que quizás me interesen porque tengo aplicaciones que aún no he migrado, el resto ocupan en mi equipo un espacio considerable sin motivo, más de 5GB, pues cada SDK puede pesar entre 150 y 200 Mb.

Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes, ¡y que los veáis desde casa, que la cosa se está poniendo muy muy fea! ¡Cuidaos mucho!

Por si te lo perdiste...

• Etiquetado de consultas en Entity Framework Core
  José María Aguilar
• La directiva @helper no existe en MVC Core 1.0
  José María Aguilar

.NET Core / .NET

• Announcing the .NET Core Uninstall Tool 1.0
  Sarah Oslund
• Visual Basic support planned for .NET 5.0
  .NET Team
• Microsoft: 'We Do Not Plan to Evolve Visual Basic as a Language'
  David Ramel
• Your C# is already functional, but only if you let it
  Igal Tabachnik
• Morestachio 3.0. An Evolving .NET TextEngine
  Jean-Pierre Bachmann
• Improving list sum function based on head and tail with C# 8
  Jiří Činčura
• Passing awaited tasks
  Eric Lippert
• Some more C# 8
  Tom Deseyn
• Microsoft Dotnet Gitignore File
  Vijay Ganesh
• C# Implementation of Basic Linear Algebra Concepts
  Mohammad Elsheimy
• C#: Different ways to Check for Null – Thomas Claudius Huber
  Thomas Claudius Huber

 Alguna vez he escuchado, a modo de leyenda urbana, que no era bueno utilizar try/catch porque el mero hecho de usar este tipo de bloque de código afectaba al rendimiento.

La verdad es que de forma intuitiva se puede adivinar que esto no debería ser así. Si no se producen excepciones en un código que tengamos envuelto en un try/catch se debería ejecutar virtualmente a la misma velocidad que si no usáramos este tipo de bloque. Cosa distinta es si producen excepciones: ahí el rendimiento sí se verá seriamente penalizado, pero no es culpa del try/catch sino del propio sistema de gestión de excepciones de .NET.

Pero claro, lo dicho anteriormente es sólo cierto si somos capaces de demostrarlo, así que usaremos nuestro viejo conocido BenchmarkDotnet para desmontar este mito.

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

Por si te lo perdiste...

• Índices y rangos en C# 8 (2 de 2)
  José María Aguilar
• ¿Cuál es el "Bus factor" de tu proyecto?
  José María Aguilar

.NET Core / .NET

• Nuevo curso: Testing de aplicaciones .NET y .NET Core
  CampusMVP
• Fin de soporte de .NET Core 3 ¿y ahora qué?
  Jorge Serrano
• Creando un Servicio Windows con .NET Core 3.1
  Jorge Serrano
• Introducing perfolizer
  Andrey Akinshin
• .NET Threading and WebAssembly
  Jerome Laban
• Why do I rag on BinaryFormatter?
  Marc Gravell
• C# 8 default interface methods
  Tom Deseyn
• Optimize struct performances using StructLayout
  Gérald Barré
• Analysing .NET start-up time with Flamegraphs
  Matt Warren
• How to write a Roslyn Analyzer
  Mika Dumont
• Functional Programming Optics in .NET
  William Barbosa
• Upgrade Your .NET Console App Experience
  Khalid Abuhakmeh
• C# 8 nullable reference types
  Tom Deseyn
• Patrik Svensson - How to write a stateful Roslyn analyzer
  Patrik Svensson
• C#: The Order of Interfaces Is Important for Casting Performance
  Thomas Claudius Huber

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

Por si te lo perdiste...

• Índices y rangos en C# 8 (1 de 2)
  José María Aguilar
• Añadir o eliminar encabezados de respuesta en ASP.NET Core y Core MVC
  José María Aguilar

.NET Core / .NET

• Windows Forms y el regreso de su diseñador en .NET Core 3
  Elena Guzmán
• Cómo escribir un logger de alto rendimiento para .Net Core
  Jorge Turrado
• .NET Core 3.0 will reach End of Life on March 3, 2020
  Lee Coward
• Dos and Don'ts of stackalloc
  Kevin Jones
• Struct equality performance in .NET
  Gérald Barré
• C# 8 asynchronous streams
  Tom Deseyn
• .NET Core/Standard Auto Incrementing Versioning
  Sacha Barber
• Provisional Mode
  Maoni Stephens
• C# 8 pattern matching
  Tom Deseyn
• Using the LINQ OrderBy operator with null values
  Jerrie Pelser
• Putting the Fun in C# Local Functions
  Rion Williams
• C# - Sealed and internal - how to use in unit test?
  Josef Ottosson
• Why is decompilation possible?
  Mark Downie

Pues va un post cortito a modo de autorecordatorio, porque es algo que me ha pasado ya varias veces y siempre tengo que ponerme a investigar cómo solucionarlo.

Personalmente me gusta tener todos los entornos y herramientas de desarrollo en inglés, básicamente porque cuando encontramos problemas es más fácil encontrar soluciones si a la hora de buscar utilizamos los términos en este idioma... bueno, y de paso, evito ver algunas traducciones terribles ;)

Pues bien, en el caso del SDK de .NET Core, el idioma no es una característica que podamos elegir a la hora de instalarlo. Se instalarán todos los idiomas disponibles (podéis verlo por ejemplo en la carpeta %programfiles%\dotnet\sdk\3.1.101), y los mensajes se mostrarán en el idioma configurado por defecto en nuestra máquina. En mi equipo, por ejemplo, se muestra todo en idioma español:

C:\>dotnet xyz
No se pudo ejecutar porque no se encontró el comando o archivo especificados.
Algunas de las posibles causas son:
  * Escribió mal un comando dotnet integrado.
  * Intentó ejecutar un programa .NET Core, pero dotnet-xyz no existe.
  * Tiene planeado ejecutar una herramienta global, pero no se encontró un ejecutable 
    con prefijo dotnet con este nombre en la RUTA DE ACCESO.

C:\>_

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

Por si te lo perdiste...

• Value Converters en Entity Framework Core
  José María Aguilar
• Custom middlewares en ASP.NET Core
  José María Aguilar

.NET Core / .NET

• Conocer el índice del elemento de una iteración dentro de un foreach
  Jorge Serrano
• Under the hood of “Default Interface Methods”
  Matt Warren
• 12 things you need to know about .Net Core
  Michał Białecki
• LINQ in C# Explained In Five Minutes
  Petey
• C# - Sealed and internal - how to use in unit test?
  Josef Ottosson
• Are you reading the "What's New" in .NET docs?
  Shayne Boyer
• Apache Kafka for .NET developers
  Ruslan Albu
• Intro To Pattern Matching
  Bassam Alugili

En muchas ocasiones, la llegada de una nueva versión de un framework viene acompañada de documentación, posts y otro tipo de contenidos que anuncian a bombo y platillo las principales novedades y cambios introducidos. Ante este ruido, es fácil pasar por alto otros pequeños cambios que introducen mejoras a los marcos de trabajo o simplemente permiten ir evolucionando código antiguo a funcionalidades más recientes.

Hoy vamos a hablar de una de eso pequeños descubrimientos: el rutado dinámico de controladores. Introducido en ASP.NET Core 3, se trata de una característica que no ha sido especialmente publicitada ni comentada, pero puede ser de utilidad en algunas ocasiones, pues permite interferir en la forma de interpretar las rutas de las peticiones entrantes con objeto de decidir en cada caso cómo deben ser procesadas.

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

Por si te lo perdiste...

• Ámbito local implícito en sentencias using de C# 8
  José María Aguilar
• Cacheo de porciones de vistas en ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• Escribiendo código de alto rendimiento en .Net Core
  Jorge Turrado
• Announcing .NET Interactive - Try .NET includes .NET Notebooks and more
  Scott Hanselman
• C# to C# Communication: REST, gRPC and everything in between
  Michael Shpilt
• Producing Multiple Related NuGet Packages from a Single Git Repo
  Mark Heath
• How to protect against XML vulnerabilities in .NET
  Gérald Barré
• How to run ASP.NET Core as a service on Linux (RHEL)
  Niels Swimberghe
• How to send emails from C#/.NET
  Thomas Ardal
• Binding Redirects
  Nick Craver
• Save Your C# Keystrokes With Tuples
  Khalid Abuhakmeh
• Get started with .NET Generic Host » André Snede Kock
  André Snede Kock
• Simplifying Parameter Null and Other Checks with the GuardClauses Library
  Jason Roberts
• Iterators in C#, IEnumerable<T>, and IAsyncEnumerable<T>
  Spencer Schneidenbach
• The Maybe Monad in C#: More methods
  Yacoub Massad
• The most dangerous constructor in .NET » André Snede Kock
  André Snede Kock
• Clean up your .NET with the Dispose Pattern
  Nick Proud
• Creating .NET Core global tools on macOS
  Sayed Hashimi
• Mono: From Xamarin to WebAssembly, Blazor, and .NET 5
  Arthur Casals

Como sabemos, para ejecutar cualquier tipo de aplicación .NET Core en un equipo necesitamos tener instalado el runtime o el SDK de la plataforma. Esto es algo que podemos hacer muy fácilmente, simplemente acudiendo a la página oficial de descargas, eligiendo nuestro sistema operativo y siguiendo las instrucciones de instalación.

El hecho de que en el equipo destino esté preinstalado el runtime es muy interesante, entre otras cosas porque permite asegurar de antemano que en él se encontrarán todas las dependencias (frameworks, bibliotecas, paquetes, metapaquetes) necesarios para una correcta ejecución. Por tanto, para distribuir nuestra aplicación sólo debemos generar lo relativo a nuestro código, el resto ya estará allí.

Esta forma de publicar aplicaciones se denomina framework-dependent, pues dependen de que determinados componentes del framework estén instalado en el destino.

Por ejemplo, el paquete de publicación de una aplicación de consola prácticamente vacía, que únicamente muestra el mensaje "Hello world!", ocuparía solo 175K:

D:\MyConsoleApp\output>dir

 El volumen de la unidad D es Datos
 El número de serie del volumen es: 8CBC-81E3

 Directorio de D:\MyConsoleApp\output

09/02/2020  18:47    <DIR>          .
09/02/2020  18:47    <DIR>          ..
09/02/2020  18:46               428 MyConsoleApp.deps.json
09/02/2020  18:46             4.608 MyConsoleApp.dll
09/02/2020  18:46           169.984 MyConsoleApp.exe
09/02/2020  18:46               668 MyConsoleApp.pdb
09/02/2020  18:46               154 MyConsoleApp.runtimeconfig.json
               5 archivos        175.842 bytes
               2 dirs  463.058.874.368 bytes libres

D:\MyConsoleApp\output>_

Otra ventaja de este tipo de distribución es que es cross platform pura, es decir, podemos copiar los archivos a cualquiera de los sistemas operativos soportados y, siempre que dispongan del runtime, nuestra aplicación podrá correr sobre ellos sin problema.

Y todo esto está muy bien, pero, ¿qué pasa si quiero crear una aplicación portable, de forma que pueda distribuirla y ejecutarla sin necesidad de que el equipo destino tenga nada preinstalado?

Pues eso es lo que veremos en este post ;)

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

Por si te lo perdiste...

• Constructores con parámetros en entidades EF Core
  José María Aguilar
• Creación de enlaces con tag helpers de ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• C#: Equals y ref structs
  Eduard Tomás
• .NET Interactive is here! | .NET Notebooks Preview 2
  Maria Naggaga
• Creating Certificates in .NET Core for Vue.js development using HTTPS
  Damien Bowden
• NAudio 1.10 released with .NET Core 3 support
  Mark Heath
• Non-exceptional averages
  Mark Seemann
• The design and implementation of a better ThreadLocal<T>
  Oren Eini
• Check if the current user is an administrator
  Gérald Barré
• Tips & tricks for unit testing in .NET Core 3: Using and mocking ISystemClock instead of using DateTime & Checking matching and non matching arguments on ILogger & Mocking IHttpContextAccessor
  Anthony Giretti
• C# how to convert a string to int
  Thomas Ardal
• C# 8.0 Using Declaration
  Dirk Strauss
• Hosting your own NuGet Server and Feed for build artifacts with BaGet
  Scott Hanselman
• C# 8.0 - What C# version does my App use?
  Dirk Strauss
• GC Handles & Garbage Collection at Food Courts
  Maoni Stephens

Días atrás veíamos cómo utilizar Swashbuckle para generar automáticamente la descripción OpenAPI de APIs creadas con ASP.NET Core MVC y ponerlas a disposición de los consumidores en una ruta específica:
 

En este post vamos a ver un par de formas de sacar provecho de esta descripción:

• En primer lugar, usaremos Swagger UI para generar un sitio web interactivo de documentación y pruebas de nuestra API.
• Después, veremos cómo generar desde Visual Studio código cliente para acceder a la API.

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
  José María Aguilar
• Backing fields en Entity Framework Core
  José María Aguilar

.NET Core / .NET

• Cómo hacer mock de ILogger en .Net Core 3.x durante las pruebas
  Jorge Turrado
  
• NetCore 3 - NativeLibrary: ¡p/invoke a tope!
  Eduard Tomás
  
• Autofac 5.0 Released
  Travis Illig
  
• Prevent Zip bombs in .NET Prevent Zip Slip in .NET
  Gérald Barré
  
• Dynamically Loading Types in .NET Core with a Custom Assembly Load Context
  Jeremy Clark
  
• TraceProcessor 0.3.0
  David Matson
  
• Top 10 .NET Core Libraries Every Web Developer Should Know
  Nagaraj Marisamy
  
• Optimizing string.Count all the way from LINQ to hardware accelerated vectorized instructions
  Sergio Pedri
  
• C# Futures: Primary Constructors
  Jonathan Allen
  
• C# Coding Standards
  Jesse Liberty
  
• Deserializing JSON into polymorphic classes with System.Text.Json
  Maarten Balliauw
  
• Dependency injection in .net core console application
  Pradeep Loganathan

La OpenAPI Specification (OAS) es un estándar abierto para la descripción de APIS REST promovido por la Iniciativa OpenAPI, un consorcio de compañías de primer nivel como Microsoft, Google, IBM, Paypal y otros.

El objetivo de OpenAPI es conseguir una fórmula normalizada para describir las capacidades de un servicio REST, independientemente de los lenguajes o tecnologías con las que sea implementado. Esta descripción, normalmente especificada en formato JSON o YAML, permite a clientes (sean humanos o máquinas) descubrir servicios, comprender sus capacidades y conocer sus detalles de funcionamiento sin necesidad de tener acceso a su código fuente o documentación textual.

Esta especificación formal abre interesantes posibilidades, pues a partir de la definición estandarizada de servicios es posible, entre otros,

• disponer de herramientas de diseño y modelado de servicios,
• generar automáticamente páginas de documentación,
• generar automáticamente código cliente y servidor para dichos servicios para distintos, frameworks y lenguajes de programación,
• generar automáticamente código de testing y validaciones,
• o generar automáticamente mocks de servicios.

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
• Tag helpers en ASP.NET Core MVC: Introducción
  José María Aguilar

.NET Core / .NET

• Windows Forms en .NET Core: Controles inexistentes y cómo sustituirlos
  CampusMVP
• WPF y netcore3 con custom host
  Eduard Tomás
• Using Local Functions to Replace Comments & Refactoring Code to Use C# Local Functions
  Jason Roberts
• Behind the compiler: 20 examples of C# code before and after compiling
  Gunnar Peipman
• Avoiding the Debugger with Better Logging
  K. Scott Allen
• .NET everywhere apparently also means Windows 3.11 and DOS
  Scott Hanselman
• Generating Mazes in a Browser
  Jeremy Clark
• Getting the Most Out of Application Insights for .NET (Core) Apps
  Dave Paquette
• Developing Mobile Applications in .NET
  Damir Arh
• A Custom Renderer Extension for Markdig
  K. Scott Allen
• C# Futures: Covariant Return Types
  Jonathan Allen

ASP.NET Core / ASP.NET

• Using NSwag to Generate Blazor Server Client for an ASP.NET Core 3.1 API
  Eric L. Anderson
• Deploying Blazor apps to Azure Storage account
  Anuraj Parameswaran
• The Future of Blazor is Native Apps
  Matthew MacDonald
• 6 Blazor component libraries to speed up your development
  Jon Hilton
• Scaffolding Syncfusion Controls in ASP.NET Core Applications
  Kannan
• Cookies and Consent in ASP .NET Core 3.1
  Shahed Chowdhuri
• User Registration with ASP.NET Core Identity
  Marinko Spasojevic
• Excluding health check endpoints from Serilog request logging: Using Serilog.AspNetCore in ASP.NET Core 3.0
  Andrew Lock
• Check and log multiple registrations of a same service in ASP.NET Core 3.1 & Remove unwanted instances from ServiceCollection in ASP.NET Core 3.1
  Anthony Giretti
• Blazor State Management
  Jeremy Likness
• Globally Require Authenticated Users By Default Using Fallback Policies in ASP.NET Core
  Scott Sauber
• Sharing Data and Splitting Components in Blazor
  Peter Vogel
• Understanding how to port your ASP.NET web apps to ASP.NET Core
  Mike Finley

Recuerdo que la primera vez que, en una de mis visitas a Redmond, vi a Steve Sanderson haciendo una demo de Blazor "en vivo" me pareció casi magia: una aplicación web SPA cuya lógica de presentación y UI se implementaba exclusivamente en C#, eliminando por completo de la ecuación a Javascript. ¡Uau!

En aquellos tiempos era aún poco más que un prototipo y no se podía saber si aquella línea de investigación llevaría a alguna parte, pero era tan prometedor que, algún tiempo después, a primeros de 2018, Blazor pasó a ser un proyecto experimental del equipo ASP.NET de Microsoft.

A partir de ese momento se fueron despejando las incógnitas que quedaban en cuanto a la viabilidad real de convertir aquello en un producto y se continuaron implementando funcionalidades, hasta que, en abril de 2019, Daniel Roth anunció que daban por concluida la fase experimental y Blazor entraba oficialmente a formar parte del stack de tecnologías para la web.

A día de hoy, Blazor es un framework completo para el desarrollo de aplicaciones web SPA, como lo pueden ser Angular, React o Vue. Dispone de sistema de bindings, routing, componentes, ciclo de vida, validaciones, plantillas, gestión de errores, inyección de dependencias, etc. Todo lo que podemos necesitar para crear aplicaciones web profesionales de calidad.

La primera versión de Blazor se lanzó acompañando a .NET Core 3.0 en Septiembre de 2019, aunque sólo en uno de sus modelos de hospedado: el denominado server-side o Blazor Server.

Pero no era ese el único plan...

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

Por si te lo perdiste...

• Antipatrones de asincronía en C#
  José María Aguilar
• El archivo _ViewImports en ASP.NET Core MVC
  José María Aguilar

.NET Core / .NET

• Digest Authentication en .NET Core 3.x
  Jorge Serrano
  
• Type.GetType Functionality Has Not Changed in .NET Core
  Jeremy Clark
  
• The Reunification of .NET 5
  Matthew MacDonald
  
• Implementing State in .NET Core gRPC Messages with oneof
  Peter Vogel
  
• C# 8.0: Understanding Using Declarations
  Steve Gordon
  
• C# 9 Proposals: Module Initializers
  Jonathan Allen
  
• Collecting and analyzing memory dumps
  Sourabh Shirhatti
  
• C# Futures: Simplified Parameter Null Validation
  Jonathan Allen
  
• SelfServe: A Self-hosting Self-installing Windows Service
  Honey the codewitch
  
• UTF-8 BOM adventures in C#
  Daniel Wertheim
  
• Not planning now to migrate your .NET 4.8 legacy, is certainly a mistake
  Patrick Smacchia
  

Las Razor Class Libraries (RCL) constituyen una interesante fórmula para crear componentes redistribuibles de interfaz de usuario para aplicaciones basadas en ASP.NET Core MVC o Razor Pages. En las bibliotecas de clases de este tipo podemos incluir controladores, view components, tag helpers o vistas y páginas Razor, elementos que estarán disponibles en las aplicaciones que las referencien, bien directamente o bien a través del paquete NuGet en el que las distribuyamos.

Sin embargo, es menos conocido el hecho de que estas bibliotecas pueden incluir también recursos estáticos como imágenes, hojas de estilo o scripts, lo que resulta bastante interesante a la hora de crear componentes totalmente autosuficientes y muy reutilizables.

En este post vamos a ver cómo crear una RCL redistribuible que definirá el tag helper <mario>, cuya inclusión en una página hará que ésta muestre el conocido personaje correteando por la pantalla, como se muestra en la siguiente captura:

Ahí van un buen puñado de enlaces recopilados durante las semanas anteriores. Como siempre, espero que os resulten interesantes. :-)

Por si te lo perdiste...

• ¿Cómo se llama el operador "-->" de C#?
  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

• Trabajando con documentos JSON en .NET Core 3.x, Parte I y Parte II
  Jorge Serrano
• Utilizando la librería BenchmarkDotNet
  Jorge Serrano
• Controversial extension methods: CastTo<T> and As<T>
  Raymond Chen
• C# 8 is old news. Onward, to C# 9!
  Calvin A. Allen
• Abusing Extension Methods and Null Continuation
  Marc Clifton
• Tracing .NET Core applications
  Tom Deseyn
• Commenting out Code in C# (Oldie but Goldie Tip) & Quick #if … #endif in Visual Studio
  Roland Weigelt
• Check for Breaking Changes with ApiCompat
  Stuart Lang
• Happy New ... C# 9 Features!
  Rion Williams
• MediatR 8.0 Released
  Jimmy Bogard
• What dotnet new Could Be
  Muhammad Rehan Saeed
• Chaos Engineering your .NET applications using Simmy
  Joseph Woodward
• Building a self-contained game in C# under 8 kilobytes
  Michal Strehovský
• Multiplatform Desktop HTML Editor with .NET Core 3 and Electron.NET
  Erik Engineer
• C# Channels - Async Data Pipelines
  Denis Kyashif
• .NET Core, .NET 5; the exodus of .NET Framework?
  Marc Gravell
• Building a Windows service with Worker Services and .NET Core 3.1, part 1: Introduction
  Anthony Giretti
• The case of the unbalanced brackets
  Mark Seemann
• C# boxing with string concatenation and interpolation
  Fons Sonnemans
• Using Type.GetType with .NET Core / Dynamically Loading .NET Standard Assemblies in .NET Core
  Jeremy Clark
• How to Design Messages for gRPC Services in .NET Core
  Peter Vogel
• Static Initializers in C#: A Cautionary Tale
  Edin Kapić
• .NET Core: Writing Really Obvious Code with Enumerated Values in gRPC Web Services & Reusing and Recycling Data Structures in gRPC Services in .NET Core
  Peter Vogel

Estrenamos este nuevo año y década (aunque esto último es bastante más discutible) siguiendo una de las grandes tradiciones de este blog: dedicar el primer post a repasar cuál fue el contenido publicado durante los doce meses anteriores que más os llamó la atención.

Pero antes, abusando de este pequeño slice de atención que me estáis prestando en este momento, quería aprovechar para desearos un 2020 repleto de salud y alegría, tanto en el plano personal como en el profesional.

Y ahora, al turrón...

Un reciente estudio de la consultora Garner indica que durante el desarrollo de una aplicación dedicamos más del 80% de nuestro tiempo a implementar controles de posibles fallos.

Además, este otro informe de StackOverflow obtenido tras analizar el código fuente de miles de proyectos open source, el control y tratamiento de excepciones y problemas supone más del 60% de nuestra base de código y, por tanto, aporta gran parte de la complejidad interna de las aplicaciones.

Pero, adicionalmente, estos estudios ponen al descubierto otros tres aspectos bastante interesantes:

• Primero, que la mayoría de errores que intentamos controlar no se van a producir nunca. Son posibles a nivel de flujo de código, pero en la operativa de la aplicación no ocurrirán, por lo que podríamos decir que son problemas creados artificialmente durante el proceso de desarrollo.
   
• Segundo, las líneas de control de errores no están exentas de problemas, por lo que muy a menudo encontraremos en ellas nuevo código de control (¿quién no ha visto try/catch anidados a varios niveles?), por lo que la bola de nieve no para nunca de crecer: código de tratamiento de errores que a su vez contiene código de tratamiento de errores, y así hasta el infinito.
   
• Y por último, también nos encontramos con que en muchas ocasiones el código de control no hace nada. Por ejemplo, se cuentan por millones las líneas de código detectadas en Github cuyo tratamiento de excepciones consiste simplemente en la aplicación a rajatabla del Swallow Design Pattern, por ejemplo, implementando bloques catch() vacíos.

Y conociendo estos datos, ¿por qué dedicamos tanto tiempo a la gestión de errores en nuestro código? Pues básicamente porque hemos sido educados para eso. Exceptuando cuando se nos cala el coche, no hay nada que suponga un golpe al ego tan importante como cuando una de nuestras aplicaciones falla, y por eso no escatimamos recursos a la hora de evitarlo.

¿No estaría bien poder ignorar esos problemas y centrar nuestro código en aportar valor a nuestros clientes?