DEV Community: Giorgi Anakidze

Stop Guessing, Start Measuring: Transform Your Code with BenchmarkDotnet!

Giorgi Anakidze — Tue, 13 Feb 2024 14:09:51 +0000

Imagine perfecting your .NET application only to struggle with performance measurement. BenchmarkDotnet resolves this, offering developers a streamlined solution for precise benchmarking. Are you in your way to migrating the project from .NET 5 to .NET 8? Is it really worth it? BenchmarkDotnet allows you to test your most time or memory consuming methods against multiple versions of .NET framework with ease and decide whether you really should do it.

Demystifying BenchmarkDotnet

Let’s look at the first example you see, when you open up BenchmarkDotnet’s website, or Github page.

[SimpleJob(RuntimeMoniker.Net472, baseline: true)]
[SimpleJob(RuntimeMoniker.NetCoreApp30)]
[SimpleJob(RuntimeMoniker.NativeAot70)]
[SimpleJob(RuntimeMoniker.Mono)]
[RPlotExporter]
public class Md5VsSha256
{
    private SHA256 sha256 = SHA256.Create();
    private MD5 md5 = MD5.Create();
    private byte[] data;

    [Params(1000, 10000)]
    public int N;

    [GlobalSetup]
    public void Setup()
    {
        data = new byte[N];
        new Random(42).NextBytes(data);
    }

    [Benchmark]
    public byte[] Sha256() => sha256.ComputeHash(data);

    [Benchmark]
    public byte[] Md5() => md5.ComputeHash(data);
}

It’s not required for you to understand everything right now, BenchmarkDotnet has beautiful docs and you could dive straight into it after reading this article, but there are some key concepts that you should understand while using BenchmarkDotnet.

1. Targeting multiple versions

With BenchmarkDotnet you can easily test your code against multiple versions of .NET and all you have to do is using an attribute just as we saw in the example above.

[SimpleJob(RuntimeMoniker.Net472, baseline: true)]

You could use as much of these as you want, you’re not really restricted, but it is mandatory that only one of them has baseline: true flag, it shouldn’t be more than that, but it shouldn’t be none as well, if you’re targeting multiple versions of .NET framework.

Remember! It’s crucial to have all target versions of .NET installed on your system.

2. Moving setup away from benchmarks

While making benchmarks, your code may require some additional data to work with and you typically don’t want to have the data generating process inside of your benchmarks, because then it counts as method execution time, which may not be true in all cases. BenchmarkDotnet solves this problem in an elegant way, you just have to make a method for data generation purposes and mark it as [GlobalSetup].

    [GlobalSetup]
    public void Setup()
    {
        data = new byte[N];
        new Random(42).NextBytes(data);
    }

If your benchmarks have more specific needs, you could make a setup method for one benchmark only, which will be executed before the exact benchmark you specify, so it doesn’t slow down other ones.

    [GlobalSetup(Target = nameof(Sha256))]
    public void Setup()
    {
        data = new byte[N];
        new Random(42).NextBytes(data);
    }

If multiple benchmarks share the same data generation process, you don’t need separate setups for them, you can easily target multiple benchmarks as well.

    [GlobalSetup(Target = new[] { nameof(Sha256), nameof(Md5) })]
    public void Setup()
    {
        data = new byte[N];
        new Random(42).NextBytes(data);
    }

3. Identifying methods to be benchmarked

Even though the code we're currently examining is relatively straightforward, benchmarks can often involve significant amounts of code, depending on the task at hand. With this in mind, you might have multiple setup methods, helper methods, etc, so it’s crucial to mark which methods need to be benchmarked exactly. The way BenchmarkDotnet does this is pretty straightforward, with the [Benchmark] attribute. One thing that the code above doesn’t tell you, this attribute can also have a Baseline parameter. Let’s say you’re refactoring some of the old code and you want to see how the new version compares to it, it’s pretty easy as well.

[Benchmark(Baseline = true)]
public void OldVersionCode() {
    // Your old code...
}

[Benchmark]
public void NewVersionCode() {
    // Your new code...
}

public void SomeHelperMethod() {
    // Your helper method code...
}

