El (relativamente desconocido) código de estado HTTP 402 (Payment required) se reservó para usos futuros hace más de veinte años, pensando que en algún momento se utilizaría para indicar al lado cliente que la operación solicitada requería "pasar por caja" antes de ser ejecutada.

Sin embargo, la idea nunca se desarrolló y, a falta de una especificación formal, no se generalizó su uso. Personalmente, jamás he implementado una API o servicio que retorne HTTP 402, pero hay algunos proveedores de servicios que sí lo hacen, aunque de forma arbitraria y no normalizada.

Esta era la píldora cultural del día, vamos con el tema que nos ocupa :)

Seguimos de encierro una semana más, aunque ya con la posibilidad de disfrutar de pequeños paseos (limitados en tiempo y distancia) o de hacer deporte en el exterior. Esto hace que el futuro se vea con algo más de optimismo, aunque espero que esta tímida apertura no provoque una vuelta atrás en los avances conseguidos hasta el momento.

Y mientras la cosa se aclara, podéis ir echando un vistazo a los enlaces recopilados durante la semana pasada que, como de costumbre, espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Limpiar la clase Startup de ASP.NET Core
  José María Aguilar
• Enumerables asíncronos en C# 8
  José María Aguilar

.NET Core / .NET

• Cómo escribir información adicional de salida en nuestros tests de xUnit
  Jorge Serrano
• Web scraping de una página web y conversión a pdf con .NET Core 3.1
  Jorge Serrano
• Work flow of diagnosing memory performance issues – Part 2
  Maoni Stephens
• Introducing C# Source Generators
  Phillip Carter
• Did you know ? Easy and custom debugging with DebuggerDisplay and DebuggerTypeProxy attributes on Visual Studio
  Anthony Giretti
• Dotnet core 3.0 Self Contained Single Executable (and other build optimisations)
  Darren Horrocks
• The Dispose Pattern is Broken
  Paulo Zemek
• Demystifying Memory Profilers in C# .NET Part 2
  Michael Shpilt
• Exception Helper – Rethrown Exceptions
  Andy Sterland
• How to use CancellationTokens to cancel operations in the Azure SDK for .NET
  Adrian Hall
• Split a string into lines without any allocation
  Gérald Barré
• INotifyPropertyChanged with C# 9.0 Source Generators
  Jerome Laban
• Performance in .NET – Part 4
  Ricardo Peres
• Access to EXIF tags in JPEG files
  Hans-Peter Kalb
• C# 8.0 nullable references: inferred (non-)nullness
  Ian Griffiths
• Markdown .NET Core Library
  Jason Gaylord

Hoy va un truquillo rápido sobre Blazor que puede resultar útil en muchos escenarios. Como probablemente sepáis, al igual que ocurre con otras tecnologías, Blazor codifica la salida HTML por motivos de seguridad, de forma que cualquier contenido con código de marcado será mostrado por defecto tal cual, sin interpretar las etiquetas.

Por ejemplo, considerad el siguiente código en un componente Blazor:

<p>This text is encoded: @myHtml</p>

@code {
    string myHtml = "Hello, <b>this is bold</b>";
}

El resultado que enviaremos al navegador es el siguiente:

<p>This text is encoded: Hello, &lt;b&gt;this is bold&lt;/b&gt;</p>

Y, por tanto, nuestros usuarios podrán leer literalmente este párrafo:

This text is encoded: Hello, <b>this is bold</b>

Normalmente no es eso lo que queremos mostrarles, ¿verdad?

Aunque seguimos en el túnel, parece que tímidamente está apareciendo un poco de luz en la lejanía. Y mientras la cosa se ilumina del todo, quizás os entretengan un rato los enlaces recopilados durante la semana pasada, que, como de costumbre, espero que os resulten interesantes. :-)

Por si te lo perdiste...

• Switch expressions en C# 8
  José María Aguilar
• Confluencia de ramas en el pipeline de ASP.NET Core
  José María Aguilar

.NET Core / .NET

• Como leer programáticamente contadores de rendimiento en .Net Core
  Jorge Turrado
• Announcing .NET 5.0 Preview 3
  Richard Lander
• Unit bias against collections
  Mark Seemann
• The Most Exciting Promise of .NET 5
  Heather Downing
• Enjoy Local Development with Tye, Docker, and .NET
  Khalid Abuhakmeh
• Building End-to-End Diagnostics and Tracing: Diagnostic Events
  Jimmy Bogard
• Nullable Reference Types: Migrating a Codebase – A Look at New Language Features in C# 8
  Matthias Koch
• Introducing Jasper as an In Process Command Bus for .Net
  Jeremy D. Miller
• C# 9 – Positional or Nominal Creation
  Christian Nagel
• Creating and Packaging a .NET Standard library
  Sayed Hashimi
