Roundup #51: .NET Core 3.0 launches at .NET Conf, .NET Standard adoption, Nullable Reference Types, Cake on Linux, Logging in ASPNET Core

Here are the things that caught my eye recently in .NET.  I’d love to hear what you found most interesting this week.  Let me know in the comments or on Twitter.

.NET Core 3.0 launches at .NET Conf

.NET Conf is a FREE, 3 day virtual developer event co-organized by the .NET community and Microsoft. This year .NET Core 3.0 will launch at .NET Conf 2019! Come celebrate and learn about the new release. You won’t want to miss this one.

Link: https://www.dotnetconf.net/

Update on .NET Standard adoption

It’s about two years ago that I announced .NET Standard 2.0. Since then we’ve been working hard to increase the set of .NET Standard-based libraries for .NET. This includes many of the BCL components, such as the Windows Compatibility Pack, but also other popular libraries, such as the JSON.NET, the Azure SDK, or the AWS SDK. In this blog post, I’ll share some thoughts and numbers about the .NET ecosystem and .NET Standard.

Link: https://devblogs.microsoft.com/dotnet/update-on-net-standard-adoption/

Try out Nullable Reference Types

With the release of .NET Core 3.0 Preview 7, C# 8.0 is considered “feature complete”. That means that the biggest feature of them all, Nullable Reference Types, is also locked down behavior-wise for the .NET Core release. It will continue to improve after C# 8.0, but it is now considered stable with the rest of C# 8.0.

Link: https://devblogs.microsoft.com/dotnet/try-out-nullable-reference-types/

How to build with Cake on Linux using Cake.CoreCLR or the Cake global tool

In this post I show two ways to use the Cake build system to build .NET Core projects on Linux: using the Cake.CoreCLR library, or the Cake.Tool .NET Core global tool.

Link: https://andrewlock.net/how-to-build-with-cake-on-linux-using-cake-coreclr-or-the-cake-global-tool/

Logging, Metrics and Events in ASP NET Core – Martin Thwaites

Providing decent monitoring of your applications has always been considered the boring part of development, with tons of boilerplate code, and making upfront decisions around how it will be done, or retrofit afterwards. However, with dotnet core, things have changed, it’s never been easier to implement effective visibility into how your application is performing in production.

In this session I will cover the fundamental differences between Metrics and Logs, and Events and look at where one is useful over the other.

We’ll look at some of the things Microsoft has done in dotnet core to make logging easier, and some of the third-party libraries and tools that aim to make it easier to navigate.

We’ll cover tools like Serilog and Log4Net, along with AppMetrics for capturing application information. We’ll then take a quick look at Grafana, and see how we can make some sense of that information. Finally, we’ll look at Honeycomb.io and how they’re providing actionable insights for distributed systems using events, enabling testing in production.

Link: https://www.youtube.com/watch?v=Fvu2DJU-dFg

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #50: HttpRepl, ReferenceAssemblies, IAsyncEnumerable, Searching Nuget, Resilience

Here are the things that caught my eye recently in .NET.  I’d love to hear what you found most interesting this week.  Let me know in the comments or on Twitter.

HttpRepl: A command-line tool for interacting with RESTful HTTP services

The ASP.NET team has built a command-line tool called HttpRepl. It lets you browse and invoke HTTP services in a similar way to working with files and folders. You give it a starting point (a base URL) and then you can execute commands like “dir” and “cd” to navigate your way around the API.

Link: https://devblogs.microsoft.com/aspnet/httprepl-a-command-line-tool-for-interacting-with-restful-http-services/

Using the ReferenceAssemblies NuGet package to build .NET Framework libraries on Linux, without installing Mono

In this post I show how you can build .NET projects that target .NET Framework versions on Linux, withoutusing Mono. By using the new Microsoft.NETFramework.ReferenceAssemblies NuGet packages from Microsoft you don’t need to install anything more than the .NET Core SDK!

Link: https://andrewlock.net/using-reference-assemblies-to-build-net-framework-libararies-on-linux-without-mono/

What’s the big deal with IAsyncEnumerable<T> in .NET Core 3.0

One of the most exciting features of .NET Core 3.0 and C# 8.0 has been the addition of IAsyncEnumerable<T> (aka async streams). But what’s so special about it? What can we do now that wasn’t possible before?

