Follow @codeopinion

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.

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

Matthias 👻 on Twitter

Around 7 years ago I went to StackOverlfow and asked for a tool that shows Cyclomatic Complexity metrics next to methods. Today I added CodeVision support in our CC plugin for @jetbrainsrider which does exactly that. That's exciting! 🥳 https://t.co/thEKWscFBr

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.

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

Follow @codeopinion

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Leave this field empty if you’re human:

Follow @codeopinion

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

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Leave this field empty if you’re human:

Follow @codeopinion

ProxyKit

Damian Hickey ❄️ on Twitter

ProxyKit 1.0.0 released. A toolkit for creating (reverse) proxies on https://t.co/4ByDHwXBWr Core. https://t.co/o0av6dBPsB Thanks to @ErwinVanDerValk , @oguzsoykan, @jchannon, @Joe_Stead and @adamralph for help and contributions. And for Aspnet labs for the original code.

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.

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

Follow @codeopinion

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Leave this field empty if you’re human:

In this section, I’m going to extend my existing ASP.NET Core application to explore more of what SignalR Server Hubs have to offer.

This blog post is apart of a course that is a complete step-by-setup guide on how to build real-time web applications using ASP.NET Core SignalR. By the end of this course, you’ll be able to build real-world, scalable, production applications using the tools and techniques provided in this course.

If you haven’t already, check out the prior sections of this course.

1. Course Overview
2. ASP.NET Core SignalR Overview
3. Basics

SignalR Server Hubs

A SignalR Server Hub is a primary point at which all communication between client and server occur. You define methods in a hub that can be called by the client. And in the client code, we can define methods that our hub can call.

We can define methods on our hub that can communicate directly with the specific client (caller) who is making the call to our hub. I’m going to add a new method to our existing MessageHub called SendMessageToCaller

Clients

We can also send data to specific clients. To do so, we simply need to know the ConnectionId of the client we want to send data to.

I’ll add a new method called SendMessageToUser which will accept a connectionId as the first parameter which we will use.

In order for our clients to know about each other, I’m going to override two methods on our Hub. OnConnectedAsync and OnDisconnectedAsync. I’ll use these methods to let all connected clients know when a new client as connected or disconnected. This way the clients/browser can keep track of the ConnectionID’s available, in order to send to specific clients.

Groups

Lastly, we can also define Groups of connections. This giving us the ability to send data to specific groups. This is often useful for multi-tenant applications.

I’ll create two new methods, one method JoinGroup which will be used for our clients to join a specific group. SendMessageToGroup will be used to send data to the specific clients that have already called JoinGroup.

Client

First, I’ll update my Razor Page to contain a new select list to specify who we want to send the message to, All, Myself or PrivateGroup. I’ll also add a button that we will wire-up to call our JoinGroup on our Hub.

Now we will wire up our new UI by adding in SignalR client handlers for UserConnected, UserDisconnected events. I’ll also add UI for the Join button click as well as using the select list to determine which methodto invoke on our Hub.

Get The Course!

You’ve got several options:

1. Check out my Practical ASP.NET Core SignalR playlist on my CodeOpinion YouTube channel.
2. Access the full course now by enrolling for free on Teachable.
3. Follow along with the blog post series here on CodeOpinion.com
4. Course Overview
5. ASP.NET Core SignalR Overview
6. Basics
7. Server Hubs
8. Server Concepts (Coming Soon)
9. Scaling (Coming Soon)

Follow @codeopinion

Source Code

All of the source code for this blog post and this course is available the Practical.AspNetCore.SignalR repo on GitHub.

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

Follow @codeopinion

.NET Core configuration provider for AWS Systems Manager

We released a new NuGet package, Amazon.Extensions.Configuration.SystemsManager. This NuGet package simplifies how your application loads the application configuration settings in the AWS Systems Manager Parameter Store into the .NET Core configuration system.

Link: https://aws.amazon.com/blogs/developer/net-core-configuration-provider-for-aws-systems-manager/

System.CommandLine

This repository contains the code for System.CommandLine, a library for command line parsing, invocation, and rendering of terminal output. For more information, please see our wiki.