Now with all the other data including mean time, etc, you will also get a new column called Ratio that indicates how your other benchmarks compare to your baseline benchmark. You can see more in the BenchmarkDotnet docs for this parameter.

Creating your own benchmarks

Now that we’ve deep dived into BenchmarkDotnet, I think it’s time to run your first benchmark, you could use the same code provided by the docs, or write your own. For the sake of simplicity I’ll cover the one provided.

Installing prerequisites

First thing you would want to do, to avoid writing all the code by yourself is installing BenchmarkDotnet templates which could be done via dotnet CLI.

dotnet new install BenchmarkDotNet.Templates

After it’s done, you could create your first benchmark from the CLI via

dotnet new benchmark

Or if you’re using a language different from C#, you could specify it as well

dotnet new benchmark -lang F#

dotnet new benchmark -lang VB

Running your benchmarks

First thing you see after creating a benchmark project is a default Program and Benchmarks classes. Program is responsible for running benchmarks located at Benchmarks class. You could have as many benchmark classes as you want, but make sure to add all of them to Program if you’d like to run them as well. You could see that program contains pretty simple code

 public class Program
    {
        public static void Main(string[] args)
        {
            var config = DefaultConfig.Instance;
            var summary = BenchmarkRunner.Run<Benchmarks>(config, args);

            // Use this to select benchmarks from the console:
            // var summaries = BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
        }
    }

Now if you have multiple benchmark classes and you only want to run several of them you could choose which ones to run with a slight change to your Main method.

static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);

This way, BenchmarkDotnet will identify all the benchmarks your assembly contains and let you choose which ones to run.

Benchmark results

I’ll be running slightly modified, in terms of targets, version of the same benchmark provided by the docs.

    [SimpleJob(runtimeMoniker: RuntimeMoniker.Net70, baseline: true)]
    [SimpleJob(runtimeMoniker: RuntimeMoniker.Net80)]
    public class Benchmarks
    {
        private SHA256 sha256 = SHA256.Create();
        private MD5 md5 = MD5.Create();
        private byte[] data;

        [Params(1000, 10000)]
        public int N;

        [GlobalSetup]
        public void Setup()
        {
            data = new byte[N];
            new Random(42).NextBytes(data);
        }

        [Benchmark]
        public byte[] Sha256() => sha256.ComputeHash(data);

        [Benchmark]
        public byte[] Md5() => md5.ComputeHash(data);
    }

If you were to run it, after it’s done, you’d see something similar to this

| Method | Job      | Runtime  | N     | Mean      | Error     | StdDev    | Ratio | RatioSD |
|------- |--------- |--------- |------ |----------:|----------:|----------:|------:|--------:|
| Sha256 | .NET 7.0 | .NET 7.0 | 1000  |        NA |        NA |        NA |     ? |       ? |
| Sha256 | .NET 8.0 | .NET 8.0 | 1000  |  1.060 us | 0.0098 us | 0.0091 us |     ? |       ? |
|        |          |          |       |           |           |           |       |         |
| Md5    | .NET 7.0 | .NET 7.0 | 1000  |        NA |        NA |        NA |     ? |       ? |
| Md5    | .NET 8.0 | .NET 8.0 | 1000  |  1.486 us | 0.0084 us | 0.0078 us |     ? |       ? |
|        |          |          |       |           |           |           |       |         |
| Sha256 | .NET 7.0 | .NET 7.0 | 10000 |        NA |        NA |        NA |     ? |       ? |
| Sha256 | .NET 8.0 | .NET 8.0 | 10000 |  6.392 us | 0.0537 us | 0.0476 us |     ? |       ? |
|        |          |          |       |           |           |           |       |         |
| Md5    | .NET 7.0 | .NET 7.0 | 10000 |        NA |        NA |        NA |     ? |       ? |
| Md5    | .NET 8.0 | .NET 8.0 | 10000 | 11.898 us | 0.0236 us | 0.0209 us |     ? |       ? |

This table basically shows us comparison of these two algorithms for each version and for two different parameters in terms of N. BenchmarkDotnet makes sure you understand everything you see on this table, so after every benchmark you’ll be provided with legends grid, explaining what all of these means.

