Author: csharp.academy

By default when you output the Ratio column in BenchmarkDotNet using the Baseline = true attribute it is output using the Value approach below. This means that the baseline method will be shown as 1.00 and that other methods will be shown as a relative value to this. If we wish we can also output … Continue reading How to set the Ratio column style in BenchmarkDotNet results

Since C#8 we can use single line using declarations which will allow us to dispose of resources at the end of the enclosing scope. This helps us reduce nesting in our code BUT… … while the using {} approach allows us to explicitly tell the compiler when to dispose of a resource, the C#8+ using declaration … Continue reading Using declarations in C#8+ can allow us to dispose of resources correctly without increasing nesting levels

If you’re using BenchmarkDotNet and want to see how other methods compare against a baseline method, set the Baseline attribute on your baseline method. Doing this will result in the Ratio column being outputted as shown below… More info from the Benchmark and Job Baselines page on BenchmarkDotNet.org.

The using static directive was introduced in C# 6 and allows us to omit the type name when calling static methods… cool right? … but I wouldn’t use this when omitting the type name would result in ambiguity or confusion for the next developer about what class a static method is in. The examples below … Continue reading Omit type name when calling static methods with the using static directive in C#

In C# we can use aliases to provide shorthand references to types or namespaces. Aliases can be useful to tidy up our code for example when we might be repeatability referencing generic types. They also help to remove ambiguity when we have conflicting type names in difference namespaces. In this case without aliases we would … Continue reading Using aliases in C# to provide shorthand references to types or namespaces

Does anyone actually use this variation of declaring variables? I rarely see it. I think its possibly useful in instances where the variables are highly related (eg.. x, y or startDate, endDate). This way the reader can know they belong together but I wouldn’t be bunching a load of variables up just because they are … Continue reading Declaring and setting multiple variables of the same type in the same statement in C#

The benchmarks (originally published on LinkedIn) below from Guilherme Ferreira show’s that there’s a big performance difference between using ToString() and nameof() when we are trying to get the string representation of a particular enum value… Why? … Well we can see from the IL below that nameof is evaluated at compile time and basically hardcodes … Continue reading ToString() v nameof() performance comparison when getting a string value from a enum option

If you’ve created long strings using string interpolation ($) and hit enter to prevent horizontal scroll Visual Studio will + two interpolated strings together. In .NET 5 and below this didn’t really matter as string concat via + and $ both delegated to String.Concat(). In NET 6 interpolation works different and is faster and more … Continue reading Breaking up long interpolated strings can impact performance in .NET 6

FYI… setting capacity on a List<> when creating it can avoid a lot of expensive resizing operations. Even if we don’t know exactly how big the list will be, a somewhat accurate estimate can still likely improve speed. Note though the higher our estimate is above the final list size the more unnecessary memory will … Continue reading Set List initial capacity to improve speed

In C# if you’re referencing property, class or namespace names in your code use the nameof() expression rather than strings so your references are type safe… If you have string literals containing property, class and namespace names all around your code you have to maintain them manually. If you rename a class which is referenced … Continue reading In C# use the nameof() expression so your property, class and namespace references are type safe