Link: https://github.com/dotnet/command-line-api

AzurePipelines.TestLogger

Announce a new test logger for the Visual Studio Test Platform designed to publish your test results in real-time to Azure Pipelines. This means that you can run dotnet test from your build script on Azure Pipelines and feed your test results directly to the test summary for your build without having to rely on post-processing like the PublishTestResults Azure Pipelines task.

Link: https://daveaglick.com/posts/announcing-azurepipelines-testlogger

Windows Sandbox

How many times have you downloaded an executable file, but were afraid to run it? Have you ever been in a situation which required a clean installation of Windows, but didn’t want to set up a virtual machine?

At Microsoft we regularly encounter these situations, so we developed Windows Sandbox: an isolated, temporary, desktop environment where you can run untrusted software without the fear of lasting impact to your PC. Any software installed in Windows Sandbox stays only in the sandbox and cannot affect your host. Once Windows Sandbox is closed, all the software with all its files and state are permanently deleted.

Link: https://techcommunity.microsoft.com/t5/Windows-Kernel-Internals/Windows-Sandbox/ba-p/301849

Ambrosia: Robust Distributed Programming Made Easy and Efficient

Ambrosia is a programming language independent approach for authoring and deploying highly robust distributed applications. Ambrosia dramatically lowers development and deployment costs and time to market by automatically providing recovery and high availability.

Link: https://github.com/Microsoft/AMBROSIA

Follow @codeopinion

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Leave this field empty if you’re human:

In this section, I’m going to create a simple ASP.NET Core application that will contain a SignalR Hub, Razor Page, and a JavaScript Client.

This blog post is apart of a course that is a complete step-by-setup guide on how to build real-time web applications using ASP.NET Core SignalR. By the end of this course, you’ll be able to build real-world, scalable, production applications using the tools and techniques provided in this course.

If you haven’t already, check out the prior sections of this course.

1. Course Overview
2. ASP.NET Core SignalR Overview

Video Tutorial

Server Hubs

A hub is a primary point at which all communication between client and server occur. You define methods in a hub that can be called by the client. And in the client code, we can define methods that our hub can call.

First thing is first, we need to install the SignalR package from NuGet. The simplest way is to modify your csproj by adding:

<PackageReference Include="Microsoft.AspNetCore.SignalR" Version="1.1.0" />

Message Hub

I’m going to create the simplest hub which will just send a message to all connected clients.

Startup.cs

Next, we need to add SignalR to the IServiceCollection in the ConfigureServices method. As well, we configure a route to our message hub in the Configure Method.

SignalR JavaScript Client

First thing will be to get the JavaScript client library from npm.

npm install @aspnet/signalr

From here you will want to copy the client file from node_modules/signalr/dist/browser/signalr.js to your wwwroot/lib/signalr.js

Razor Page

Next, I’m going to create a Razor page that will just contain a simple textarea and button that we will wire up to the SignalR hub. It will also contain a script tag to reference the signalr.js file and a file we will create next called messages.js

JavaScript

Now they are referencing messages.js, let’s actually create it. This file will provide the functionality to connect to our SignalR Server Hub, send messages to the hub, and receive messages from the hub.

Get The Course!

You’ve got several options:

1. Check out my Practical ASP.NET Core SignalR playlist on my CodeOpinion YouTube channel.
2. Access the full course now by enrolling for free on Teachable.
3. Follow along with the blog post series here on CodeOpinion.com
4. Course Overview
5. ASP.NET Core SignalR Overview
6. Basics
7. Server Hubs (Coming Soon)
8. Server Concepts (Coming Soon)
9. Scaling (Coming Soon)

Follow @codeopinion

Source Code

All of the source code for this blog post and this course is available the Practical.AspNetCore.SignalR repo on GitHub.

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

Follow @codeopinion

MinVer

A minimalistic .NET package for versioning .NET SDK-style projects using Git tags.

When you want to release a version of your software, whether it’s a pre-release, RTM, patch, or anything else, simply create a tag with a name which is a valid SemVer 2.0 version and build your projects. MinVer will apply the version to the assemblies and packages. (If you like to prefix your tag names, see the FAQ.)

