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

Por si te lo perdiste...

• El Tao de la Programación
  José María Aguilar
• Mi controlador tiene muchos parámetros en el constructor, ¿estoy haciendo algo mal?
  José María Aguilar

.NET / .NET Core

• La potencia de la Reflexión en C# (Parte 2: Ensamblados)
  Jorge Turrado
• Top five tips for handling .NET Exceptions
  Justin Miller
• Microsoft Feature Toggle Feature Flag Library: A First Look
  Jason Roberts
• Find, Fix, and Avoid Performance Problems in C# .NET: 10 Best Practices
  Michael Shpilt
• Questions from the NDC Oslo Panel Discussion on the Future of .NET
  K. Scott Allen
• Selective enrichment
  Nicholas Blumhardt
• C# 8 Features Nullable References
  Peter Mbanugo
• Using C# anonymous types to assert complex results in your unit tests
  Dror Helper
• Use Polly fallback policies for default return values
  Jerrie Pelser
• Versioning limitations in .NET
  Jon Skeet

ASP.NET / ASP.NET Core

• gRPC – Hello World
  Jorge Serrano
• gRPC y “no gRPC” todo junto en el mismo proyecto & Traducir entre gRPC y HTTP/JSON
  Eduard Tomás
• Routing in ASP.NET Core MVC
  Marinko Spasojevic
• Creating a Custom Tag Helper in ASP.NET Core: Generating HTML
  Peter Vogel
• Web.config transformations - The definitive syntax guide
  Thomas Ardal
• Using Blazor Components In An Existing MVC Application
  Chris Sainty
• Decode JWTs in C# for Authorization
  Ryan Foster
• Ensuring consistent feature flags across requests: Adding feature flags to an ASP.NET Core app
  Andrew Lock
• Access your local ASP.NET Core web application from the public web & Use Conveyor to access your IIS Express app over the internet Jerrie Pelser
• ASP.NET Core Vue CLI Templates
  Daniel Jimenez Garcia
• Using Chained Certificates for Certificate Authentication in ASP.NET Core 3.0
  Damien Bowden
• Using the BodyReader and BodyWriter in ASP.NET Core 3.0
  Steve Gordon

Pues hablábamos hace unos días del extensor TagWith() de Entity Framework Core que, como recordaréis, venía de perlas para incluir un comentario en las consultas SQL enviadas al servidor de datos para poder identificarlas a posteriori:

LINQ
============================================
var query = context.Friends
    .OrderByDescending(friend => friend.Age)
    .Take(10)
    .Select(friend =>
        new { FriendName = friend.Name, 
              friend.Age, 
              CountryName = friend.Country.Name 
     })
    .TagWith("Get top 10 older friends with country");

Generated SQL
============================================
-- Get top 10 older friends with country

SELECT TOP(@__p_0) [friend].[Name] AS [FriendName], [friend].[Age], 
                   [friend.Country].[Name] AS [CountryName]
FROM [Friends] AS [friend]
LEFT JOIN [Countries] AS [friend.Country] 
     ON [friend].[CountryId] = [friend.Country].[Id]
ORDER BY [friend].[Age] DESC

Mientras escribía el post, pensaba que quizás sería interesante poder utilizar esta misma idea en Entity Framework 6, porque, al fin y al cabo, todos tenemos por ahí muchas aplicaciones en producción que continúan delegando en este marco de trabajo su acceso a datos. Tras una búsqueda en Google y no encontrar gran cosa, pensé que tampoco sería tan difícil de implementar algo que diera el apaño...

TL;DR: Echad un vistazo a EF6.TagWith en NuGet o en el repo de GitHub.

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

Por si te lo perdiste...

• El veloz murciélago hindú…
  José María Aguilar
• Establecer textos por defecto y localizados en validaciones de ASP.NET Core MVC
  José María Aguilar

.NET / .NET Core

• Making a tiny .NET Core 3.0 entirely self-contained single executable
  Scott Hanselman
• Using pointers in Image Processing
  Napuzba
• Parsing HTML data with C#
  Bruno Sonnino
• Net Core (Linux) Error: System.IO .IOException: The configured user limit on the number of inotify instances has been reached
  Eduard Tomás
• async y await en C#: cómo manejar asincronismo en .Net de manera fácil
  Jorge Turrado
• Cryptography in .NET
  Gérald Barré
• The Evolving Infrastructure of .NET Core
  Matt Mitchell
• Create interactive documentation with the new Try .NET template
  Akshita Agarwal
• Delegates as callback functions in csharp
  Karthik Chintala
• C# - The good parts
  Sam Williams
• Using High-Performance Techniques to Base64 Encode a GUID
  Steve Gordon
• Communicating between Python and .NET Core with Boost Interprocess
  Jared Rhodes

Como sabemos, las consultas que definimos mediante LINQ contra conjuntos de datos de Entity Framework son traducidas automáticamente a queries SQL, que es lo que finalmente ejecuta el servidor de base de datos.

Muchas veces estas sentencias SQL generadas de forma automática y ejecutadas al servidor son fáciles de leer y entender, pero hay veces que EF traduce el LINQ a consultas SQL enormes, complejas, con escasa legibilidad y difícilmente reconocibles.

Seguro que alguna vez habéis tenido por delante una de estas complejas sentencias SQL generada por Entity Framework y os hubiera gustado saber en qué punto del código fue lanzada. Esto es muy frecuente, por ejemplo, cuando estamos monitorizando las consultas en ejecución con SQL Profiler, o al examinar las queries que consumen mayor número de recursos desde los paneles de Azure SQL.

En versiones "clásicas" de Entity Framework había que ingeniárselas para conseguirlo, pero, como podréis comprobar a continuación, en EF Core la cosa se ha simplificado bastante :)

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

Por si te lo perdiste...

• Lo que ocurre cuando desarrolladores diseñan interfaces de usuario (II)
  José María Aguilar
• Localizar errores de validación del binding en ASP.NET Core MVC
  José María Aguilar

.NET / .NET Core

• Announcing .NET Core 3.0 Preview 6
  Richard Lander
• Delegates And Events In C#
  Shadman Kudchikar
• Complete Sudoku Game for Windows using VB.NET 2013
  Hung, Han
• Empty try with finally
  Jiří Činčura
• Migrating a Sample WPF App to .NET Core 3 Part 1 & Part 2
  Mike Rousos
• Tangled in .NET: Will 5.0 really unify Microsoft's development stack?
  Tim Anderson
• Customize object displays in the Visual Studio debugger YOUR way
  Leslie Richardson
• Conditional Ref, Ref ReadOnly, Ref Reassignment in C# 7.X
  Brij Bhushan Mishra
• Calling Cognitive Services OCR Service from a .NET Application
  David Giard
• Try the new System.Text.Json APIs
  Immo Landwerth
• How to Debug LINQ queries in C#
  Michael Shpilt
• La potencia de la Reflexión (Parte 1)
  Jorge Turrado

En el post anterior vimos que la estructura Index, junto con alguna cortesía del compilador, permitía la especificación de índices en arrays de forma muy sencilla. Veíamos cómo podíamos acceder a elementos concretos utilizando su posición en la colección, tanto contando desde el principio como desde el final:

var primes = new[] { 2, 3, 5, 7, 11, 13, 17, 19 };
Index fromStart = 2;  // = Index.FromStart(2) - conversión implícita
Index fromEnd = ^2;   // = Index.FromEnd(2)

Console.WriteLine(primes[fromStart]); // 5
Console.WriteLine(primes[fromEnd]); // 17

Sin embargo, puede que a Index por sí mismo tampoco le veáis demasiada utilidad... y así es. De hecho, su finalidad es más bien el dar soporte a rangos, una nueva característica de C#8 que nos permitirá referirnos a "porciones" de arrays o colecciones similares usando una sintaxis compacta e integrada en el lenguaje.