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

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?

En primer lugar, quería desearos a todos unas felices fiestas; como debe ser, espero que descanséis y aprovechéis para pasar estos días disfrutando de la familia y amigos. Y ya puestos, espero también que el 2020 sea un gran año para todos.

Pero al hilo de estas fiestas, por si alguno no estáis al tanto, me ha parecido interesante aprovechar la ocasión para contaros un curioso cuento de navidad: la que se ha liado hace unos días en el repositorio de Visual Studio Code en Github, algo que algunos ya han denominado el "SantaGate".

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

Por si te lo perdiste...

• Los diez mandamientos del egoless programming
  José María Aguilar
• Crear proyectos usando versiones específicas del SDK de .NET Core
  José María Aguilar

.NET Core / .NET

• El futuro de .NET en 2020: guía para desarrolladores (justificadamente) despistados
  José Manuel Alarcón
• Repasando Null-Coalescing Operator y Null-Coalescing Assignment Operator y convirtiendo tipos nullable a tipos no nullable
  Jorge Serrano
• Novedades de C#8: Interfaces. ¿Qué podemos esperar?
  Jorge Turrado
• Uso de yield en C#, ese pequeño desconocido
  Jorge Serrano
• Creating Common Intermediate Language projects with .NET SDK
  Filip Woj
• C# 7 ref returns and locals
  Shao Voon Wong
• User Secrets in Docker-based .NET Core Worker Applications
  Jimmy Bogard
• C# 8 Interfaces: Static Members
  Jeremy Clark
• Fuse.NET: A lightweight zero-dependency C# port of the Fuse.js fuzzy-search library
  Conna Wiles
• A Quantum Random Number Generator for .NET: The quantum measurement problem and many-worlds approach
  Andrew Lock
• Vertically Sliced Command Line Tools in C# and .NET Core 3.1
  Garo Yeriazarian
• C# 8 Interfaces: Static Main
  Jeremy Clark
• Hitchhiker’s Guide to the C# scripting
  Ali Bahraminezhad

Días atrás veíamos lo sencillo que resultaba crear un servicio gRPC que hacía uso de streaming unidireccional de mensajes, en sentido servidor-cliente. Como recordaréis, en este post implementábamos un servicio generador de números al que los clientes podrían conectarse para recibir una secuencia de enteros a intervalos periódicos.



Hoy vamos a complicar algo el escenario, pues veremos una opción aún más potente: la creación de streaming bidireccional, es decir, cómo cliente y servidor pueden enviar mensajes al lado opuesto de forma asíncrona, una vez establecida la comunicación entre ambos.

Para ello, implementaremos un sencillo juego, con las siguientes funcionalidades:

• El lado cliente, una aplicación de consola, abrirá una conexión con el servicio. En ese momento, el servidor elegirá un número al azar (1-100) y lanzará un mensaje de bienvenida, que deberá ser mostrado en el lado cliente.
• Desde el lado cliente solicitaremos al usuario un número entero, que enviaremos al servidor por el stream ascendente.
• El servidor recibirá el número y lo comparará con el que tiene almacenado, enviando por el canal descendente el resultado de la comparación.
• El proceso finalizará cuando el número sea encontrado.

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

Por si te lo perdiste...

• 101 citas célebres más del mundo de la informática (¡505 ya!)
  José María Aguilar
• Antipatrones de asincronía en C#
  José María Aguilar

.NET Core / .NET

• Runtime Host Configuration Options and AppContext data in .NET Core
  Filip Woj
• Thread-safe observable collection in .NET
  Gérald Barré
• GC Perf Infrastructure – Part 1
  Maoni Stephens
• C# 9
  Bassam Alugili
• Discriminated Unions in C# — An Unexceptional Love Story
  Zhengbo Li
• Setting assembly and nuget package metadata in .NET Core
  Cezary Piątek
• Useful ClaimsPrincipal extension methods I use in my projects
  Jerrie Pelser
• .NET Core, Docker, and Cultures - Solving a culture issue porting a .NET Core app from Windows to Linux
  Andrew Lock
• Fun with URL Encodings
  Phil Haack