// * Legends *
  N       : Value of the 'N' parameter
  Mean    : Arithmetic mean of all measurements
  Error   : Half of 99.9% confidence interval
  StdDev  : Standard deviation of all measurements
  Ratio   : Mean of the ratio distribution ([Current]/[Baseline])
  RatioSD : Standard deviation of the ratio distribution ([Current]/[Baseline])
  1 us    : 1 Microsecond (0.000001 sec)

Conclusion

While BenchmarkDotnet will not supercharge your code to run faster or make you a 10x engineer, it’s nice to have in your toolbox. I remember making monstrosities out of stopwatches and Console.WriteLine just to compare the runtime speed of several methods, we’ve all been there and I’m pretty sure you can’t reach the same level of accuracy with those.

Thank you for taking the time to read! :)
All of the stories are also available at my personal website - https://anakidze.dev

Zero-Cost Database Magic 🪄💾

Giorgi Anakidze — Fri, 29 Sep 2023 21:28:47 +0000

Whether you’re a hobbyist or a professional developer, at some point you’re going to need a database. 😄 We all know the famous solutions like AWS, Azure, or maybe something that’s more affordable like Linode or DigitalOcean, but what if you only need a database to test some of your ideas? 🤔 Spinning up your own instance with Docker or just installing it locally may not always be an option. 😅 I wish there were some database services that would be performant enough for testing your ideas and also were free… Well, guess what? There are! 😎 And in this article, I’m going to show off 5 of them, so you can choose the best one for your project! 🚀

PlanetScale 🌍

PlanetScale is a serverless platform for MySQL which offers really good options on a free tier. 🤩 I think it’d suit most of the developers who want to use MySQL and to save up some money as well. 💵 Here’s a short brief of what the free tier has to offer:

Storage - 5GB 📦
Reads per month - 1 Billion 📖
Writes per month - 10 Million ✍️
1 Production Branch 🌳
1 Development Branch 🌱

As you see, PlanetScale has a pretty good free tier, but there’s one more service that has even more in theirs, so make sure to read to the end! 😉

Cloudflare D1 🌐

Cloudflare D1 is basically a SQLite database that runs on the edge and is used with Cloudflare Workers. So, if you have your web service deployed to Workers which is also running on the edge, it means that your users will be able to always connect to the closest server and get the least amount of latency for them. ⚡ Here’s a short brief of what the free tier has to offer:

Serverless SQL Database 🗄️
Reads per day - 5 Million 📖
Writes per day - 100K ✍️

If you’re someone who enjoys using Cloudflare Workers, D1 might be the best choice for you, make sure to check it out at - Cloudflare D1. 🎉

Xata 📊

Xata is another serverless relational database that is based on PostgreSQL and ElasticSearch under the hood. 🚀 It treats your tables like a spreadsheet and what’s really cool about it is that it has full-text search built-in. 🔍 No need to duplicate data to an ElasticSearch instance! They have SDKs for many languages and a visual schema editor. Here’s a short brief of what the free tier has to offer:

15 GB Storage for your data 📦
Total records - 750K 📈
Branches per database - 15 🌳
Requests per second - 75 ⚡ Make sure to check it out at - Xata. 😃

Fauna 🐾

Fauna is another serverless database created by ex-Twitter engineers. It's kind of like MongoDB, but with native JOIN operations, many document databases miss. They have their own language, FQL, and also a GraphQL API. Here's a quick overview of their free tier:

100K TROs (Total Read Operations) 📖
50K TWOs (Total Write Operations) ✍️
1GB Storage 📦
5 Databases 🗄️ Sounds good, but the next one is my personal favorite! 🌟

Neon 💡

Neon is a serverless PostgreSQL option written in Rust. 🎉 It has a great free tier, good docs, and supports data branching for various environments. Here's a glance at their free tier:

Storage - 3GiB 📦
Branches - 10 🌳
Active time per month - 100 hours (Primary branch stays active even if you go over!) ⏳
History retention - 7 days 🗓️
Choose the PostgreSQL version and server location 🌍

By far, Neon is my top pick! Check it out for yourself at - Neon. 🚀

Enjoy these databases and happy coding! 😊

