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

Por si te lo perdiste...

• Leyes epónimas relacionadas con el desarrollo de software (I)
  José María Aguilar
• ¡Mi pantalla se ha puesto gris!
  José María Aguilar

.NET / .NET Core

• Announcing .NET Core 2.2
  Rich Lander
  
• Announcing .NET Core 3 Preview 1 and Open Sourcing Windows Desktop Frameworks
  Rich Lander
  
• Announcing WPF, WinForms, and WinUI are going Open Source
  Scott Hanselman
  
• C#: Conversiones (explícitas o implícitas) e interfaces
  Eduard Tomás
  
• Miscellaneous C# Async Tips
  Stuart Lang
  
• Explicitly Ignoring Exceptions in C#
  Rick Strahl
  
• Why does Clipboard.SetData put extra junk in the clipboard data? And how can I get it to stop?
  Raymond Chen
  
• C# Features: Innovations or Imitations? – Part 3
  Michael Shpilt
  
• Lecturas recomendadas sobre c# y .net · noviembre 2018
  Albert Capdevila
  
• HttpClientFactory .NET Core 2.1
  Daniel Donbavand
  
• Open Source .NET – 4 years later
  Matt Warren
  
• Announcing ML.NET 0.8 – Machine Learning for .NET
  César de la Torre
  
• Using Stopwatch and ContinueWith to Measure Task Execution Time in C#
  Matthew Jones
  
• Exploring C#’s ref return to better understand it
  Jiří Činčura
  
• Depuración remota sobre SSH
  Jorge Turrado
  
• Performance in .NET – Part 3
  Ricardo Peres
  
• An Ad Hoc Approach to Passing Elements from Blazor to JavaScript
  Peter Vogel
  
• Using Roslyn C# Completion Service programmatically
  Filip Woj

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

Por si te lo perdiste...

• ¿Es mi biblioteca portable a .NET Core?
  José María Aguilar
• ¿Autoincrementos, incrementos o sumas?
  José María Aguilar

.NET / .NET Core

• Announcing .NET Framework 4.8 Early Access build 3694
  Namrata Karnam
• Computer Controlled Watering System with C# or VB.NET
  Troy Simpson
• What happens if I mutate a string in a p/invoke?
  Raymond Chen
• Introducing the .NET Core Unit Testing Framework (or: Why xUnit?)
  Peter Vogel
• Working with the Dynamic Type in C#
  Camilo Reyes
• Elvis operator in expressions and why (probably) it’s not allowed
  Jiří Činčura
• Nifty trick: Combining constructor with collection initializer
  Raymond Chen
• Crear imágenes Docker de proyectos netcore en varias versiones del framework
  Eduard Tomás
• Taking advantage of the ordering guarantees of the LINQ GroupBy method
  Raymond Chen
• Creating a language server using .NET
  Martin Björkström
• Overcoming Limitations of .NET Core
  Fiodar Sazanavets
• Returning an XML Encoded String in .NET
  Rick Strahl

Como sabemos, la inyección de dependencias está grabada a fuego en los genes de ASP.NET Core. La mayoría de sus componentes la usan internamente para obtener acceso a otros componentes que necesitan para cumplir sus funciones y, además, es una práctica recomendada en la parte que nos toca a nosotros como desarrolladores de aplicaciones.

Por ello, en ASP.NET Core MVC, lo habitual es que implementemos nuestros controladores atendiendo a este principio, y para ello utilicemos la técnica de inyección de dependencias en el constructor:

public class InvoiceController: Controller
{
    private readonly IInvoiceServices _invoiceServices;
    private readonly IMapper _mapper;
    private readonly ILogger<InvoiceController> _logger;

    public InvoiceController(
        IInvoiceServices invoiceServices, 
        ILogger<InvoiceController> logger,
        IMapper mapper)
    {
        _invoiceServices = invoiceServices;
        _logger = logger;
        _mapper = mapper;
    }
    ...
}

