{"id":393874,"date":"2024-06-29T11:16:37","date_gmt":"2024-06-29T11:16:37","guid":{"rendered":"http:\/\/savepearlharbor.com\/?p=393874"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-29T21:00:00","slug":"","status":"publish","type":"post","link":"https:\/\/savepearlharbor.com\/?p=393874","title":{"rendered":"Structured Logging and Interpolated Strings in C# 10<\/span>"},"content":{"rendered":"
<\/div>\n
\n
\n
\n
\n

Structured logging is gaining more and more popularity in the developers’ community. So it makes no surprise that Microsoft has added support for it to the Microsoft.Extensions.Logging package being the part of .Net Core\/.Net 5\/.Net 6. In this article I’d like to demonstrate how we can use structured logging with this package and show the idea how we can extend it using the new features of C# 10.<\/p>\n

Initial Setup<\/h3>\n

Microsoft.Extensions.Logging is known to be a fa\u00e7ade supporting different pluggable underlying logging providers. In this article I will use the Serilog provider and will set it up to output logs to the console in JSON format.<\/p>\n

I will use simple console application as an example (GitHub Link<\/a>). Logging configuration looks the following way:<\/p>\n

\/\/ Serilog configuration Log.Logger = new LoggerConfiguration()     .MinimumLevel.Information()     .WriteTo.Console(new CompactJsonFormatter())     .CreateLogger();     \/\/ Register Serilog while creating Microsoft.Extensions.Logging.LoggerFactory using var loggerFactory = LoggerFactory.Create(     builder => builder.AddSerilog(dispose: true)); \/\/ Create an instance of ILogger using the factory var logger = loggerFactory.CreateLogger(); <\/code><\/pre>\n
Let’s also create two records which will be used in the further examples:<\/p>\n
public record Point(double X, double Y);  public record Segment(Point Start, Point End) {     public double GetLength()     {       var dx = Start.X - End.X;       var dy = Start.Y - End.Y;       return Math.Sqrt(dx * dx + dy * dy);     } } <\/code><\/pre>\n
Using ILogger<\/h3>\n
We will use the ILogger<\/code> interface for logging. This interface provides several overloads of the Log<\/code> method which take the log level as a parameter. It also provides overloads of methods Log<Level><\/code>, e.g. LogInformation<\/code>, LogError<\/code>, etc. All these method take the message template string and the array of arguments (params object[]<\/code>) as their parameters.<\/p>\n
For example, let’s log the result of a segment length calculation:<\/p>\n
var segment = new Segment(new (1, 2), new (4, 6)); var length = segment.GetLength(); logger.LogInformation(     \"The length of segment {@segment} is {length}.\", segment, length); <\/code><\/pre>\n
The template string contains two arguments enclosed in braces: segment<\/code> and length<\/code>. Their values are passed to the method as the following parameters. The @<\/code> symbol before the segment<\/code> argument is a part of the Message Template<\/a> specification which means that Serilog must expand the argument’s structure as an object. Without this symbol Serilog would just log the result of segment.ToString()<\/code>.<\/p>\n
As the result we will get the following log item:<\/p>\n
{     \"@t\": \"2021-11-13T19:57:31.8636016Z\",     \"@mt\": \"The length of segment {@segment} is {length}.\",     \"segment\": {         \"Start\": {             \"X\": 1,             \"Y\": 2,             \"$type\": \"Point\"         },         \"End\": {             \"X\": 4,             \"Y\": 6,             \"$type\": \"Point\"         },         \"$type\": \"Segment\"     },     \"length\": 5,     \"SourceContext\": \"Program\" } <\/code><\/pre>\n
The resulting JSON object has a property @mt<\/code> containing the template string, and properties segment<\/code> and length<\/code> containing the arguments.<\/p>\n
While this approach is quite easy and straightforward, it has some significant disadvantages:<\/p>\n