In this article, we’ll look at what challenges IAsyncEnumerable<T> is intended to solve, how to implement it in our own applications, and why IAsyncEnumerable<T> will replace Task<IEnumerable<T>> in many situations.

Link: https://dev.to/dotnet/what-s-the-big-deal-with-iasyncenumerable-t-in-net-core-3-1eii

Indexing and searching NuGet.org with Azure Functions and Search

In an application I’m writing, I need to deserialize some JSON. I know the class to use is JsonConvert, but which NuGet package was that type in again?

Granted, that’s an obvious one. Yet, there are many uses for a “NuGet reverse package search”that helps finding the correct NuGet package based on a public type.

While ReSharper and Rider initially added this nice feature and Visual Studio has added this a few years later as well, I wanted to see if I could build an indexer and search engine that collects public type information from NuGet packages and makes them searchable. And along the way, I discovered that this would be an ideal use case for Azure Functions.

Link: https://blog.maartenballiauw.be/post/2019/07/30/indexing-searching-nuget-with-azure-functions-and-search.html

System Stable: Robust connected applications with Polly, the .NET Resilience Framework – Bryan Hogan

In this session I will show you how with just a few lines of code you can make your applications much more resilient and reliable. With Polly, the .NET resilience framework, your application can easily tolerate transient faults and longer outages in remote systems or infrastructure.

At the end of this hour you will know how to use all the features of Polly to make your application a rock solid piece of work. We’ll cover the reactive and proactive resilience strategies, starting with simple but very powerful retries and finishing with bulkhead isolation.

Oh, and did I mention Polly is a .NET Standard library so it will work on any application you can think of!

Join me for an hour, and your applications will never be the same.

Link: https://www.youtube.com/watch?v=esEDPtBJz40

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #49: .NET Core 3 Preview 7, MasterMemory, Alternatives to Microsoft.FeatureManagement, Monolith Decomposition Patterns

Here are the things that caught my eye recently in .NET.  I’d love to hear what you found most interesting this week.  Let me know in the comments or on Twitter.

.NET Core 3.0 Preview 7

Today, we are announcing .NET Core 3.0 Preview 7. We’ve transitioned from creating new features to polishing the release. Expect a singular focus on quality for the remaining preview releases.

Link: https://devblogs.microsoft.com/dotnet/announcing-net-core-3-0-preview-7/

MasterMemory — Embedded Typed Readonly In-Memory Document Database for .NET Core and Unity

As a new open-source library, we present to you a read-only in-memory database that focuses on management use of master data.

We made it from our experience in game development up until now with an emphasis on the three points of “Saving memory (also because it is called in-memory, it pays attention to memory usage)”; “High-speed database loading (when it takes a long time to build, it will have a major effect on a game’s startup speed)”; and “High-speed search (similar queries as dictionary lookup.)” 

Link: https://medium.com/@neuecc/mastermemory-embedded-typed-readonly-in-memory-document-database-for-net-core-and-unity-7ff4519ae0f

Alternatives to Microsoft.FeatureManagement

In this series I’ve been looking at the Microsoft.FeatureManagement library (which is now open source on GitHub 🎉). This provides a thin layer over the .NET Core configuration system for adding feature flags to your application. But this library is new, and the feature flag concept is not – so what were people using previously?

Link: https://andrewlock.net/alternatives-to-microsoft-featuremanagement/

Monolith Decomposition Patterns – Sam Newman

Patterns to help you incrementally migrate from a monolith to microservices.

Big Bang rebuilds of systems is so 20th century. With our users expecting new functionality to be shipped ever more frequently than before, we no longer have the luxury of a complete system rebuild. In fact, a Big Bang migration of a Monolithic architecture into a microservice architecture can be especially problematic, as we’ll explore in this talk. We want to ship features, but we also want to change our architecture – and many of us want to be able to break down existing systems into microservice architectures. But how do you do this while still shipping features?

In this talk, I’ll share with you some key principles and a number of patterns which you can use to incrementally decompose an existing system into microservices. I’ll even cover off patterns that can work to migrate functionality out of systems you can’t change, making them useful when working with very old systems or vendor products. We’ll look at the use of stranger patterns, change data capture, database decomposition and more.

Link: https://www.youtube.com/watch?v=64w1zbpHGTg

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.