• C# Channels - Timeout and Cancellation
  Denis Kyashif
• ConfigureAwait FAQ
  Stephen Toub
• Regex Performance With and Without RegexOptions.Compiled Using .NET Framework 4.8 and .NET Core 3.1 (December 2019)
  Ken Dale
• An Introduction to System.Threading.Channels
  Stephen Toub
• Demystifying the new .NET Core 3 Worker Service
  Randy Patterson
• Serialización/Deserialización Json omitiendo "JsonProperty" Name (o no)!
  Juan Luis Guerrero

Hace bien poco hablábamos de la introducción en .NET/C# de la interfaz IAsyncEnumerable, y de las interesantes posibilidades que abría vistas a la producción y consumo de streams de mensajes.

También hace unos días dimos un repaso al soporte para la implementación de clientes y servidores gRPC lanzado con ASP.NET Core 3. En dicho post hacíamos una pequeña introducción al desarrollo de este tipo de servicios, basados en HTTP/2 y el estándar protobuf.

Como ya comentábamos entonces, a diferencia de los tradicionales servicios tipo REST (HTTP/JSON), gRPC soporta el intercambio de datos en modo streaming, tanto unidireccional como bidireccionalmente. Es decir, en el escenario más complejo podríamos abrir un canal gRPC a través del cual un cliente podría ir enviando paquetes de información de forma asíncrona, y al mismo tiempo utilizarlo para recibir un flujo de datos continuo desde el servidor.

Hoy vamos a ver cómo se combinan estas características viendo un ejemplo de implementación de un servicio gRPC que utiliza streaming unidireccional, en sentido servidor-cliente.

Para ello crearemos un servicio generador de números en streaming que funcionará de la siguiente forma:

• Los clientes invocarán un procedimiento del servidor suministrándole un número entero inicial y un delay expresado en segundos.
• Como respuesta, el servidor creará un stream por el que irá enviando, según la periodicidad indicada, números consecutivos partiendo del especificado en la llamada inicial.
• El proceso finalizará, cerrando en stream, cuando el servidor haya generado 10 números, o bien cuando el cliente sea detenido.

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

Por si te lo perdiste...

• Interpolación de cadenas en C# 6
  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

• Announcing .NET Core 3.1
  Richard Lander
• .NET Core 2.2 will reach End of Life on December 23, 2019
  Lee Coward
• Updates to .NET Core Windows Forms designer in Visual Studio 16.5 Preview 1
  Olia Gavrysh
• C# - la palabra clave volatile
  Juan Carlos Ruiz Pacheco
• “Equals” and “==” are not… equal
  João Antunes
• Check for spammy email addresses when registering users
  Jerrie Pelser
• Novedades de C# 8: Índices y Rangos
  Jorge Turrado
• Exploring borrowed annotations in C#
  Jared Parsons
• How to simulate AutoMapper that works during the build time
  Cezary Piątek
• IAsyncEnumerable<T> Is Your Friend, Even In .NET Core 2.x
  Brant Burnett
• Declaring InternalsVisibleTo in the csproj
  Gérald Barré
• Remote Debugging a .NET Core Linux app in WSL2 from Visual Studio on Windows
  Scott Hanselman
• Novedades de C# 8: Índices y Rangos
  Jorge Turrado
• Controla la calidad de tu código con NDepend
  Albert Capdevila

Hace poco estaba revisando un proyecto y me topé con un problema derivado de un uso extraño de los expression bodied members, y creo que es interesante comentarlo porque, aunque probablemente la mayoría no os vayáis a encontrar con esto, seguro que puede venir bien a alguien que no tenga del todo claro cómo y cuándo se debe utilizar esta sintaxis.

Pero comencemos desde el principio...

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

Por si te lo perdiste...

• Inicialización de diccionarios en C# 6
  José María Aguilar
• Publicando nuestra web sobre Azure Web Apps
  Jorge Turrado

.NET Core / .NET

• TimeSpan configuration values in .NET Core
  Mark Seemann
• Bootstrap a .NET Core development environment for Linux
  Jim Burger
• Properly Comparing Strings with Globalization and Performance in .NET
  David McCarter