Thank you for taking the time to read! :)
All of the stories are also available at my personal website - https://anakidze.dev

Entity Framework: 5 Rookie Traps

Giorgi Anakidze — Tue, 26 Sep 2023 22:04:24 +0000

I’m pretty sure that everyone who works with C#/.NET has heard at least once about Entity Framework (EF). Whether it’s good or bad, it’s used widely and it will benefit you to know how to work with it. But what happens when a beginner developer enters the .NET world and sees the picture where EF is promoted everywhere? All of the job requirements include it and you can find plenty of guides on it. We can’t ignore that EF gives you a lot of benefits, but some caveats may be not so visible for a beginner developer and in this article, I’d like to introduce them to you.

1. Control over the DB while doing Code-First

Scenario:

Imagine having a simple User model for your database.

Like the one below:

public class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
}

// DbContext declaration
// ...
public DbSet<User> Users { get; set; }

And since you’re a beginner you might think it’s completely fine, but this is what you end up having in your database:

As you might see, if you don’t specify any length to your string fields, EF will default it to nvarchar(max) and you might be asking, so what? What’s wrong with that? I have plenty of reasons why you should never use it unless it’s really necessary for business needs:

nvarchar(max) fields can potentially store up to 2GB of data for each row. So when the data is queried, the database might allocate memory based on the potential size of the column, even if only a fraction of it is used, which leads to inefficient memory usage.
You can’t apply any traditional indexes to nvarchar(max) columns. You could still use full-text indexes or indexed views in some cases, but it will still limit your performance optimization options.
With all of that said above, data retrieval could be slow because of nvarchar(max) , especially when they are being used for JOIN operations

So, including all cons of nvarchar(max) what you should consider is refactoring your DB model to be like:

public class User
{
    public int Id { get; set; }
    // if you want FirstName to remain nvarchar type
    // but limit it's length
    [MaxLength(200)]
    public string FirstName { get; set; }
    // or even better
    // if you only allow alphanumeric characters
    // or special characters & whitespace
    [Column(TypeName = "varchar(200)")]
    public string LastName { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
}

Always check your model for having your string fields limited by length or column data type.

2. Lazy Loading vs. Eager Loading

Many beginners might have spotted some performance problems with their EF queries. Entity Framework is not forcing you to use Lazy Loading or Eager Loading, you get to choose what to do. But first, before we talk about what are the pros and cons of each of them, let’s dive into how they work.

Lazy Loading

Lazy Loading is a feature that allows EF to query the data on an as-needed basis.

Scenario:

Imagine having a blog where users should be allowed to have many posts.

So you build some simple models like this:

public class User
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }

    public ICollection<Post> Posts { get; set; }
}

public class Post
{
    public int PostId { get; set; }
    public string Title { get; set; }
    public string Content { get; set; }
}

And later on in your service, you query the user with all the posts

// method declaration
// ...
var users = _dbContext.Users.ToList();
foreach (var user in users)
{
    foreach (var post in user.Posts)
    {
      Console.WriteLine(post.Title);
    }
}

You might be thinking that it’s cool to load data only when you need it, so you’re not overloading your database, but what happens is that if you have 1 user who has 100 posts on your blog, you’re making 101 separate queries, 1 to query the user and 100 others to query all the posts.

Often referred to as N+1 problem.

That’s when Eager Loading comes in to save your database!

Eager Loading

On the other side, Eager Loading is a feature that allows EF to query all the required data in a single query and map it as your model declares. In terms of code, you’ve got the new .Include() method.

var users = _dbContext.Users
                      .Include(u => u.Posts)
                      .ToList();

And that’s it. Now you’ve queried all the users with all of their posts in a single query which is a more efficient approach while working with big data models as blog posts.

3. Ignoring Database Migrations

EF provides a mechanism called “Migrations” to help you manage changes to the database schema. You add a new migration each time you’ve changed a database entity model and EF generates a set of commands it then executes to update the database table according to your model. Beginners often forget to apply their migrations to the database which can lead to having certain errors later on. If you’re someone who loves working from CLI, execute these commands after each change to keep your database in sync with your entities.

dotnet ef migrations add nameOfMigration
dotnet ef database update

