Category: ASP.NET

Roundup #32: System.IO.Pipelines, Libraries vs Frameworks, Performance Profiling in Rider, Cyclomatic Complexity, Lessons from the Birth of Microservices

Derek Comartin Leave a comment

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.

Follow @CodeOpinion on Twitter

https://youtu.be/BX-CDrTzi8Q

High Performance IO with System.IO.Pipelines

Pipelines was born from the work the .NET Core team was doing to make it easier to do high performance IO in .NET.

In this episode, Pavel Krymets (@pakrym) and David Fowler (@davidfowl) come on the show to give us an overview of how the Pipelines programming model works, as well as give show us a few demos on how to use the API.

https://www.youtube.com/watch?v=1koWtKkKb_o

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

Libraries vs Frameworks w/ Dennis Doomen

Dennis Doomen is on an everlasting quest for better solutions that will significantly improve the efficiency, the quality and the productivity of your software development teams.

And among other things he is the author of Fluent Assertions, an API for asserting the results of unit tests in .NET.

Link: https://6figuredev.com/podcast/episode-074-libraries-vs-frameworks-w-dennis-doomen/

Performance Profiling in Rider

If you’re an active Rider 2018.3 user or just follow our blog, you probably know that Rider just got an integrated performance profiler based on JetBrains dotTrace. Though we’ve already reviewed the profiler features on the EAP stage, the release version brings some important changes, especially concerning profiling session configuration. Read this post to learn more about the changes.

Link: https://blog.jetbrains.com/dotnet/2019/01/17/performance-profiling-rider-2018-3-whats-new/

Rider Cyclomatic Complexity Plugin

Link: https://plugins.jetbrains.com/plugin/10395-cyclomaticcomplexity

What We Got Wrong: Lessons from the Birth of Microservices

Ben Sigelman talks about what Google got wrong about microservices, the lessons learned along the way and how to apply those lessons today.

https://www.youtube.com/watch?v=-pDyNsB9Zr0

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

Follow @CodeOpinion on Twitter

Software Architecture & Design

Get all my latest YouTube Vidoes and Blog Posts on Software Architecture & Design

Roundup #31: .NET OSS, Async Startup, Loki Serilog, Monitoring, Collectible Assemblies, Alba 3.0

Derek Comartin Leave a comment

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.

https://youtu.be/RwnEanSxd-Y
Follow @CodeOpinion on Twitter

Starting the .NET Open Source Revolution

Today building open source software at Microsoft is normal — but when I started at Microsoft in 2007, it sure wasn’t. It took a few years to figure out the right thing to do and to get the big ship that is Microsoft turned into the wind of open source. But we’re there now and I look back on those early challenges with a smile. This is my story of the first successful open source project at Microsoft and how it paved the way to where we are today.

Link: https://medium.com/microsoft-open-source-stories/starting-the-net-open-source-revolution-e0268b02ac8a

Running async tasks on app startup in ASP.NET Core (Part 1)

Sometimes you need to perform one-off initialisation logic before your app starts up properly. For example, you might want to validate your configuration is correct, populate a cache, or run database migrations. In this post, I look at the options available and show some simple methods and extension points that I think solve the problem well.

Link: https://andrewlock.net/running-async-tasks-on-app-startup-in-asp-net-core-part-1/

Serilog Sink for Loki

This is a Serilog Sink for Grafana’s new Loki Log Aggregator.

What is Loki?

Loki is a horizontally-scalable, highly-available, multi-tenant log aggregation system inspired by Prometheus. It is designed to be very cost effective and easy to operate, as it does not index the contents of the logs, but rather a set of labels for each log stream.

Link: https://github.com/JosephWoodward/Serilog-Sinks-Loki

Monitoring GC and memory allocations with .NET Core 2.2 and Application Insights

It all started when we were migrating some of our service from .NET Framework to .NET Core. We have been using Application Insights, using it’s performance counter collection feature to monitor performance counters on our Windows server that run our applications. We soon discovered when we moved over to .NET Core that we’d have to do things differently, since performance counters aren’t supported in Application Insights for .NET Core.

Link: https://stebet.net/monitoring-gc-and-memory-allocations-with-net-core-2-2-and-application-insights/

Collectible assemblies in .NET Core 3.0

Since the beginning of .NET Core, the one feature that I have been most anxiously waiting for, has been support for collectible assemblies. It took a while (a while!), but finally, in .NET Core 3.0 (at the time of writing 3.0.0-preview-27122-01 from 2018-12-04), it’s here.


It’s going to be a killer functionality, that will support some excellent use cases in .NET Core – especially around application plugins, extensibility and dynamic assembly generation.

Link: https://www.strathweb.com/2019/01/collectible-assemblies-in-net-core-3-0/

Alba 3.0 – TestServer on steroids and HTTP contract testing for .NET

Alba is a library you can use in combination with xUnit/NUnit to much more easily author integration tests against ASP.Net Core applications by running HTTP requests in process.

Link: https://jeremydmiller.com/2019/01/09/alba-3-0-testhost-on-steroids-and-http-contract-testing-for-net/

Follow @CodeOpinion on Twitter

Software Architecture & Design

Get all my latest YouTube Vidoes and Blog Posts on Software Architecture & Design

Roundup #30: ProxyKit, BeeHive, Nullable Ref Types, Close Loops & Opening Minds

Derek Comartin Leave a comment

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.

Follow @CodeOpinion on Twitter
https://youtu.be/MzAAC7UXBAs

ProxyKit

A toolkit to create HTTP proxies hosted in ASP.NET Core as middleware. This allows focused code-first proxies that can be embedded in existing ASP.NET Core applications or deployed as a standalone server. Deployable anywhere ASP.NET Core is deployable such as Windows, Linux, Containers, and Serverless (with caveats).

Link: https://github.com/damianh/ProxyKit

BeeHive

A Zero Friction mini-Framework for cloud Actors – currently for Windows Azure only. Implementation is very simple – if you need a complex implementation of the Actor Model, you are probably doing it wrong. It supports .NET Framework 4.5.2+ and .NET Standard 2.0+.

Link: https://github.com/aliostad/BeeHive

C# 8 Nullable Reference Types

C# 8.0 will introduce a new groundbreaking feature called Nullable reference types, this feature will change the way we currently develop our software in C# by making, you guessed it, reference types nullable.

Link: https://www.marcbruins.nl/C-8-Nullable-reference-types

Close Loops & Opening Minds: How to Take Control of Systems, Big & Small

Whether it’s distributing configurations and customer settings, launching instances, or responding to surges in load, having a great control plane is key to the success of any system or service. Come hear about the techniques we use to build stable and scalable control planes at Amazon. We dive deep into the designs that power the most reliable systems at AWS. We share hard-earned operational lessons and explain academic control theory in easy-to-apply patterns and principles that are immediately useful in your own designs.

https://www.youtube.com/watch?v=O8xLxNje30M

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

Follow @CodeOpinion on Twitter

Software Architecture & Design

Get all my latest YouTube Vidoes and Blog Posts on Software Architecture & Design