.NET R&D Digest (September, 2019)

Every month there is something exciting happening in the world of technology. This month (September) was a special one for .NET community because of .NET Core 3.0 release (and if you haven’t noticed that I recommend you to watch these .NET Conf recordings and read this announcement).

Despite the fact we all are overwhelmed by the information and blog posts we now have to read about new features and changes I hope there is still a small room for new issue of .NET R&D Digest (September, 2019) 😊

This issues includes bits of architecture, a story and a few posts about .NET and .NET Internals.

Have a nice read!

Story

  1. Lessons learned from making a video course for Pluralsight (by Szymon Warda)
    A very nice post by Szymon Warda where he shares his experience authoring a Pluralsight course. In this post you will find a set of advises that could really help you made your first course.

Architecture

  1. Don’t get locked up into avoiding lock-in (by Gregor Hohpe)
    Working as an architect isn’t only about drawing fancy diagrams – it is also about making strategic decisions. Lock-in is one them. In this article Gregor Hohpe goes into details about what lock-in is, what types of lock-ins you has to deal with and how to approach the lock-in problem. A very interesting and easy to read article.

.NET

  1. Hardware Intrinsics in .NET Core (by Tanner Gooding)
    .NET Core 3.0 has a lot of performance improvements and one of the most significant improvements is support for hardware intrinsics. In this post Tanner Gooding starts from basic of vectorization and continues with description of features .NET Core has to implement it. All of this is demonstrated on simple but yet real world example and each result is confirmed by an appropriate benchmark.
  2. An introduction to SequenceReader (by Steve Gordon)
    .NET Core 2.1 brought us a System.IO.Pipelines to simplify implementation of high performance I/O routines. This new API heavily relies on a ReadOnlySequence<T> which is used to represents multiple separate memory blocks as a single continues block of memory. While it does the job very well it is still not the simplest thing to use. In this post Steve Gordon describes how newly introduced SequenceReader class can be used to simplify consumption of ReadOnlySequence<T> in I/O scenarios.
  3. An Introduction to System.Threading.Channels (by Steve Gordon)
    The System.IO.Pipelines API significantly simplifies the implementation of I/O scenarios but what about high level producer – consumer workflows? Are BlockingCollection and BufferBlock the only alternatives? No, there is an alternative and it is called System.Threading.Channels. In this post Steve Gordon introduce us to this relatively new library with theory and sample scenarios.
  4. Default Interface Members and Inheritance and What Are They Good For? (by Dave Glick)
    Default Interface Members is a new C# 8 feature. In these posts Dave Glick overviews how DIM plays with inheritance and explores a possibilities to use DIM.
  5. What is the difference between ToArray and ToList? (by Oleg Karasik)
    We use ToArray and ToList methods all the time. But have you ever wonder how they work? What is the difference between them? Is there is a difference? 🙂 If you have asked these questions but didn’t find the answers then this post by Oleg Karasik (it’s me) is for you.

.NET Internals

  1. Finalization implementation details (by Maoni Stephens)
    In this short but very informative post Maoni Stephens explains principles of how Finalization works and what f-reachable and finalization queues really are. Recommended to read if you like to understand how things are implemented internally.

ASP.NET Core

  1. Exploring ASP.NET Core 3.0 (by Andrew Lock)
    In this very nice series Andrew Lock explores changes and new features introduced in ASP.NET Core 3.0. This isn’t an overview series – each post is a detailed walk through a single change or feature (and there are many of them!) backed with samples and explanations.
  2. Dynamic controller routing in ASP.NET Core 3.0 (by Filip W)
    Do you know what “dynamic controller routing” is? If yes – then do you know how to implement it in ASP.NET Core 3.0? 🙂 If yes then you probably could skip this interesting post by Filip W where he gives a high level explanation of what “dynamic controller routing” is and then does a walk through (with examples!) of how it can be used to localize routes in ASP.NET Core 3.0.

Tools

  1. Ben.BlockingDetector
    A very interesting NuGet package created by Ben Adams detects a sync-over-async invocations. Each time your or any of the libraries you use make a sync-over-async call this package writes a warning message to console with detailed stack trace. Wondering what is sync-over-async? Here is a post (sample + video) by Derek Comartin with problem description and examples.
  2. AlphaFS
    In 2019 PathTooLongException is still the thing. Sometimes we can avoid it by shortening the path and sometimes we can’t. So what do we say to PathTooLongException? – Win32 API 🙂 Besides long path support AlphaFS also support file system transaction, provides more details about file system entries and what is quite important – it can be used as drop in replacement because it has all the file system classes from System.IO namespace.
  3. Announcing the first preview and code release of PowerToys
    Probably every Visual Studio developer heard about Visual Studio Productivity PowerTools but have you ever heard about PowerToys? I didn’t. PowerToys existed since Windows 95 and were officially unsupported for a long time. In 2019 Microsoft relaunched the project and now we have a preview PowerToys live!

Books we can get for free

  1. Kubernetes: Up and Running, Second Edition
    Abstract: Improve the agility, reliability, and efficiency of your distributed systems by using Kubernetes. Get the practical Kubernetes deployment skills you need in this O’Reilly e-book. You’ll learn how to: develop and deploy real-world applications; create and run a simple cluster; integrate storage into containerized microservices; use Kubernetes concepts and specialized objects like DaemonSet jobs, ConfigMaps, and secrets.

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