Make sure you’ve installed EF Tools before executing these commands.

4. Not keeping track of SQL generated by EF

EF abstracts the SQL generation process, which can be a double-edged sword. While it allows developers to work without worrying about SQL, it can lead to inefficient or unexpected SQL code generated.

Let’s have kinda same example and see how EF generates SQL code and how can we do it ourselves.

Scenario:

Imagine you have a Users table and a Purchases table. You want to fetch all users who have made more than 5 purchases.

Using EF you might write something like this:

var usersWithMoreThanFivePurchases = context.Users
    .Where(u => u.Purchases.Count() > 5)
    .ToList();

Which might later be translated to SQL like this:

SELECT [u].[UserId], [u].[Username]
FROM [Users] AS [u]
WHERE (
    SELECT COUNT(*)
    FROM [Purchases] AS [p]
    WHERE [u].[UserId] = [p].[UserId]
) > 5

This query is truly not the best I’ve seen due to several reasons. So, what are those reasons:

Subquery overhead. For each object in the Users table, a subquery is run to check how many purchases were made. If the Users table has a lot of entries, this could be very inefficient.
No JOIN operations. In this case, the JOIN operation might be more efficient to use, however, the abstraction might not always choose the most optimal path.

How would we write the same query, if it was handwritten?

SELECT [u].[UserId], [u].[Username]
FROM [Users] AS [u]
JOIN [Purchases] AS [p] ON [u].[UserId] = [p].[UserId]
GROUP BY [u].[UserId], [u].[Username]
HAVING COUNT([p].[PurchaseId]) > 5

In this case, we’re using JOIN operation, then using GROUP BY clause to get rid of the possible duplicates and finally checking the count of purchases with HAVING clause.

5. Security concerns with RAW SQL

In case you didn’t know, EF lets you execute raw SQL. There are multiple ways to do so, but the most commonly used ones are Migrations and direct execution from DbContext. Both of the methods accept interpolated strings as parameters and there’s a huge flaw in security.

Migrations

While executing raw SQL from Migrations, you’ll need to add an empty migration file, where you apply your SQL code later.

dotnet ef migrations add createstoredprocedure

// Migration code
// ...
migrationBuilder.Sql($"YourSqlQuery ${parameter}");

In terms of creating stored procedures with raw SQL from EF there’s nothing wrong. The problem appears when you are calling it from EF. You might think, what’s the worst that can happen?

Well, EF is accepting RAW SQL as an interpolated string, which means your parameters are not being converted to SQLParameter class, because it’s the only way EF supports running RAW SQL.

DbContext

So you might say, if EF has a chance of generating bad SQL code, why don’t I use it to run RAW SQL for complex queries? And you could do it, but really carefully. That’s because of the reason I already stated above, EF is not converting your parameters to SQLParameter class, it directly executes all the SQL you give it. The way you do it through DbContext is as follows:

_context.Users.FromSqlInterpolated($"SELECT FirstName FROM dbo.Users WHERE Id = {id}");

As you see, your parameter is directly passed to the SELECT statement. It is not good, to put it mildly. You always got to be careful with such tools, if you screw anything up, you might as well drop your whole DB.

Conclusion

There will never be a way that’s always good or bad, and you can’t say any of those about EF as well. You have to decide what’s best for your application and how are you going to use it. If you have a small and simple application you might use Entity Framework and won’t even need RAW SQL execution. If you’re building something more complex, you might want to look at Dapper, which gives you the ability to execute RAW SQL and Stored Procedures while converting all parameters to SQLParameter class, guarding your DB from SQL Injection attacks. I might write some article on Dapper as well later, but for now, that’s all, thanks for reading!

Thank you for taking the time to read! :)
All of the stories are also available at my personal website - https://anakidze.dev

Awaiting .NET 8: A Look Back at the .NET Journey

Giorgi Anakidze — Thu, 21 Sep 2023 20:46:14 +0000

While the tech world awaits .NET 8, it’s an opportune moment to take a step back and reflect on the transformative journey of C# & .NET. Their evolution was not just a testament to Microsoft’s vision but also the dynamic and ever-changing demands of developers worldwide. This article offers a whirlwind tour of their metamorphosis, highlighting key milestones, and setting the stage for the exciting innovations .NET 8 promises to bring.