Link: https://github.com/adamralph/minver

REST Fest 2018: Kin Lane

Kin Lane (API Evangelist) — ‘’API Discovery in the Real World is Complicated’’ — 28 September 2018

REST Fest 2018 \ Kin Lane (API Evangelist) \ 2018 Keynote from REST Fest on Vimeo.

Link: https://vimeo.com/295217613

Dependabot

Dependabot pulls down your dependency files and looks for any outdated or insecure requirements.

If any of your dependencies are out-of-date, Dependabot opens individual pull requests to update each one.

You check that your tests pass, scan the included changelog and release notes, then hit merge with confidence.

Link: https://dependabot.com/

Stop Using Repository Pattern With an ORM

In this post I’m going to list some reasons suggested for using repository pattern. Then we’re going to see if these reasons really needs these kind of patterns to be solved. Then I’m going to propose other alternatives for solving these problems.

Link: http://hamidmosalla.com/2018/11/25/stop-using-repository-pattern-with-an-orm/

dotJS 2018 — Anders Hejlsberg

How do you define and implement a static type system for a dynamic language like JavaScript, and why would you even care to? Anders explores how TypeScript came to be, how it differs from classic type systems, and how it can be beneficial even if you don’t like types.

If you’re not on the TypeScript train yet, why not? But really, it might be worth a watch if you aren’t.

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

Follow @codeopinion

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Leave this field empty if you’re human:

In some projects, I use the AssemblyInfo Patcher build feature to modify the AssemblyInfo.cs’s version information. Mainly I was just using a static version with the %build_number% suffixed at the end. Something like 1.2.3.%build_number%. However, I decided to go with a date version number of YYYY.MM.DD.%build_number%

Variables

The first thing that caused me an issue was there is no existing system or environment variables defined that provide you with date parts. I figured this by adding a new build step for creating an environment variable using Service Messages.

Service messages are specially constructed pieces of text that are used to pass commands/information about the build from the build script to the TeamCity server.

To be processed by TeamCity, they need to be written to the standard output stream of the build, i.e. printed or echoed from a build step. It is recommended to output a single service message per line (i.e. divide messages with newline symbol(s))

What this allowed me to do was create a build step in PowerShell and use Write-Host to output a service message:

Write-Host "##teamcity[setParameter name='env.BUILD_DATE' value='$([DateTime]::Now.Year.ToString() + "." + [DateTime]::Now.Month.ToString() + "." + [DateTime]::Now.Day.ToString())']"

This will create a new environment variable that I can use called %env.BUILD_DATE%

AssemblyInfo Patcher

As mentioned, I use this build feature to modify the AssemblyInfo.cs, however, I immediately ran into an issue.

AssemblyInfo Patcher should be used with the automatic checkout only: after this build feature is configured, it will run before the first build step. TeamCity will first perform replacement in the files found in the build checkout directory and then run your build.

The issue is that the AssemblyInfo patcher is run before the first build step which is setting the environment variable. Meaning I cannot use the environment variable in the AssemblyInfo patcher.

Snapshot Dependencies

What I decided to do was create a new build configuration that only contained one build step. That build step would be the PowerShell above which sets the environment variable. Then I would link my existing build configuration to this new build configuration. In TeamCity these are defined as SnapShot Dependencies.

Build configurations linked by a snapshot dependency will use the same snapshot of the sources. The build of this configuration will run after all the dependencies are built. If necessary, the dependencies will be triggered automatically.

Dependency Properties

Once I had my dependencies defined, you can use build parameters from linked dependencies. Now in the assembly patcher, I can use the environment variable by:

%dep.[ConfigurationID].env.BUILD_DATE%

ASP.NET Core SignalR is an excellent way to add real-time functionality to your web applications. You may be wondering, what exactly is real-time web functionality and what problem does that solve?

Here’s an overview of what problems SignalR solves, and how it does it using various technologies.

This blog post is apart of a course that is a complete step-by-setup guide on how to build real-time web applications using ASP.NET Core SignalR. By the end of this course, you’ll be able to build real-world, scalable, production applications using the tools and techniques provided in this course.

