Ahí van los enlaces recopilados durante la semana pasada y, como siempre, espero que os resulten interesantes :-)

Y de paso, aprovecho este momento  para desearos a todos unas felices fiestas y un grandioso 2019 en todos los ámbitos.

Por si te lo perdiste...

• Xmas Tree scan, el escaneo de puertos navideño
  José María Aguilar
• Constantes string multilínea en C#
  José María Aguilar

.NET / .NET Core

• .NET Core - What's Coming in .NET Core 3.0
  Scott Hunter
• Composing Honest Methods in C#
  Yacoub Massad
• Comparaciones en C#
  Eduard Tomás
• ClosedXML, una manera fácil de dar formato a nuestros .xlsx
  Jorge Turrado
• VB.NET Hits High in Programming Language Popularity Index
  David Ramel
• Enable repeatable package restores using a lock file
  Anand Gaurav
• Garbage Collection in C# (.NET Framework and .NET Core)
  Damir Arh
• Writing a Roslyn analyzer
  Gérald Barré
• The Lazy applicative functor
  Mark Seemann
• Interesting uses of tuple deconstruction
  Nigel Sampson
• C# All The Things
  David Pine
• Presenting HttpTracer Library
  Daniel Causer
• How to Remove Application Insights
  Matt Watson
• C# Features: An Exhaustive List of the Best Ones
  Carlos Schults
• Updating Westwind.AspnetCore.Markdown with Markdown from Files and URLs
  Rick Strahl
• Top .NET Tutorials in 2018
  David Ramel

Hace unos días publicaba un post sobre la mala idea que era tener controladores con demasiadas responsabilidades y cómo un constructor con demasiadas dependencias podía ser una señal (un 'code smell') de que las cosas no estaban yendo bien en ese sentido.

Por ejemplo, echando un vistazo al siguiente controlador podemos ver claramente una violación del Principio de Responsabilidad Única (SRP) en un controlador que conoce demasiados detalles sobre la forma de proceder al registrar un pedido:

public class OrderController: Controller
{
    private readonly IOrderServices _orderServices;
    [...] // Other private members

    public OrderController(IOrderServices orderServices, IUserServices userServices, 
        IMailingService mailingServices, ISmsServices smsServices, 
        IPdfGenerator pdfGenerator, IMapper mapper
    )
    {
        _orderServices = orderServices;       
        _userServices = userServices;
        [...] // Other assignments...
    }

    [HttpPost]
    public Task<IActionResult> Submit(OrderViewModel orderViewModel)
    {
        if(!ModelState.IsValid)
        {
            return View(orderViewModel);
        }
        var orderDto = _mapper.Map<OrderDto>(orderViewModel);
        var orderResult = await _orderServices.AddAsync(orderDto);
        if(!orderResult.Success)
        {
            return RedirecToAction("OrderError", new { error = orderResult.Error }));
        }
        var userPreferences = await _userServices.GetNotificationPreferencesAsync(CurrentUserId);
        var pdfUrl = await _pdfGenerator.GenerateOrderAsync(orderResult.Details);
        if(userPreferences.NotificationMode == NotificationMode.Sms)
        {
            await _smsServices.NotifyNewOrderAsync(orderResult.Details, pdfUrl);
        } 
        else 
        {
            await _mailingServices.NotifyNewOrderAsync(orderResult.Details);
        }
        return RedirectToAction("ThankYou", new { id = orderResult.Details.OrderId } );
    }
    ...
}

En dicho post comentaba también algunas cosas que podíamos hacer para solucionar el problema, así como una recomendación de lo que no debíamos hacer: disimular dependencias instanciando directamente componentes o utilizando otros "sabores" de inyección que hicieran menos evidente la relación de nuestra clase con otras de las que depende.

Pues bien, como hoy estamos algo rebeldes, vamos a ver las técnicas que nos permitirían hacerlo cuando sea necesario o, dicho de otra forma, qué alternativas tenemos para usar dependencias desde los controladores sin que estas sean suministradas mediante inyección en su constructor.

Precaución: estas técnicas son consideradas antipatrones o, como mínimo, code smells en la mayoría de los escenarios, así que usadlas poco, con precaución y siempre con conocimiento de causa ;)

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 (y II)
  José María Aguilar
• 10 razones por las que tu blog te ayuda a encontrar empleo
  José María Aguilar

.NET / .NET Core

• Seven reasons that Roslyn-based Code Analysers are awesome
  Tom Wright
• A Simple Look at .NET Memory Model
  James M. Curran
• Why is string.GetHashCode() different each time I run my program in .NET Core?
  Andrew Lock
• Six Opinionated Tips to be a Better .NET Developer
  Isaac Levin
• Writing xUnit Tests in .NET Core & Providing Constant Context for .NET Core Tests
  Peter Vogel
• Support for Value Objects in C#
  Steve Smith
• Explicit interface implementation
  Ed Freeman
• Announcing .NET Framework 4.8 Early Access Build 3707
  Namrata Karnam
• Exploring the .NET Core Runtime (in which I set myself a challenge)
  Matt Warren

La pasada semana, en el contexto del evento Microsoft Connect(); 2018, se lanzaron las últimas versiones de la familia de productos "Core": .NET Core 2.2, ASP.NET Core 2.2 y Entity Framework Core 2.2.

En todos los casos son revisiones pequeñas y que no rompen nada de lo anterior, pero en cada uno de estos productos se han introducido mejoras que vale la pena conocer, por lo que, antes que nada, os recomiendo que echéis un vistazo a los artículos anteriores, que son los anuncios oficiales.

En este post vamos a ver rápidamente las novedades más destacables de ASP.NET Core 2.2.

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