How it all began

.NET Framework 1.0

Released in 2002, .NET Framework 1.0 was Microsoft’s answer to a changing software development landscape, aiming to provide a unified environment for developing web services, desktop applications, and other software. The first release included many of the key features that are still being used today, even if they’ve changed as time went by, these were:

CLR: Common Language Runtime
BCL: Base Class Library
ASP.NET: For web-based applications, introducing WebForms which allowed for event-driven web development
ADO.NET: A set of classes for data access, offering disconnected data architecture and XML integration
Windows Forms: For building rich desktop applications and even with the release of WPF or .NET MAUI they’re still being used
Support for multiple languages: One of the main advantages was its ability to support multiple languages, ensuring interoperability

As you can see, even though .NET platform is constantly changing and evolving, the key features were a fundament for what we have today, which is being polished to this day. We’ve talked about the platform and now you might be wondering what did C# 1.0 had to offer back then.

C# 1.0

Introduced alongside .NET Framework, C# 1.0 became one of the primary languages designed for the platform. Anders Hejlsberg, who also worked on Turbo Pascal and Borland Delphi, was a chief architect behind C#. As you may guess, C# 1.0 was not so rich in features as today, but in the same way as .NET Framework 1.0, it already had all the key concepts included that we’re still using to this day and they’re nowhere to go.

Object-Oriented: Full support for classes and the three pillars of Object-Oriented programming (inheritance, polymorphism, and encapsulation)
Syntax, which was heavily influenced by Java and C++, but with a focus on simplicity and productivity, was also related to the next key feature
Garbage collection: Automatic memory management to avoid common programming pitfalls
Type-Safety: C# is designed to be strongly typed to minimize runtime errors and enhance performance
Declarative programming: Attributes in C# allow developers to add metadata to assemblies, classes, etc., which could be then queried at runtime using reflection

What has changed

Although .NET Framework and C# went a long way and there were a ton of features added year to year, the major change happened in November 2020, when .NET 5 was released. You might be asking, what did it change for us, developers? Well, let’s see:

Consolidation of .NET Core and .NET Framework: .NET 5 was a successor to .NET Core 3.1, it brought an end to the separate .NET Core branding. It’s not here to continue what .NET Framework is but to represent the path forward for the .NET platform as a whole.

Unified Platform for Different Workloads: .NET 5 allows developers to target various application types such as web, cloud, mobile, gaming, IoT, and AI using a single .NET platform.

Cross-Platform Support: .NET 5 maintained and improved upon .NET Core’s commitment to cross-platform development, enabling developers to run their applications on Windows, Linux, and MacOS.

All of this sounds pretty cool, although .NET 5 didn’t bring us any GUI development libraries that were cross-platform, and existing ones like WinForms or WPF remained Windows-only technologies.

.NET 6/7

In terms of major changes, there were not so many features offered with .NET 6/7 releases as in previous versions, but they both provided significant performance improvements and also, we finally have a technology for making GUI applications cross-platform, although, still not possible for Linux. What I’m talking about is — .NET MAUI, which is pretty good, but comes with some caveats.

Yes, you have a cross-platform GUI technology, but Linux is still missing out.
Yes, you have the ability for AOT compilation to run basically on bare metal, without .NET Runtime installed at all, but not for cross-platform apps, this is still a Windows-only feature.
And the last one, .NET MAUI is actually pretty good, but you have to write its styling and markup using HTML & CSS, which might be a plus for someone, although old C# developers might be more used to WinForms style or XAML.

What to Expect?

Even though .NET 8 is set to release in November 2023, we already can try it out! Yes, the RC1 is already available and it has a lot to offer, including things like Native AOT for Web applications, Blazor improvements, and Entity Framework updates, make sure to check out all the benchmarks (really big performance improvements) and RC1 notes. From the revolutionary advancements in Web application development to performance leaps, .NET 8 promises a transformative experience for developers. So why wait? Dive into the RC1 today and be among the first to feel the power of the future of .NET!

Thank you for taking the time to read! :)
All of the stories are also available at my personal website - https://anakidze.dev