• Verify User File Uploads With .NET
  Khalid Abuhakmeh
• Demystifying Memory Profilers in C# .NET Part 1: The Principles
  Michael Shpilt
• Referencing a Specific Assembly from a NuGet Package
  Maarten Balliauw
• Finalization Queue Tips
  Mark Downie
• .NET Core Tab Completion With Zsh
  Khalid Abuhakmeh

Es lógico pensar que muchas de las aplicaciones que construyamos con Blazor, sobre todo en el mundo empresarial, necesitarán acceder a bases de datos para obtener o almacenar información.

En caso de utilizar Blazor WebAssembly, ese acceso encajará conceptualmente con lo que venimos haciendo desde hace años al construir aplicaciones SPA: desde el lado cliente simplemente llamaremos a una API o endpoint que actuará como pasarela, por lo que todo el código de acceso a datos se encontrará en el servidor. Aunque existen algunas iniciativas para posibilitar que EF Core funcione directamente en el navegador con algunos proveedores, ciertamente no será el escenario habitual.

Sin embargo, si utilizamos Blazor Server, tendremos la sensación inicial de que es todo más sencillo. El código de eventos bindeados a la interfaz se ejecuta en servidor, por lo que a priori sólo tendríamos que replicar lo que solemos hacer con servicios o controladores: solicitar una instancia del contexto de datos al inyector de dependencias, y utilizarla para lograr nuestros propósitos.

Pero no, la cosa es algo más complicada que eso. De hecho, los que ya estéis creando aplicaciones Blazor Server con EF Core seguro que os habéis topado en algún momento con un error como el siguiente:

InvalidOperationException: A second operation started on this context before a previous operation 
completed. This is usually caused by different threads using the same instance of DbContext. For 
more information on how to avoid threading issues with DbContext, see 
https://go.microsoft.com/fwlink/?linkid=2097913.

Esta excepción se debe a que existen dos hilos de ejecución utilizando la misma instancia del contexto de datos al mismo tiempo, algo que Entity Framework no permite. Esto ocurrirá, por ejemplo, si tenéis en la misma página varios componentes que de forma concurrente intentan acceder a la base de datos al inicializarse.

¿Por qué ocurre esto?

Pues recién cumplidos los diez años desde que comencé a publicar enlaces de interés todas las semanas, vamos ahora a por la entrega número 400. Como siempre, espero que os resulten interesantes y os ayuden a llevar mejor estos días :)

Por si te lo perdiste...

• Novedades en la compilación de vistas en ASP.NET Core 3.0, ¡otra vez!
  José María Aguilar
• Ramificar el pipeline de ASP.NET Core con Map() y MapWhen()
  José María Aguilar

.NET Core / .NET

• Work flow of diagnosing memory performance issues – Part 1
  Maoni Stephens
• Pretty Method Display in xUnit.net
  Jason Roberts
• Using .NET Core to provide Power Query for Excel on Mac
  Oded Hanson
• A Framework to DotNet Core Conversion Report
  Mike Hadlow
• C# 8.0 nullable references: non-nullable is the new default
  Ian Griffiths
• Serilog Logging Best Practices
  Ben Foster
• C# 8, A Year Late
  Dave Brock
• .NET JIT compiler is not type safe
  Konrad Kokosa
• A little riddle with AsyncLocal
  Nelson Parente
• 7 ways to improve code quality in C# using option type
  Ahmed Fouad

Es increíble lo rápido que pasa el tiempo: aunque parezca que fue ayer, hace ya diez años que comencé a publicar enlaces interesantes en el blog, iniciando la serie con el post Enlaces interesantes 1... y en estos momentos estoy preparando la entrega semanal número 400 :)

Y para celebrarlo, he pensado que estaría bien hacer un recopilatorio de preguntas y curiosidades que los fieles seguidores de esta serie me habéis ido haciendo llegar, tanto en persona como a través de redes sociales o mails, a lo largo de estos años.

Una semana más de confinamiento, pero una semana menos para que esta pesadilla termine. Y mientras tanto, sigamos compartiendo enlaces que, como de costumbre, espero que os resulten interesantes :)

Por si te lo perdiste...

• Implementación por defecto en interfaces de C#8, un primer vistazo
  José María Aguilar
• Archivos estáticos en aplicaciones ASP.NET Core (II)
  José María Aguilar

.NET Core / .NET

• Contadores de rendimiento multiplataforma en .Net Core
  Jorge Turrado
• Resolviendo problemas con repositorios de paquetes NuGet a la hora de instalar Templates de proyectos en .NET Core
  Jorge Serrano
• .NET 5.0, VS2019 Preview and C# 9.0 for ASP .NET Core developers
  Shahed Chowdhuri
• Work flow of diagnosing memory performance issues – Part 0
  Maoni Stephens