Nota: aunque en este post estemos hablando de controladores ASP.NET Core MVC, las ideas que vamos a comentar aquí son también aplicables a ASP.NET MVC "clásico" e incluso a otro tipo de frameworks que comparten los mismos conceptos.

Ahí van los enlaces recopilados durante la semana pasada, algo más escasa de lo habitual debido a los festivos en USA. Pocos, pero espero que interesantes :-)

Por si te lo perdiste...

• ¿Se pueden desarrollar aplicaciones ASP.NET Core con Visual Basic .NET?
  José María Aguilar
• Entre 10 y 28 desarrolladores por el precio de uno
  José María Aguilar

.NET / .NET Core

• Caching http requests to debug faster
  Gérald Barré
• AutoMapper 8.0.0 Released
  Jimmy Bogard
• How to use the Abstract Factory design pattern in C#
  Gary Woodfine
• Como instalar .NetCore en Linux
  Jorge Turrado
• Getting Stack Overflow Localization Tooling Ready for .NET Core
  Samo Prelog
• Accessing NuGet Package Paths in Your .NET SDK Based csproj Files
  Georg Dangl
• Java vs C# – Part 3
  Ricardo Peres
• Code reliability: Unit testing with XUnit and FluentAssertions in .NET Core 2 apps
  Anthony Giretti
• Introducing the ML.NET – A Machine Learning library for .NET developers
  Coding Notes
• Cómo buscar patrones de búsqueda o coincidencias en C# dentro de un bucle switch & Cómo buscar patrones de búsqueda o coincidencias en C# dentro de un bucle switch con C# 6.0 o anterior
  Jorge Serrano
• How to Choose the Right .NET Collection Class?
  Damir Arh

Seguramente habréis notado que en proyectos ASP.NET Core 2.1 la compilación de las vistas funciona de forma ligeramente diferente a como se hacía en versiones anteriores. Hasta ahora las vistas sólo eran compiladas al publicar el proyecto pero, a partir de esta versión, este proceso se realizará antes, durante la compilación.

En este artículo vamos a ver cómo aprovechar las ventajas de la precompilación, y al mismo tiempo mantener la flexibilidad que nos ofrece la compilación en tiempo de ejecución que tradicionalmente hemos disfrutado en proyectos ASP.NET y ASP.NET Core.

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

Por si te lo perdiste...

• Programación esotérica
  José María Aguilar
• Autenticación JWT en APIs con ASP.NET Core
  José María Aguilar

.NET / .NET Core

• Building C# 8.0
  Mads Torgersen
• C#: Structs de un solo campo como typedefs
  Eduard Tomás
• .NET Core/ .NET Framework My Perspective On The Future
  Mitchel Sellers
• Cross-platform Time Zones with .NET Core
  Christopher Roberts
• .NET Core tooling update for Visual Studio 2017 version 15.9
  Phillip Carter
• Writing ILogger Diagnostics to a File
  Christian Nagel
• .NET Core 2.1.x será soportado hasta 3 años de la declaración TLS
  Jorge Serrano
• Some quick notes on converting String operations to use Span<T>
  Matt Lacey
• Handling a new era in the Japanese calendar in .NET
  Ron Petrusha
• Sample performance investigation using BenchmarkDotNet and PerfView
  Adam Sitnik
• A dynamic definite assignment puzzle
  Eric Lippert
• .NET Core Service Provider Gotchas and Less-Known Features
  Ricardo Peres
• Visual Basic in .NET Core 3.0
  Kathleen Dollard

En el post anterior veíamos cómo personalizar los mensajes de error generados durante el proceso de binding, y cómo aprovechar las posibilidades que nos brinda el framework para introducir textos localizados en esos puntos.

Hoy seguiremos profundizando en este tema, pero esta vez nos centraremos en modificar los textos por defecto de las anotaciones de datos y hacer que simplemente decorando una propiedad con un atributo como Required consigamos obtener mensajes de error localizados y a nuestro gusto, sin necesidad de establecer el ErrorMessage de forma explícita y, en algunos casos, ni siquiera tener que indicar dicho atributo.

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