What you’ll learn:

• Creating ASP.NET Core SignalR Hubs
• Connecting to Hubs using JavaScript Clients
• Scaling your application using Redis and Azure

If you haven’t already, check out the prior sections of this course.

1. Course Overview

ASP.NET CoreSignalR Overview

ASP.NET Core SignalR: Problem Space

ASP.NET Core SignalR: Push

ASP.NET Core SignalR: Summary

Get The Course!

If you want all the content right now, you can access the full course now by enrolling for free on Teachable. Otherwise stay tuned to this blog and my YouTube Channel for all the content in the coming weeks.

Follow @codeopinion

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

Follow @codeopinion

Today’s JavaScript trash fire and pile on

Four years ago I wrote a slightly inflamatory blog on what still sucks in front-end dev. One of the points was on Bower and how JS library management sucks. Sadly, the tools have changed, but JS library managment still sucks.

This post is in response to the recent npm even-stream package that had malicious code injected into it by a new maintainer.

Link: https://medium.com/@cnorthwood/todays-javascript-trash-fire-and-pile-on-f3efcf8ac8c7

Open-Source Maintainers are Jerks!

As software developers we often make use of open-source software (OSS) but do we ever think about all the man hours that go into developing and supporting the project. When OSS breaks, or we need a new features, we log an issue on gitHub and then sit back awaiting a response. After a week of waiting we start complaining about how badly the project is run. The thing about OSS that’s too often forgetten, it’s AS-IS, no exceptions. Different projects may operate differently, with more or less people, with work being prioritised differently, on differing release schedules but in all cases the software delivered is as-is, meaning that there is absolutely no SLA. In this talk we’ll look at a day in the life of an OSS maintainer: what drives them, what annoys them and what keeps them up at night. Maintainers aren’t jerks, they just care about the project more than you do.

Thought this was a worthwile related talk to watch in regards to the npm package issue this week.

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

Serverless Data APIs with Azure Functions and Cosmos DB

Azure Functions, Microsoft’s serverless offering, allow developers to focus on their code and not be concerned with infrastructure or DevOps. And thanks to a slew of built-in integrations, it’s also easy to have your functions get and send data to various services or even be triggered by events in those services. One such integration is with Azure Cosmos DB, the multi-model, globally distributed NoSQL data service. Cosmos DB exposes data as documents that you can access via SQL, JavaScript MongoDB or Cassandra as well as graph and key-value store. In this session, you’ll see how easily you can build an API from a set of Azure Functions that interact with Cosmos DB documents and some other services. We’ll go all cross-platform with Visual Studio Code and Node JS.

Julie Lerman — Serverless Data APIs with Azure Functions and Cosmos DB | Øredev 2018 from Øredev Conference on Vimeo.

Link: https://vimeo.com/302679933

windows-dev-box-setup-scripts

The goal of this project is to provide a central place to share ideas for streamlining dev box setup and provide sample scripts for common dev scenarios. It’s likely you will want to take the scripts here and modify them to fit your particular needs.

I was recentlys setting up a new dev machine and Rich Turner pointed me to this repo.

Guarded Devirtualization

Guarded devirtualization is a proposed new optimization for the jit in .Net Core 3.0. This document describes the motivation, initial design sketch, and highlights various issues needing further investigatio

The .Net Core jit is able to do a limited amount of devirtualization for virtual and interface calls. This ability was added in .Net Core 2.0. To devirtualize the jit must be able to demonstrate one of two things: either that it knows the type of some reference exactly (say because it has seen a newobj) or that the declared type of the reference is a final class (aka sealed). For virtual calls the jit can also devirtualize if it can prove the method is marked as final.

Link: https://github.com/dotnet/coreclr/blob/5af32b00186ba37f5b2cdc4b0a9b5715d7807f1d/Documentation/design-docs/GuardedDevirtualization.md

Follow @codeopinion

Enjoy this post? Subscribe!

Subscribe to our weekly Newsletter and stay tuned.

Leave this field empty if you’re human: