Roundup #45: AWS Secrets Manager, Microservices, ASP.NET Core Architect, WCF vs gRPC

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

AWS Secrets Manager client-side caching in .NET

AWS Secrets Manager now has a client-side caching library for.NET that makes it easier to access secrets from .NET applications. This is in addition to client-side caching libraries for Java, JDBCPython, and Go. These libraries help you improve availability, reduce latency, and reduce the cost of retrieving your secrets. Secrets Manager cache library does this by serving secrets out of a local cache and eliminating frequent Secrets Manager API calls.

Link: https://aws.amazon.com/blogs/security/how-to-use-aws-secrets-manager-client-side-caching-in-dotnet/

Microservices and more in .NET Core 3.0

Enabling developers to build resilient microservices is an important goal for .NET Core 3.0 In this episode, Shayne Boyer is joined by Glenn Condron and Ryan Nowak from the ASP.NET team who discuss some of the exciting work that’s happening in the microservice space for .NET Core 3.0.

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

Becoming the ASP.NET Architect with David Fowler

In this episode, David Fowler, the Partner Architect for the ASP.NET team walks you through landing his first job, moving from a dev to an architect role and what he had to learn and let go of at every step along the path. (David intros himself as a Principal Architect but his promotion was announced right after we filmed.)

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

WCF vs gRPC – Round 2

After my previous post comparing WCF to gRPC, a couple of people on Twitter and in the comments asked which WCF binding I had used for the performance comparison. The answer to that was “whatever the default binding is”, which is basic HTTP binding. As Clemens Vaster pointed out, that is not an “apples-to-apples” comparison, and a fairer WCF vs gRPC test would use NetTCP binding. So I re-ran my performance tests using NetTCP binding in a simple console host for the WCF service.

Link: https://unwcf.com/posts/wcf-vs-grpc-round-2/

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #44: Porting Desktop Apps to .NET Core, .NET Core 3 Progress, GC Pressure, WCF vs gRPC

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

Porting desktop apps to .NET Core

Since I’ve been working with the community on porting desktop applications from .NET Framework to .NET Core, I’ve noticed that there are two camps of folks: some want a very simple and short list of instructions to get their apps ported to .NET Core while others prefer a more principled approach with more background information. Instead of writing up a “Swiss Army knife”-document, we are going to publish two blog posts, one for each camp:

This post is the simple case. It’s focused on simple instructions and smaller applications and is the easiest way to move your app to .NET Core.

We will publish another post for more complicated cases. This post will focus more on non-trivial applications, such WPF application with dependencies on WCF and third-party UI packages.

If you prefer watching videos instead of reading, here is the video where I do everything that is described below.

Link: https://devblogs.microsoft.com/dotnet/porting-desktop-apps-to-net-core/

.NET Core 3.0 Progress

Link: https://twitter.com/ziki_cz/status/1133786512473018368

8 Techniques to Avoid GC Pressure and Improve Performance in C# .NET

In a .NET application, memory and performance are very much linked. Poor memory management can hurt performance in many ways. One such effect is called GC Pressure or Memory Pressure.

GC Pressure (garbage collector pressure) is when the GC doesn’t keep up with memory deallocations. When the GC is pressured, it will spend more time garbage collecting, and these collections will come more frequently. When your app spends more time garbage collecting, it spends less time executing code, thus directly hurting performance.

Link: https://michaelscodingspot.com/avoid-gc-pressure/

WCF vs gRPC

One of the alternatives recommended by Microsoft for organizations looking for a migration path away from WCF on .NET Framework is gRPC: a low-overhead, high-performance, cross-platform RPC framework. The upcoming .NET Core 3.0 has first-class support for gRPC; out of the box, you can create a new project with dotnet new grpc.

Link: https://unwcf.com/posts/wcf-vs-grpc/

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Roundup #43: .NET 5, gRPC, .NET Core 3 Perf, App Service Dashboard, Interface Default Implementation

I was away while Microsoft BUILD happened last week. After catching up, here are the things that caught my eye this week in .NET.  I’d love to hear what you found most interesting this week.  Let me know in the comments or on Twitter.

Introducing .NET 5

Today, we’re announcing that the next release after .NET Core 3.0 will be .NET 5. This will be the next big release in the .NET family.

There will be just one .NET going forward, and you will be able to use it to target Windows, Linux, macOS, iOS, Android, tvOS, watchOS and WebAssembly and more.

We will introduce new .NET APIs, runtime capabilities and language features as part of .NET 5.

There were a lot of announcements at Build but this is the one that caught most of my attention.

Link: https://devblogs.microsoft.com/dotnet/introducing-net-5/

Introduction to gRPC on ASP.NET Core

gRPC is a language agnostic, high-performance Remote Procedure Call (RPC) framework. For more on gRPC fundamentals, see the gRPC documentation page.

I never noticed the docs available for gRPC. Most notably is the Comparing gRPC services with HTTP APIs

Link: https://docs.microsoft.com/en-us/aspnet/core/grpc/?view=aspnetcore-3.0

Performance Improvements in .NET Core 3.0

Back when we were getting ready to ship .NET Core 2.0, I wrote a blog post exploring some of the many performance improvements that had gone into it. I enjoyed putting it together so much and received such a positive response to the post that I did it again for .NET Core 2.1, a version for which performance was also a significant focus. With //build last week and .NET Core 3.0‘s release now on the horizon, I’m thrilled to have an opportunity to do it again.

Link: https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-core-3-0/

ASP.NET Core on App Service Dashboard

Link: https://aspnetcoreon.azurewebsites.net/

Default implementations in interfaces

With last week’s posts Announcing .NET Core 3.0 Preview 5 and Visual Studio 2019 version 16.1 Preview 3, the last major feature of C# 8.0 is now available in preview.

A big impediment to software evolution has been the fact that you couldn’t add new members to a public interface. You would break existing implementers of the interface; after all they would have no implementation for the new member!

Default implementations help with that. An interface member can now be specified with a code body, and if an implementing class or struct does not provide an implementation of that member, no error occurs. Instead, the default implementation is used.

Link: https://devblogs.microsoft.com/dotnet/default-implementations-in-interfaces/

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.