Por si te lo perdiste...

• El gran consejo para crear código mantenible
  José María Aguilar
• Probar scripts en producción sin desplegar nada, y otros usos interesantes de Fiddler
  José María Aguilar

.NET / .NET Core

• Announcing .NET Standard 2.1
  Immo Landwerth
• Announcing ML.NET 0.7 (Machine Learning .NET)
  César de la Torre
• Understanding the Whys, Whats, and Whens of ValueTask
  Stephen Toub
• Rompiendo los limites: Mocking en las Pruebas Unitarias .Net
  Jorge Turrado
• Move your first steps with .NET Core 3.0 for desktop development
  Matteo Pagani
• Smart enums / Type-safe enums in .NET
  Gérald Barré
• Exploiting multiplication by zero optimization (and failing), yet learning about equals to zero shortcut (Roslyn)
  Jiří Činčura
• Code Coverage is Finally Easy in .Net Core
  Lee Richardson
• dotnet-script 0.27.0 is out – with a ton of features!
  Filip Woj
• Creating a .NET Global Tool from an existing Console Application
  Rick Strahl
• An Early Exploration of Blazor
  Dane Vinson
• Creating your own (simple) dependency injection framework: Service Locator
  Jonathan Donaldson

En el framework ASP.NET Core MVC es muy sencillo establecer los mensajes de error de validación de campos utilizando propiedades de las data annotations, como en el siguiente ejemplo:

namespace LocalizationDemo.ViewModels
{
    public class PersonViewModel
    {
        [Required(ErrorMessage ="The name is required")]
        public string Name { get; set; }
    }
}

Incluso es bastante fácil hacer que este texto aparezca traducido atendiendo a la cultura del hilo actual. Para ello, simplemente debemos configurar los servicios de localización apropiadamente, e indicar en la propiedad ErrorMessage la clave del mensaje de error en el archivo RESX asociado a la clase:

// En Startup.cs:
public void ConfigureServices()
{
    ...
    services.AddLocalization(opt=>opt.ResourcesPath="Resources");
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1)
        .AddViewLocalization()
        .AddDataAnnotationsLocalization(); // Esta línea añade la localización 
                                           // de data annotations 
    }

// En el view model:
namespace LocalizationDemo.ViewModels
{
    public class PersonViewModel
    {
        // El mensaje de error está definido 
        // en Resources/ViewModels.PersonViewModel.resx
        [Required(ErrorMessage ="NameIsRequired")] 
        public string Name { get; set; }
    }
}

Esto es así de fácil para las validaciones que declaramos de forma explícita en nuestro código, mediante atributos de anotaciones de datos. Sin embargo, existen otro tipo de validaciones que se realizan de forma implícita (por ejemplo, cuando en un campo entero introducimos un valor no numérico) y cuyos mensajes de error no son tan sencillos de establecer.

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

Por si te lo perdiste...

• ¿Sabes 1337?
  José María Aguilar
• Personalizar las plantillas de controladores y vistas para ASP.NET Core MVC
  José María Aguilar

.NET / .NET Core

• .NET Core Opinion - Be Wary of GUI Build Tools
  K. Scott Allen
• The future of JSON in .NET Core 3.0
  Immo Landwerth
• Announcing .NET Framework 4.8 Early Access build 3673
  Namrata Karnam
• C# Intermediate - Delegates in C# (Func, Action)
  Marinko Spasojevic
• How to stress and measure the Garbage Collector
  CalvinH
• Embedding quotes within a C# string - The Wit and Ramblings of David Giard
  David Giard
• Side by Side user scoped .NET Core installations on Linux with dotnet-install.sh
  Scott Hanselman
• Subqueries in LINQ -- Visual Studio Magazine
  Peter Vogel

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

Por si te lo perdiste...

• Cancelación de peticiones en ASP.NET Core y MVC
  José María Aguilar
• Cómo reconocer a los buenos desarrolladores
  José María Aguilar

.NET / .NET Core

• Dependabot for .NET Core dependency tracking in GitHub
  Scott Hanselman