• Mobius – .NET runtime running on .NET Core
  Konrad Kokosa
• Depending on the right PowerShell NuGet package in your .NET project
  Robert Holt
• Building End-to-End Diagnostics and Tracing: Trace Context
  Jimmy Bogard
• Move OData to .NET 5
  Sam Xu
• Memory Cache in C#
  Jaimin Shethiya
• Check Certificate Expiry Date in .NET Core
  Steve Fenton
• How are .NET APIs Designed?
  Steve Gordon
• Strangling .NET Framework App to .NET Core
  Kamil Grzybek
• HttpClient - Error handling, a test driven approach
  Josef
• Simplifying Parameter Null and Other Checks with the Pitcher Library
  Jason Roberts
• Queuing Background Jobs with Coravel
  Derek Comartin
• Using Oakton for Development-Time Commands in .Net Core Applications
  Jeremy D. Miller
• Building your First async fluent API using interface extension methods pattern
  Ahmed Fouad

Dado que la recopilación de enlaces ha sido considerada una actividad esencial, no se ha visto afectada por el parón decretado recientemente, así que ahí va la cosecha de la semana pasada :)

Como siempre, espero que os resulten interesantes y os ayuden a llevar mejor el confinamiento. ¡Que paséis una buena Semana Santa!

Por si te lo perdiste...

• Tipos referencia anulables en C# 8
  José María Aguilar
• Archivos estáticos en aplicaciones ASP.NET Core (I)
  José María Aguilar

.NET Core / .NET

• Announcing .NET 5.0 Preview 2
  Richard Lander
• .NET 5 preview support in OmniSharp and C# Extension for VS Code
  Filip Woj
• What Are .NET Worker Services?
  Steve Gordon
• Sending and Receiving JSON using HttpClient with System.Net.Http.Json
  Steve Gordon
• C# Functional Programming In-Depth (12) Immutability, Anonymous Type, and Tuple
  Dixin Yan
• Inject JsonSerializerOptions so Don't Repeat Yourself
  Adam Storr
• NLog Tutorial - The essential guide for logging from C#
  Thomas Ardal
• Writing .NET Database Integration Tests
  Khalid Abuhakmeh
• Can .NET Core Framework Assemblies be Mapped back to Individual NuGet Packages? A Detective Story
  Maarten Balliauw
• Regex Performance Improvements in .NET 5
  Stephen Toub
• Build a Windows Worker Service Using .NET Core 3.1 for Removing Old Files in Folders
  Fredrik Rudberg

Como sabemos, hasta ASP.NET Core 2.2, registrábamos los servicios de MVC y Razor Pages en el método ConfigureServices() de la clase Startup con una línea como la siguiente:

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();
    ...
}

Esto era todo lo que necesitábamos para poder utilizar cualquiera de estas tecnologías en nuestra aplicación. Sin embargo, a partir de ASP.NET Core 3.0, nuestro intellisense se vio inundado de opciones adicionales como AddControllers(), AddRazorPages() o AddControllersWithViews().

¿Para qué sirven, y por qué ha sido necesario introducir estos nuevos extensores?

Pues otra semana de encierro, y otro buen número de enlaces recopilados que, como de costumbre, espero que os resulten interesantes.

¡Cuidaos mucho!

Por si te lo perdiste...

• Null coalescing assigment "??=", el nuevo operador de asignación en C# 8
  José María Aguilar
• Acceder a arrays en settings JSON de ASP.NET Core
  José María Aguilar

.NET Core / .NET

• Variables? We Don’t Need No Stinking Variables
  Jason Roberts
• C# interop with C/C++ and Rust in WebAssembly
  Jerome Laban
• Learning and documenting .NET with dotnet try
  Bruno Sonnino
• NServiceBus and .NET Core Generic Host
  Jimmy Bogard
• Suppressing Disassembly
  Mark Downie
• Sanitize HTML snippets with AngleSharp
  Gérald Barré
• Use NodaTime to replace C# DateTime
  Matteo Locher
• Controlling the Serial and Parallel Test on XUnit
  Tsuyoshi Ushio
• ElectronCGI 1.0 - Cross-platform GUIs for .Net Core
  Rui Figueiredo
• Using HttpCompletionOption to Improve HttpClient Performance in .NET
  Steve Gordon
• Getting Started With .NET Localization
  Khalid Abuhakmeh
• Adding Tuple Support to .NET Classes in C#
  Jason Roberts
• Optimising C# for a serverless environment
  Carmel Eve
• Generator Pattern using CSharp and Linq
  Ahmed Fouad
• .NET 5: Merging .NET Core and .NET Standard with New Target Framework Monikers (TFMs)
  Thomas Claudius Huber
• ValueTask Restrictions
  Stephen Cleary

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...