.NET R&D Digest (November – December, 2019)

This year was huge for .NET community. We hit .NET Core 3.0 with all it’s goodies just to find out that .NET Framework 4.8 will be the last framework release. We saw a glimpse of future called .NET 5 where Mono is part of the .NET. We saw / heard multiple talks from multiple conferences and read a lot of blog posts from the internet.

Now the year is coming to its end but there are still some stuff to read and I know, there is nothing better than read some technology blog post on holiday / vacation 😊

Have a good time! See you next year!

Windows

  1. Cool WSL (Windows Subsystem for Linux) tips and tricks you (or I) didn’t know were possible (by Scott Hanselman)
    WSL (Windows Subsystem for Linux) is an amazing thing which brought Linux experience to your Windows machine (there is already a WSL2). In this post Scott Hanselman share a set of nice tricks (most of them were a nice surprise to me) to make you work with WSL more productive. Recommended to read & bookmark if you are using or planning to use WSL 🙂

Performance

  1. “Performance Matters” (by Emery Berger)
    I think who has ever done performance optimization knows how confusing this process could be. It is really hard to measure things right, to be sure you are really improving performance. In this presentation Emery Berger talks about things that made performance optimizations hard and how to do performance analysis in a right way. Recommended to watch at least to know that changing methods order could affect performance.

    (I wish I saw this talk a few years ago when I personally faced the layout effect. I thought that I lost my mind.)

Visual Studio

  1. Pinnable Properties: Debug & Display Managed Objects YOUR Way (by Leslie Richardson)
    Visual Studio has many features to simplify debugging. We can use different breakpoints to pause the execution. We can print information without modifying the code using tracepoints. We can attribute our classes so Visual Studio will know how to display them. And now, there is more. In this post Leslie Richardson explains how we can use new Visual Studio “Pinnable Properties” feature to quickly identify objects by changing theirs display at runtime!
  2. WSL + Visual Studio = attaching/launching a Linux .NET Core application on Window 10 (by Christophe Nasarre)
    .NET Core runs on Linux. Windows has WSL to run Linux. Combining these two pieces make it possible to run .NET Core apps on Linux on Windows, which is great but what about debugging? In this post Christophe Nasarre describes how you can debug .NET Core application running on WSL in Visual Studio (using both methods: attach to process and start process).

.NET

  1. Exploring borrowed annotations in C# (by Jared Parsons)
    Have you ever asked yourself: “Will this class store a reference to my <resource name>”? If yes, then you should know there is no simple answer if you are using C#. The reason why is because there is no resource ownership semantics built in into the language. In this post Jared Parsons explores what it would be if C# would have semantics to “borrow” resources (based on the real experience) and why it cannot be easily added to the language now.
  2. HttpClient connection pooling in .NET Core (by Steve Gordon)
    In this post Steve Gordon describes what is HTTP connection pooling and how it works. The post starts from the brief history of HttpClient and then dives into internal details of how connection pooling is implemented in different versions of .NET Framework and .NET Core (spoiler: It is not about IHttpClientFactory).
  3. You’re (probably still) using HttpClient wrong and it is destabilizing your software (by Josef Ottosson)
    In this post Josef Ottosson demonstrated various ways to use HttpClient (from quite straightforward way to typed clients with IHttpClientFactory) by creating multiple versions of the same application. Besides code samples the post also contains detailed explanations of every change and pros / cons section for each implementation version. In the end all these implementations are benchmarked 🙂
  4. Using async disposable and async enumerable in frameworks older than .NET Core 3.0 (by Filip W.)
    C# 8 brings a lot of great features. However, most of these goodies are only for .NET Core 3.0 / .NET Standard 2.1 consumers. In this post Filip W. describes how you can bring ‘async enumerable’ features to .NET Standard 2.0 compatible frameworks.
  5. An Introduction to System.Threading.Channels (by Stephen Toub)
    Producer / consumer is a very common problem. We face it when processing any chunks of data. Most of the custom solutions I saw were implemented using BlockingCollection or TPL DataFlows. These I would say become a standard way to address these scenarios. While BlockingCollection is great for simplest scenario and TPL DataFlows allows you to build very complex data processing pipelines they aren’t really effective in many quite common producer / consumer scenarios. Some time ago .NET introduced System.IO.Pipelines to handle scenarios involving stream of bytes and now there is also System.Threading.Channels to address the rest of cases. In this post Stephen Toub in describes what System.Threading.Channels is, what it’s API does and how all this thing works internally. The post is very detailed and contains samples, source code snippets and problems definitions. Highly recommended to read.

Security

  1. How Does HTTPS Work? RSA Encryption Explained (by Bobby Hood)
    A very simple and representative explanation of how HTTPS works by Bobby Hood. The article is slightly out dated, however it is still more than enough to get good high level understanding why you have to secure your web site with HTTPS.

Testing

  1. Exploratory Testing (by Martin Fowler)
    Application testing is the essential part of software development cycle. There are so many types of testing that we can even form a test pyramid from them 🙂 However most of the tests we do are scripted tests and while they allow us to make sure all known cases are work as expected they do not guarantee our app is 100% fine. In this post Martin Fowler talks about of exploratory testing and why it is important to do it regularly even when you have good automated tests coverage.

Tools

  1. Do you care about performance? 🙂 I am sure you do! We all do! Hence from time to time it can be interesting to see what JIT actually generates from code we write.

    Here are three projects which can help you with that (or you can do it coreclr way):
    Disasmo by Egor Bogatov
    JitBuddy by Alexandre Mutel
    JitDasm by 0xd4d

    Each of these project has it’s own unique features, so it is for you to decide which best suits your need, however they all do print JIT generated ASM 🙂
  2. MartinCostello.Logging.XUnit
    This project by Martin Costello allows you to hook into ILogger infrastructure and make sure no information written by the application components is missed. Instead of this it would be written to Test Output and will be available right in the Test Explorer.

Books we can get for free

  1. Getting started with Azure Red Hat OpenShift
    Abstract: This guide is meant for developers who are looking to learn how to bolster their cloud-native application building and deployment capabilities by leveraging Azure Red Hat OpenShift and its built-in CI/CD pipelines, container registry and security that provide a wide range of supported technologies and streamlined workflows. We will begin by introducing you to Red Hat OpenShift and the reasons why so many developers and operators choose it as their cloud-native cluster management platform. You’ll then go through the fundamental concepts and building blocks of OpenShift and follow a hands-on guide to setup your own cluster and deploy your first microservices application.
  2. Effective DevOps—Building a DevOps Culture at Scale
    Abstract: DevOps enables organizations to deliver software faster and more reliably. But to get the desired results, it’s important to know that there’s more to building an effective DevOps practice than learning new methodologies and technologies. Culture is the key to a successful DevOps transformation.

    Read the e-book to learn:
    – The foundations and central four pillars of effective DevOps.
    – Tips for fostering collaboration, strong interpersonal relationships, and affinity between teams.
    – How to select tools and workflows that support and strengthen your organization’s unique DevOps culture.
    – How to troubleshoot common problems and misunderstandings.
    – How successful organizations have handled their DevOps journeys.

History


  • 2020/01/30 – Added “by author” to each entry i.e.
    Was: 1. The blog post name; Now: 1. The blog post name (by author)

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s