• How to Build Analyzers and Code Fixes by Roslyn using VS2019
  Ashutosh Gpt
• Embracing nullable reference types
  Mads Torgersen
• Task Parallel Library 101 Using C#
  Jin Vincent Necesario
• ElectronCGI - A solution to cross-platform GUIs for .Net Core
  Rui Figueiredo

Hace ya algún tiempo nos preguntábamos que dónde había ido a parar la directiva @helper de Razor en ASP.NET Core, y la respuesta era simple: había desaparecido.

Como recordaréis, esta directiva era bastante útil para simplificar el código de las vistas y mejorar su legibilidad, pues permitía crear funciones reutilizables que mezclaban HTML y código de servidor, como en el siguiente ejemplo:

@* File: Test.cshtml *

@Multiplication(2)
@Multiplication(3)

@helper Multiplication(int x)
{
    <h2>Multiplication table of @x</h2>
    <ul>
        @for (var i = 1; i <= 10; i++)
        {
            <li>@x * @i = @(x * i)</li>
        }
    </ul>
}

Hasta la versión 2.2, teníamos que conformarnos con apaños como los descritos en aquél post si queríamos emular lo que llevábamos tantos años utilizando con MVC 5 y anteriores. Y también entonces comentamos que había ciertas posibilidades de que en algún momento volviera a la vida, y éstas se han materializado, por fin, en ASP.NET Core 3.0.

Aunque quizás más bien habría que hablar de reencarnación...

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

Por si te lo perdiste...

• Rendimiento de nameof en C# 6
  José María Aguilar
• 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

.NET Core / .NET

• Meet WebWindow, a cross-platform webview library for .NET Core
  Steve Sanderson
• Easy unit testing of null argument validation (C# 8 edition)
  Thomas Levesque
• Augmenting the .NET Core 3.0 Generic Host
  Ian Bebbington
• Fire and forget a Task in .NET
  Gérald Barré
• Using foreach with index in C#
  Thomas Levesque
• HttpClient Connection Pooling in .NET Core
  Steve Gordon
• Using async disposable and async enumerable in frameworks older than .NET Core 3.0
  Filip Woj
• Using proper culture with C# string interpolation
  Martin Zikmund
• TaskMonitor: Free Yourself From async void and MOAR
  Jean-Marie Alfonsi
• Recommended Asynchronous Pattern in .NET
  Damir Arh
• Novedades de C# 8: Pattern Matching
  Jorge Turrado

Hace algunos meses hablábamos del peligro que suponía la la evaluación en cliente de Entity Framework Core, una característica que, por defecto, venía activada de serie. En el post explicábamos los problemas que podían dar, cómo podíamos detectar su uso e incluso impedirlo para evitar males mayores.

Pues bien, esto ha cambiado a partir de la versión 3.0, en mi opinión, hacia una dirección bastante más correcta. Veamos en qué consisten estos cambios.

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

Por si te lo perdiste...

• Software patch, literalmente
  José María Aguilar
• Shadow properties en Entity Framework Core
  José María Aguilar

.NET Core / .NET

• Announcing .NET Core 3.1 Preview 3
  Richard Lander
  
• Interfaces In C# 8.0
  Mangesh Gaherwar
  
• C# 8 Interfaces: Public, Private, and Protected Members
  Jeremy Clark
  
• Light-weight run-time composition for the .NET Core 3.0 Generic Host
  Ian Bebbington
  
• .NET Framework Repair Tool
  Namrata Karnam
  
• Use C# 8 In Any .NET Project Today
  James Montemagno
  
• How to Do Naive Bayes with Numeric Data Using C#
  James McCaffrey
  
• How YOU can make your .NET programs perceived as more responsive with Asynchronous Code in .NET Core, C# and VS Code
  Chris Noring
  
• CSharp: Convert a GUID to a Compressed GUID
  Metadata Consulting
  
• Instantiating an object without using its constructor in C#
  Filip Woj
  
• High-Performance Logging in .NET Core
  Steve Gordon
  
• What's New With C# 8.0 – Using Declaration
  Suresh M