Sabemos que está feo y no sea especialmente recomendable en muchos casos, pero hay veces en las que es totalmente necesario acceder a miembros privados de una clase. Por ejemplo, sería un requisito  imprescindible si fuéramos a implementar un serializador o deserializador personalizado, o necesitásemos clonar objetos, o simplemente realizar pruebas unitarias a una clase que no ha sido diseñada para ello.

Para conseguirlo, siempre hemos utilizado los mecanismos de introspección de .NET, conocidos por todos como reflexión o por su término en inglés reflection. Por ejemplo, imaginemos una clase como la siguiente, virtualmente inexpugnable:

public class BlackBox
{
    private string _message = "This is a private message";
    private void ShowMessage(string msg) => Console.WriteLine(msg);
    public override string ToString() => _message;
}

Aunque a priori no podemos hacer nada con ella desde fuera, usando reflexión podríamos acceder sin problema a sus miembros privados, ya sean propiedades, campos, métodos o cualquier tipo de elemento, como podemos ver en el siguiente ejemplo:

var instance = new BlackBox();

// Obtenemos el valor del campo privado _message:
var field = typeof(BlackBox)
    .GetField("_message", BindingFlags.NonPublic | BindingFlags.Instance);
var value = field!.GetValue(instance);

// Ahora llamamos al método privado ShowMessage():
var method = typeof(BlackBox)
    .GetMethod("ShowMessage", BindingFlags.NonPublic | BindingFlags.Instance);
method.Invoke(instance, [value]);

// Al ejecutar, se nuestra en consola: "This is a private message"

Sin embargo, de todos es sabido que la reflexión es un mecanismo muy lento, a veces farragoso en su implementación y, sobre todo, incompatible con tree-shaking, que es como se suele llamar la técnica que usan los compiladores de eliminar del código final todas las clases, métodos y propiedades que no se utilizan en el código final. Esta técnica va tomando cada vez más relevancia conforme los compiladores son capaces de crear directamente ejecutables nativos puros, porque permiten reducir de forma considerable el peso de los artefactos creados.

Por esta razón, en .NET 8 se ha incluido una nueva fórmula para acceder a miembros privados, mucho más eficiente y amistosa con AOT, porque se lleva a tiempo de compilación algo que antes obligatoriamente se resolvía en tiempo de ejecución.

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
• Implicit usings en C#10
  José María Aguilar

.NET Core / .NET

• Announcing .NET 8 RC2
  Jon Douglas
• OpenSilver 2.0 released
  Userware
• Full precision floating-point summation in C#
  Anthony Lloyd
• Get the default value of a type at runtime
  Gérald Barré
• Replace Line Breaks in a String in C#
  Code Maze
• Getting Started With NServiceBus in .NET
  Milan Jovanović
• Padding for Overlaid Structs
  Stephen Cleary
• How To Use Embedded Resources in .NET
  Khalid Abuhakmeh
• Revisiting Various Change Feeds Consumption in .NET
  Tomasz Pęczek
• xUnit And Moq – How To Master Unit Testing In C#
  Nick Cosentino
• Lessons learned from building a static code analyzer for C#
  Daniel Genezini
• Primary constructors changes initialisation behaviour in C# 12
  David Grace
• Structured Concurrency in C#
  Steven Giesel
• .NET 8 New and Efficient Way to Check IP is in Given IP Range
  Sibeesh Venu
• ConcurrentQueue in C#
  Michal Kaminski
• Simplify Source Generator creation the RoslynGenerator template
  Bart Wullems

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
• Directivas using globales en C# 10
  José María Aguilar

.NET Core / .NET

• Logs en .Net
  Fernando Escolar
• How to test the logs from ILogger in .NET
  Gérald Barré
• Testing Time-Dependent Code With TimeProvider in .NET
  Code Maze
• Performance Improvements in .NET 8
  Rico Mariani
• Rolling Forward to Major Versions in .NET
  Rick Strahl
• How To Display .NET Collections with the Oxford Comma
  Khalid Abuhakmeh
• Selecting Xml Nodes With XPath in C#
  Code Maze
• Effortlessly Resolving Circular Dependencies in .NET with SmartInject
  Daan Acohen
• Arm64 Performance Improvements in .NET 8
  Kunal Pathak
• Don't Use "Task.WhenAll" for Interdependent Tasks
  Jeremy Clark
• Tales from the .NET Migration Trenches - Our First Views
  Jimmy Bogard
• The convenience of System.Text.Json
  Richard Lander
• Looking at Producer/Consumer Dependencies: Bounded vs. Unbounded Channels & Producer/Consumer Exception Handling
• Jeremy Clark

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

Por si te lo perdiste...

• ¿Por qué llamamos "uppercase" y "lowercase" a mayúsculas y minúsculas?
  José María Aguilar
• 32 Síntomas que indican que estás afectado por el desarrollo
  José María Aguilar

.NET Core / .NET

• Polly v8 officially released
  Joel Hulen
• Wolverine Expands its Multi-Tenancy Story to HTTP
  Jeremy D. Miller