• Use structures to improve the lisibility of your code
  Gérald Barré
• Venciendo el miedo a las pruebas unitarias en .Net
  Jorge Turrado
• C# Intermetiade - Queue, Stack and Hashtable Collections in C#
  Marinko Spasojevic
• .NET Core Source Code Analysis with Intel® VTune™ Amplifier
  Varun Venkatesan, Li Tian & Denis Pravdin
• Comparing speed of ToUpper, ToUpperInvariant, ToLower and ToLowerInvariant in .NET Framework and .NET Core
  Jiří Činčura
• Secure Random Integers in .NET Core 3
  Kevin Jones
• Playing with C# 7
  Adam Storr
• Performance in .NET – Part 2
  Ricardo Peres

Desde que comenzamos a programar con ASP.NET MVC tenemos interiorizado que si en nuestras acciones vemos código repetido, suele ser un candidato a ser implementado en forma de filtro. Así, durante años hemos implementado en forma de action filters asuntos transversales de nuestras aplicaciones, como la seguridad, logging, caching y otros aspectos.

Sin embargo, a veces olvidamos que estas mismas técnicas podemos utilizarlas para simplificar código en la implementación de convenciones o funciones más ligadas al negocio o a funcionalidades de nuestra aplicación. Por ejemplo, ¿no estáis aburridos de escribir acciones como las siguientes?

public class FriendsController: Controller
{
    public IActionResult View(int id) 
    {
        var friend = _friendServices.GetById(id);
        if(friend == null)
           return NotFound();
        ... // Prepare and show "View" view
    }

    public IActionResult Edit(int id) 
    {
        var friend = _friendServices.GetById(id);
        if(friend == null)
           return NotFound();
        ... // Prepare and show "Edit" view
    }

    public IActionResult Delete(int id) 
    {
        var friend = _friendServices.GetById(id);
        if(friend == null)
           return NotFound();
        ... // Prepare and show "Delete" view
    }

    ...
}

Pues bien, vamos a aplicar el mismo principio para simplificar este código y eliminar duplicidades extrayendo las porciones comunes a un filtro, resultando en algo así de bonito:

[Autoload(typeof(Friend))] // ¡Magia!
public class FriendsController: Controller
{
    public Task<IActionResult> View(Friend friend) 
    {
        ... // Prepare and show "View" view
    }

    public Task<IActionResult> Edit(Friend friend) 
    {
        ... // Prepare and show "Edit" view
    }

    public Task<IActionResult> Delete(Friend friend) 
    {
        ... // Prepare and show "Delete" view
    }
    ...
}

No sé lo útil que podrá resultar en la práctica pero, como mínimo, nos ayudará a conocer mejor cómo funciona por dentro el framework ASP.NET Core MVC.

Después del parón de la semana pasada debido a compromisos profesionales (¡hola, chic*s!), continuamos con una nueva recopilación de enlaces que, como siempre, espero que os resulten interesantes :)

Por si te lo perdiste...

• ¿Dónde está Server.MapPath() en ASP.NET Core?
  José M. Aguilar
• 7 Hábitos de personas altamente innovadoras
  José M. Aguilar

.NET / .NET Core

• Announcing .NET Core 2.2 Preview 3
  Rich Lander
• No InternalsVisibleTo, no problem – bypassing C# visibility rules with Roslyn
  Filip Woj
• Announcing ML.NET 0.6 (Machine Learning .NET)
  César de la Torre
• Working with the Dynamic Type in C#
  Camilo Reyes
• Using multiple instances of strongly-typed settings with named options in .NET Core 2.x
  Andrew Lock
• New prescriptive guidance for Open Source .NET Library Authors
  Scott Hanselman
• Nice little trick when working with Expression API
  Sacha Barber
• .Net Core 2: Managing Secrets in Web Apps - TechNet Articles - United States (English)
  Jayendran arumugam
• When Is It Okay to Use a C# Partial Class?
  Carlos Schults
