Hello, I am Laszlo

DotNet gRPC Getting Started

07/17/2022

In the this series of posts I will look into the details of gRPC in ASP.NET Core. In this first post I will be creating a simple service and a corresponding client. In future posts I will focus on the internal implementation of ASP.NET Core's gRPC extension. gRPC (gRPC Remote Procedure Calls is an open source remote procedure call implementation that is based on modern (web) standards. gRPC leverages HTTP2 as transport protocol, and uses Protocol Buffer as a data format and interface definition language. It is typically used for back channel (service-to-service) communication due to its efficiency. However, the efficiency comes at a cost: debugging/decoding messages are not as straightforward as with other protocols.

Creating a gRPC Service

This post provides a getting started and a look into the internals of Grpc.AspNetCore nuget package. The official documentation is spot on to get started:

• create a proto file: the proto file defines the messages exchanged by server and the client as well as the operations that a client may invoke on a server

• create a new asp.net core project (using dotnet CLI: dotnet new webapp)

• add Grpc.AspNetCore nuget package to the project (dotnet add package Grpc.AspNetCore)

• add the proto file as a Server gRPC service

Find out more

HttpClient Diagnostics

06/26/2022

HttpClient has the capability to propagate correlation Id-s in the HTTP headers of traceparent and tracestate. Every recent .NET release had changes in this scope, for the last few releases the followings has changed:

• Automatic Id propagation

• AspNet Core creates a new parent activity for each request (by default)

• Actvitity's DefaultIdFormat changed in .NET 5

• ActivitySource introduced

In .NET 6 HttpClient allows greater control on how traceIds and spanIds are propagated on downstream HTTP calls. It accomplishes this with the help of DistributedContextPropagator, which comes with a few built in propagator strategies. In this post I will look into testing these strategies work with OpenTelemetry and Jaeger.

Under the hood

Find out more

Regex Unleashed

06/05/2022

In the series of these posts, I take a regular task, and implement it multiple times in an iteratively manner, while also improving performance.

The task is the following, given an input string with placeholders in it, and a map of placeholders to actual values. Replace the placeholders in the input string with the actual text values from the map and return the final string. For example, given input string Hello [%placeholder%]! and map [%placeholder%] => World should return Hello World!. The placeholder's [%placeholder%] part is referred as the key, and World part as the value in this post.

To further clarify the task, these constraints are also true:

• placeholder keys are delimited with [% at the beginning and %] at the end

• placeholders are recursive (a placeholder's value may contain another (or the same) placeholder's key, but it should be processed recursively)

• input text contains no placeholder that are embedded by other placeholders (such as hello [%outer[%inner%]example%])

• the key of a placeholder contain letters and underscores

• the same fixed set of placeholders are used on multiple input strings

• placeholders are used at most once per input text

Find out more

My favorite sessions from Build 2022

05/28/2022

These are my favorite sessions from Build 2022:

• What's Next in C# 11

• Future Possibilities for .NET Core and WASI (WebAssembly on the Server)

• Minimal APIs: Past, Present, and Future

• Native client apps with Blazor Hybrid

• Next Steps for Distributed Programming with .NET and Orleans

• Output Caching in ASP.NET Core 7

• Codespaces: Managed cloud environments developers love with the controls their admins need

• Azure SQL and Azure Functions: Integration with SQL bindings

Find out more

Regex and Faster

05/21/2022

In the series of these posts, I take a regular task, and implement it multiple times in an iteratively manner, while also improving performance.

The task is the following, given an input string with placeholders in it, and a map of placeholders to actual values. Replace the placeholders in the input string with the actual text values from the map and return the final string. For example, given input string Hello [%placeholder%]! and map [%placeholder%] => World should return Hello World!. The placeholder's [%placeholder%] part is referred as the key, and World part as the value in this post.

To further clarify the task, these constraints are also true:

• placeholder keys are delimited with [% at the beginning and %] at the end

• placeholders are non-recursive (a placeholder's value may contain another (or the same) placeholder's key, but it should not be processed recursively)

• input text contains no placeholder that are embedded by other placeholders (such as hello [%outer[%inner%]example%])

• the key of a placeholder contain letters and underscores

• the same fixed set of placeholders are used on multiple input strings

• placeholders are used at most once per input text

Find out more