• Create Cryptographic Numbers With RandomNumberGenerator
  Code Maze
• How to write logs from ILogger to xUnit.net ITestOutputHelper
  Gérald Barré
• Less boilerplate code with the new primary constructor in C# 12
  Steven Giesel
• Don’t persist GetHashCode() in .NET!
  Isaac Abraham
• The convenience of .NET
  Richard Lander
• The case of the mysterious comparison
  Mark Seemann
• C# Tip: Improve memory allocation by initializing collection size
  Davide Bellone
• Using a Discard Variable in C#
  Code Maze
• Green Thread Experiment Results
  David Wrighton
• Debugging Enhancements in .NET 8
  James Newton-King
• Wolverine Interoperability with Others
  Jeremy D. Miller
• Memory Optimization With ArrayPool in C#
  Code Maze
• How To Use BenchmarkDotNet For Beginners
  Nick Cosentino
• Tales from the .NET Migration Trenches
  Jimmy Bogard
• Questions I asked as .NET interviewer
  Steven Giesel
• Memory-Mapped Files and Overlaid Structs
  Stephen Cleary
• 22 C# Best Practices
  Code Maze
• How to Add Comments to Excel Documents Using C#
  Mohan Chandran

Seguro que más de una vez habéis tenido que construir una abstracción sobre DateTime para poder controlar apropiadamente la obtención de la fecha/hora actual y otras operaciones relacionadas con el tiempo.

Suelen ser bastante útiles cuando creamos pruebas unitarias de métodos que dependan del momento actual. Por ejemplo, ¿cómo testearíamos de forma automática que las dos líneas de ejecución del siguiente método DoSomething() funcionan correctamente? Sería imposible salvo que ejecutásemos las pruebas a una hora determinada, algo que se antoja complicado 😉

public class MyClass
{
    public string DoSomething()
    {
        var now = DateTime.Now;
        return now.Second == 0
            ? "A new minute is starting"
            : "Current second " + now.Second;
    }
}  

Sin duda, una forma mejor y más test friendly sería contar con una abstracción sobre el proveedor de tiempos capaz de retornar la fecha y hora actual, por ejemplo:

public interface IDateTimeProvider
{
    DateTime GetCurrentDateTime();
}

De esta forma, podríamos reescribir la clase MyClass de forma que recibiera por inyección de dependencias nuestro proveedor IDateTimeProvider. Así sería realmente sencillo crear un par de pruebas unitarias que, suministrando los valores correctos a través de esta dependencia, podrían recrear los escenarios a cubrir:

public class MyClass
{
    private readonly IDateTimeServices _dateTimeServices;
    public TimeHelpers(IDateTimeServices dateTimeServices)
    {
        _dateTimeServices = dateTimeServices;
    }
    public string DoSomething()
    {
        var now = _dateTimeServices.GetCurrentDateTime();
        return now.Second == 0
            ? "A new minute is starting"
            : "Current second " + now.Second;
    }
}  

Aunque hacerlo de esta manera en nuestras aplicaciones es lo ideal, hay partes que se quedarían fuera de esta posibilidad, como las bibliotecas de terceros que de alguna forma dependan de las funcionalidades proporcionadas por DateTime.

Por esta razón, .NET 8 va a introducir una abstracción que nos permitirá gestionar estos escenarios de forma más homogénea y generalizada en aplicaciones y componentes .NET. 

Os presento la clase abstracta TimeProvider 😁

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

Por si te lo perdiste...

• 5 motivos por los que tus acciones MVC reciben objetos vacíos o nulos en ASP.NET Core
  José María Aguilar
• Validación de peticiones en ASP.NET, o cómo evitar el error “Request.Form peligroso”
  José María Aguilar

.NET Core / .NET

• Métricas en .Net
  Fernando Escolar
• What's new in System.Text.Json in .NET 8
  Eirik Tsarpalis
• Extending HTTPClient with Custom Http Message Handlers in dotnet
  Abdul Rahman
• How to Validate JWTs in .NET
  Andrea Chiarelli
• Sharing WireMock in sequential and parallel tests
  Cezary Piątek
• Accessing private members without reflection in C#
  Gérald Barré
• Discriminated Unions in C#
  Maarten Balliauw
• Back to .NET basics: How to easily build a Strategy pattern using dependency injection
  Carlos Pons
• Synchronization Mechanisms - Volatile vs Interlocked vs lock in C#
  Code Maze
• Feature Flags in .NET and How I Use Them for A/B Testing
  Milan Jovanović
• When to Use ReaderWriterLockSlim Over lock in C#
  Code Maze
• System.Text.Json JsonConverter Test Helpers
  Khalid Abuhakmeh
• Feature Flags 101: A Guide for .NET Developers
  Davide Bellone
• .NET 8–Keyed/Named Services
  Bart Wullems
• ASCII vs UTF8 - How To Navigate Character Encoding
  Nick Cosentino
• Different Log Levels in Serilog
  Code Maze
• Less boilerplate code with the new primary constructor in C# 12
  Steven Giesel