• C# Intermediate - Abstract Classes in C#
  Marinko Spasojevic
• Don't Code Tired | Setting Up Mock ref Return Values in Moq
  Jason Roberts
• #MLNET – Analizando datos de la Pipeline con la nueva version API 0.6.0 (gracias LINQ!)
  Bruno Capuano
• Inyección de Dependencias en .Net Framework
  Jorge Turrado

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

Por si te lo perdiste...

• ¿Recomendarías a tu hijo que se dedicase al mundo del desarrollo de software?
  José M. Aguilar
• Cómo incluir scripts en la página desde vistas parciales ASP.NET Core MVC con DynamicSections
  José María Aguilar

.NET / .NET Core

• .NET Core 2.0 Sees End of Life, 2.1.5 Update Released
  David Ramel
• Update on .NET Core 3.0 and .NET Framework 4.8
  Scott Hunter
• I didn't understand why people struggled with (.NET's) async
  Dan
• C# Intermediate: Structures in C# & Enumerations in C#
  Marinko Spasojevic
• The danger of TaskCompletionSource<T> class
  Sergey Teplyakov
• Using Async with ManualResetEventSlim
  Calvin H.
• BenchmarkMockNet: Benchmarking .NET Mocking Libraries
  Steve Desmond
• Middle Ground between Server and Workstation GC
  Maoni Stephens
• Unit Testing With .NET Core
  Jeremy Morgan
• .NET Tip: Testing Private Fields
  Peter Vogel
• A Recap about Creating Maps for AutoMapper in .NET Core
  Silvia Campo
• FixedTimeEquals in .NET Core
  Kevin Jones
• LINQ Stinks - code smells in your LINQ
  Mark Heath
• A History of .NET Runtimes
  Matt Warren

Pues como uno que os habla, seguro que muchos de vosotros habéis comparado miles de veces si un objeto es nulo utilizando un patrón de código C# como el siguiente:

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

¿Qué podría salir mal, verdad?

Pues aunque pueda parecer raro, hay casos en los que la comparación anterior no funcionaría bien... o mejor dicho, no funcionaría como esperamos.

Hace unos días leía un post de Khalid Abuhakmeh en el que hacía referencia a una charla de Channel 9 en la que Mads Torgersen recomendaba no utilizar la doble igualdad para comparar con null (minuto 33:00, aprox.)

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

Por si te lo perdiste:

• 10 razones por las que tu blog te ayuda a encontrar empleo
  José María Aguilar
• Redirecciones HTTP 303, 307 y 308: ¿las conoces?
  José María Aguilar

.NET / .NET Core

• Scripts to remove old .NET Core SDKs
  Scott Hanselman
• Async pitfalls: deferred work and resource ownership
  Ian Griffiths
• Asynchronous functors
  Mark Seemann
• "ImageResizer" is now "dotnet srcset"
  Steve Desmond
• Getting the date of build of a .NET assembly at runtime
  Gérald Barré
• How to generate a zip containing the user personal data to be GDPR compliant in .Net Core 2.1.
  Silvia Campo
• A command-line REPL for RESTful HTTP Services
  Scott Hanselman
• [.NET Internals 09] Just-In-Time (JIT) compilation
  Dawid Sibiński
• C# Intermediate - Static Members in C# & Anonymous and Nullable Types in C#
  Marinko Spasojevic
• Performance in .NET – Part 1
  Ricardo Peres
• How Microsoft rewrote its C# compiler in C# and made it open source
  Mads Torgersen

Hace unos días, un alumno del curso online de ASP.NET Core en CampusMVP (por cierto, desde hace unas semanas actualizado a la versión 2.1) me planteaba una cuestión que quizás podría interesar a alguien más, por lo que vamos a comentarla por aquí.

Básicamente, la duda era la siguiente:

¿Hay alguna forma sencilla de añadir el atributo [Authorize], pero sólo a los controladores que se encuentren en una carpeta determinada del proyecto, sin tener que aplicarlo uno a uno?

La respuesta rápida es: sí. Bueno, con matices ;) Incluso hay varias opciones, así que vamos a ver algunas de ellas, y de paso repasamos conceptos de ASP.NET Core MVC :)

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

Por si te lo perdiste:

• Extendiendo claims de usuarios en ASP.NET Core
  José María Aguilar
• ¿Se pueden desarrollar aplicaciones ASP.NET Core con Visual Basic .NET?
  José María Aguilar

.NET / .NET Core

• Announcing .NET Framework 4.8 Early Access build 3646
  Jamshed Damkewala
• Announcing Cumulative Updates for .NET Framework for Windows 10 October 2018 Update
  Brett Lopez
• Implementing Self-Organizing Maps with .NET Core
  Nikola Živković
• C# Intermediate - Properties in C#
  Marinko Spasojevic
• C# 8 Small Features
  Jonathan Allen
• C# Special Method Names
  Ricardo Peres
• .NET Core Opinion
  K. Scott Allen
• Introduction to ANNdotNET v1.0 deep learning tool on .NET Platform
  Bahrudin Hrnjica
• Avoid Logging in Low-Level Code
  Mark Heath

Los que peinamos ya bastantes canas recordamos con nostalgia aquellas intensas sesiones de programación intentando arañar ciclos de CPU y bytes en nuestro flamante Spectrum para sacar el máximo provecho de, en el mejor de los casos, un Zilog Z80A a 3,5MHz con 48K de memoria RAM. ¡Ah, el maravilloso mundo de las micro-optimizaciones!

Hoy en día, salvo en contadas ocasiones, ha dejado de tener sentido invertir demasiado tiempo en estas labores. Tenemos máquinas potentes, con micros cuya velocidad se mide en GHz capaces de ejecutar bastantes tareas de forma concurrente, y muchos Gigabytes libres de memoria RAM en los que guardar información. Además, los frameworks actuales como .NET permiten despreocuparse de asuntos como la reserva o liberación de memoria porque ya hay sistemas de más bajo nivel que se encargan de eso por nosotros.

Indudablemente es un gran avance, pero esto ha llevado a que, con el tiempo, se nos esté atrofiando ese sentido arácnido que antes nos disparaba las alertas cuando cierto código podía ser optimizado para consumir menos recursos.

En la mayoría de escenarios, y sobre todo cuando trabajamos en entornos empresariales, aplicaciones de escritorio o webs de poca carga, está bien así. Sin embargo, es cierto también que las necesidades han cambiado.

Por ejemplo, ahora creamos frecuentemente aplicaciones mucho más complejas que pueden ser utilizadas a través de Internet por miles de usuarios de forma simultánea y todos ellos esperan respuestas rápidas. Estas aplicaciones se ejecutan en servidores cuyos recursos son compartidos entre todos los usuarios que pueden llegar a tener un coste importante y debemos exprimir al máximo. Aquí, y en otros escenarios similares, es donde aparece de nuevo la necesidad de introducir optimizaciones en el código.

En este post vamos a hacer una introducción al uso de BenchmarkDotNet, una magnífica herramienta que nos permitirá medir el rendimiento de nuestro código .NET para hacerlo más eficiente en términos de uso de procesador y memoria.

Pero antes de empezar, no olvidéis la famosa frase de Donald Knuth:

“Los programadores consumen una gran cantidad de tiempo pensando, o preocupándose, sobre la velocidad de partes no críticas de sus programas, y esos intentos de mejorar la eficiencia tienen posteriormente un gran impacto negativo sobre la facilidad de depuración o mantenimiento. Deberíamos olvidarnos de las pequeñas mejoras de eficiencia, digamos en un 97% de los casos: la optimización prematura es el origen de todos los males. Sin embargo, no debemos dejar pasar la oportunidad de mejorar ese crítico 3% restante”

¡Hola de nuevo! Pues sí, tras una larga temporada de descanso, por fin estamos de vuelta, preparados para la nueva temporada y con las baterías cargadas al 99% (ese 1% me temo que es ya irrecuperable ;D)

Y para celebrarlo, nada mejor que un buen puñado de enlaces recopilados durante la semana pasada que, como siempre, espero que os resulten interesantes. :-)

.NET / .NET Core

• .NET Core September 2018 Update
  Lee Coward
• .NET Framework September 2018 Security and Quality Rollup
  Tara Overfield
• .NET Core Opinion - Structuring a repository & Managing a repository structure
  K. Scott Allen
• How to (really) migrate from .NET Core 2.0 to 2.1
  Jelly Hive
• How do you use System.Drawing in .NET Core?
  Scott Hanselman
• Writing a JIT Compiler in C# | Mono
  Ludovic Henry, Miguel de Icaza, Aleksey Kliger, Bernhard Urban & Ming Zhou
• Announcing ML.NET 0.5
  César de la Torre
• C# 8 Concerns
  Ben Bowen

Pues eso, que parecía que no llegaba y las semanas se hacían cada vez más cuesta arriba, pero por fin es el momento de descansar un poco e intentar conseguir un merecido reinicio mental.

Durante las próximas semanas dejaré el blog a merced de las olas, pues estaré disfrutando con la familia en las maravillosas playas de Cádiz: sol, paseos, refrescantes bañitos en las aguas del Atlántico y chiringuitos playeros con aroma a pescado fresco. Un buen plan, sin duda ;)


Imagen original

Nos vemos a la vuelta, ya en el mes de septiembre, con la batería al 100% y listos para seguir buscando la variable ;)

¡Felices vacaciones a todos!

Publicado con ánimo vacacional en Variable not found.

Los que lleváis tiempo programando APIs HTTP, ya sea con ASP.NET Core o con otras tecnologías, seguro que en muchas ocasiones habéis tenido que decidir cómo retornar al cliente, de forma más o menos normalizada, los errores producidos en el lado servidor.

Lo habitual es echar mano de los status code de HTTP para indicar problemas en el proceso de una petición; de hecho, este protocolo dispone de un rico conjunto de códigos que en principio parecen cubrir todas nuestras necesidades.

Pero no siempre es así. Por ejemplo, si tenemos un servicio que permite a los clientes de una empresa formalizar un pedido a través de un API y una llamada a este servicio retorna un error HTTP 403 (forbidden), claramente estamos indicando que el solicitante no tiene permisos para hacer un pedido. Sin embargo, no tenemos una forma clara de indicar cuál es la causa de esta prohibición (¿quizás las credenciales no son correctas? ¿o quizás el cliente no tiene crédito en la empresa? ¿o puede ser que el administrador lo haya denegado expresamente?)

Para aportar más detalles sobre el problema, normalmente necesitaremos retornar en el cuerpo de la respuesta información extra usando estructuras o formatos personalizados, probablemente distintos de una aplicación a otra, y documentarlos apropiadamente para que los clientes puedan entenderlos. Y aquí es donde entra en juego el estándar “Problem details”.

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

.NET / .NET Core

• Pipelines - a guided tour of the new IO API in .NET, part 1
  Marc Gravell
• Prepare Visual Basic for Conversion to C#
  Paul D. Sheriff
• What C# can learn from Haskell: Pipe Operator
  Daniel Cabtree
• Optimising Image Processing
  Indy Singh
• Debugging through the .NET Core framework using VSCode (e.g. on Linux)
  Vance Morrison
• Create and Pack Reference Assemblies
  Oren Novotny
• C# 8: Pattern Matching Extended
  Christian Nagel
• Machine Learning with ML.NET – Solving Real-World Classification Problem (Wine Quality)
  Nikola Živković
• The Case For .Net Monkey Patching In 2018
  Khalid Abuhakmeh
• Using global tool “dotnet outdated” to check for the latest NuGet package updates
  Shayne Boyer
• Sending email in .NET Core with FluentEmail
  Luke Lowrey*
• The whole of WordPress compiled to .NET Core and a NuGet Package with PeachPie
  Scott Hanselman
• .NET JIT and CLR - Joined at the Hip
  Matt Warren