Forem: Aleksei Zagoskin

AI Coding Agent That Rocks 🚀

Aleksei Zagoskin — Wed, 24 Sep 2025 09:00:19 +0000

(handwritten with ❤️ including emoji's and "—" (SHIFT+OPT+-))

It's been a while since my last post. A lot has happened, and its time to share some good stuff. To be honest, I missed writing 🙂 As always, we'll keep it dry and useful "TL;DR" style (aka shorts). Fasten your seat belt and lets go.

ℹ️ Disclaimer

This post is based on my experiments, personal preferences, and conversations with other heavy AI users.
If you have to use some other AI coding agent (e.g. due to license), it's perfectly fine. You can get A LOT from it (keep reading because many techniques are universal), and there are teams of brilliant minds behind every product which constantly improve their IDE's and tools.
Nothing is ideal.

🤖 AI Coding Agents I Tried

GitHub Copilot;
Cursor;
Windsurf;
Claude Code;
JetBrains Junie;
Claude Desktop + DesktopCommander MCP (this wild combo deserves its own post).

👨🏻‍💻 Tech I Used Them On

C#/.NET, Web API
Node.js;
Golang;
CosmosDB, MongoDB;
Azure, Google Cloud, DigitalOcean;
GitHub Actions pipelines.

🏆 My Favorite

Over the last year (or even more?), I tried them all, watched the videos, read the docs, bought and cancelled subscriptions and, most importantly, shipped production code and solved non-trivial architectural problems with AI.

🔥 Claude Code has been the best — by a wide margin — for me. So if you haven't tried it, yet, don't wait — go ahead and install it right now (no, Anthropic doesn't pay me for this).

⚠️ Important: don't use API-key (pay-as-you-go) billing. Get Anthropic Pro subscription (around $20), and you'll save up a fair bit of money. If you end up doing heavy development, switch to Max.

🚀 Why It Works

Its fast. Like... actually fast.
It lives in Terminal + plug-ins for our favorite IDE's. Dont be afraid, you'll like it even if you're not a Terminal ninja.
Strong project awareness. It understands your repo and context very well.
You can easily "attach" extra directories to an opened project. E.g. when you work on a front-end project and need something from the backend. Another example would be opening multiple microservices (different repos).
It's easy to control reasoning with special words think, think harder, ultrathink (yes, it is ultrathink 🧠).
Its pretty stable (subjectively steadier than some alternatives).
Sub-agents for specific tasks. Claude Code even can run them in parallel when it makes sense.
Custom slash commands. Like your own shortcuts for repeatable operations.
GitHub Integration. It can live on your GitHub (done in ~2 minutes) and reply to comments, make code changes (push commits), and even convert issues into PRs.
Planning mode. Super useful for larger tasks.

Of course, this list is not complete. For more, see https://docs.claude.com/en/docs/claude-code/overview.

🎬 The End

If you haven't tried Claude Code, now's a good time.

And remember, choosing the right tool is just the beginning. Similar to computer languages it's not enough just to pick a programming language and start coding. To get the best results you have to master it (and it takes time). I'll share some advanced techniques and tips in the next post(s).

That's it for now. Thanks for reading and stay tuned ❤️

Get To Know Your Message Broker

Aleksei Zagoskin — Sun, 28 Jul 2024 19:55:56 +0000

First In First Out (FIFO) in Message Brokers

Message brokers are a crucial part of many asynchronous distributed systems. Just like blood vessels transport blood throughout the human body, message brokers transmit streams of countless messages between applications. Today, we're going to take a quick look (as always) at a very useful yet often forgotten feature of our beloved friends — message brokers — the First In First Out mechanic.

The Problem

Imagine we have a producer — a service that emits messages. Every message belongs to a certain group. There are a few consumers — services that process these messages. We want to secure the order of the messages related to the same group while allowing messages for different groups to be processed in a non-deterministic way.

At first glance, there seem to be no issues: the message broker fans out the messages to the consumers in the same order it received them from the producer, so we can expect them to be processed sequentially, right? Unfortunately, no. For instance, if consumer A is much slower than the others, while it processes message 1, consumer B cansage 2, then receive from the broker and process message 3. As a result, the messages will be processed in the following order: 2, 3, 1 instead of 1, 2, 3.

☠️ Approach 1: Keep Only One Consumer

Reduce the number of consumers to one, turn off parallel message processing to ensure instance doesn't process multiple messages at the same time, and enjoy the result (no, you won't enjoy it).

I've seen it done this way a few times. Don't do this, please. Just don't, okay?

✅ Approach 2: Use The Power Of Message Broker

Many messaging systems support the FIFO pattern, making it fairly easy to maintain the order of messages.

Azure Service Bus

In Azure Service Bus, it's called Sessions: a mechanism to ensure that messages with the same value of the session ID header will be processed by consumers in the same order as they were received by the Message Bus from publishers.

(picture from https://learn.microsoft.com/en-us/azure/service-bus-messaging/message-sessions)

Amazon SQS

AWS SQS supports FIFO queues, which ensure the order of messages. These queues maintain the order in which messages are sent and received and also ensure that a message is delivered only once. Similar to Azure Service Bus, FIFO queues from AWS support grouping messages (messages in a group will be processed in order while different groups are processed in parallel).

Apache Kafka

Kafka is designed with partitioning at its core, which inherently supports message ordering within each partition. By designating a key for messages, Kafka ensures that all messages with the same key go to the same partition, thus preserving the order.

Conclusion

Many popular message brokers provide this powerful and often exceptionally useful feature — message ordering. It's good to know about it so that when you need to deal with message ordering or synchronization of parallel events, you have this tool in your toolbox.

Thanks for reading, and see you next time ❤️

Dangerous Using Declaration (C# 8.0)

Aleksei Zagoskin — Mon, 09 Oct 2023 07:00:15 +0000

Today, let's dive into the somewhat unpredictable and potentially risky behavior of the C# 8.0 "Using Declaration" feature. As always, no boring long introduction paragraphs, let's get straight to the point!

What is Using Declaration?

In C# 7.0 we did this:

public void SuperMethod()
{
    using (var myVariable = new SomeDisposable())
    {
        // use myVariable
    } // myVariable will be disposed here
}

Since C# 8.0 we can write this as follows:

public void SuperMethod()
{
    using var myVariable = new SomeDisposable();
    // use myVariable
} // myVariable will be disposed here

The lifetime of myVariable will extend to the end of the scope in which it is declared (in this case SuperMethod containing method).

Looks marvelous! But only until we combine it with object initializers...

The Problem

First, we're going to take a look at this tiny piece of code:

using var response = new HttpResponseMessage
{
    Content = new StringContent("Hello, World!")
};
// some other code

At first glance, it looks perfectly fine: we create an instance of a disposable type and initialize one of its properties. When the program execution reaches the end of the method that contains this code, our response object will be disposed (the same goes for when "some other code" throws an exception). In other words, we could expect this behavior:

var response = new HttpResponseMessage();
try
{
    response.Content = new StringContent("Hello, World!");
    // some other code
}
finally
{
    response.Dispose();
}

While intuition and common sense might lead us to expect this, the reality is quite different.

To understand what happens let's check the "Low-Level C#" and IL for the first code snippet that we started with:

Now we can see what is wrong with this lovely Using Declaration construction: if we use object initializer on our instance, the values will be assigned to the properties before the try-catch block. Thus, if one of these setters throws an exception, we will end up with an allocated instance of a disposable type that is not going to be disposed by the using (in the try-catch block).

Frankly, this implementation and design choice caught me off guard.

Solution

As you might have guessed, the workaround is straightforward: first, instantiate a disposable object using "Using Declaration," and then initialize its properties avoid using object initializers.

Example

using var response = new HttpResponseMessage();
response.Content = new StringContent("Hello, World!");
// some other code

Bonus

If you use an advanced IDE (JetBrains Rider) or an amazing plugin for Visual Studio (Resharper), it will warn you about this code issue:

initialize object properties inside the 'using' statement to ensure that the object is disposed if an exception is thrown during initialization

That's all for now. Thank you for reading, I hope it helps!

Cheers!

Mastering AI: How to Make ChatGPT Write Code Your Way

Aleksei Zagoskin — Wed, 19 Jul 2023 05:05:11 +0000

In recent months, the buzz around AI assistants, particularly our "old new" friend ChatGPT, has been impossible to ignore. If you've ever requested it to generate code for you, chances are you received a fairly decent result. However, it likely required some adjustments to align with your personal (or corporate) style and conventions. In this article, I'll reveal a simple yet effective trick to make ChatGPT generate unit tests precisely the way you want.

While I'll be using .NET in the examples below, this method applies to any programming language. So, ensure you have access to ChatGPT-4 (a statement that will look fun a few years from now when we're all using ChatGPT-10) and let's get started.

As I was writing this article, OpenAI temporarily (?) disabled the "Browse with Bing" feature. This led me to put it on hold until I recently discovered the Link Reader plugin, which performs even better than the slow and glitchy "Browse with Bing" (despite its complaints about fetching failures, it always got the job done).

💡Approach #1

The first step is to create an example for ChatGPT to follow, ensuring the generated code meets our standards. Alongside the example, we need to clearly explain our requirements.

I've created a GitHub Gist containing my preferred unit test template, which I discussed in the"Unit Tests Done Right" article, and provided some instructions for the language model.

🚀 Prompt

I want you to write unit tests for my c# class. Use best coding practices, AAA and the following libraries: xUnit, FluentAssertions, AutoFixture, NSubstitute. I'm going to give you a link to a GitHub gist which contains an example of the code style, structure and conventions that you will have to follow.

This is the example: https://gist.github.com/Powerz/f20500a16eead6bc591ed99d224700f5

And this is the class you need to write unit tests for:

(your code)

👍 Result

Our robot friend generated an impressive output that closely matched the desired code style and required minimal changes. The only aspect that caught my attention was the use of hardcoded input values, while I prefer to generate test data using either AutoFixture or [AutoData]. However, this was the case only with "Browse with Bing". With the "Link Reader", the code was generated exactly as shown in the GitHub Gist.

💡Approach #2

Next, I wondered if I could simply direct ChatGPT to my blog posts where I've detailed my approach to unit tests. Instead of providing instructions and a template link, I could ask it to read the articles and follow the practices described therein.

🚀 Prompt

I want you to write unit tests for my c# class. I'm going to give you a link to my blog posts which contain examples of the code style, structure and conventions that you will have to follow.

Here are the links: https://zagosk.in/unit-tests-done-right, https://zagosk.in/unit-tests-done-right-part-2

And this is the class you need to write unit tests for:

(your code)

🔥 Result

This time the output was perfect in both cases. Although when using "Browse with Bing" the machine complained that it had some problems reading the second article, it managed to read the first one and it just nailed it. The code was perfect and didn't require any changes. With the Link Reader plugin it was much faster and error-less.

This time, the output was flawless in both instances. Although "Browse with Bing" reported some difficulties reading the second article, it successfully read the first one and the resulting code was impeccable, requiring no changes. The Link Reader plugin proved to be much faster and error-free.

Is ChatGPT-3.5 Capable?

With ChatGPT-3.5 it's not that simple and it's not due to the lack of Web Search, but simply because v3.5 is not as progressive as v4. Although I couldn't make this model write tests the way I wanted, if v3.5 is the only model you have access to, give it a go and maybe the result will be acceptable.

With ChatGPT-3.5, things aren't as straightforward, and it's not due to the absence of Web Search: v3.5 just isn't as advanced as v4. While I couldn't get this model to write tests to my specifications, if v3.5 is the only model you have access to, it's worth a shot. Play with it, and you might find the results acceptable.

In Conclusion

Thank you for your time. If you're reading this, there's a good chance you found it useful, which makes me happy Harness the power of cloud brains to automate boring routine tasks, validate your ideas, and devote more time to challenges that only your brain can handle (at least for now).

That's probably enough about ChatGPT for this blog. Next time, I plan to shift gears and discuss something less hyped.

Cheers!

ChatGPT-4 outperformed 90% of developers

Aleksei Zagoskin — Sat, 22 Apr 2023 20:47:00 +0000

The title may sound bold and clickbait-ish, but it is what it is...

A few days ago I stumbled upon a post on LinkedIn (unfortunately, I didn't save the link) in which a programmer demonstrated his solution to a LeetCode challenge. The code was fine and the post got dozens of likes, which it undoubtedly deserved. I decided to feed the requirements to ChatGPT-4 and see if it could understand and solve the problem. The outcome was... interesting and I spent some time experimenting with the AI, modifying the prompt to see how it affected the results.

The Challenge

First, I would like you to take a look at the LeetCode problem and attempt to solve it. Take your time, give it some thought. Then, google it. Yes, search the internet for the best solution.

Given two integer arrays pushed and popped each with distinct values, return true if this could have been the result of a sequence of push and pop operations on an initially empty stack, or false otherwise.

Example 1:
Input: pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
Output: true
Explanation: We might do the following sequence:
push(1), push(2), push(3), push(4),
pop() -> 4,
push(5),
pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
Example 2:
Input: pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
Output: false
Explanation: 1 cannot be popped before 2.
Constraints:

1 <= pushed.length <= 1000

0 <= pushed[i] <= 1000

All the elements of pushed are unique.

popped.length == pushed.length

popped is a permutation of pushed.

Done?

Alright, remember I asked you to brainstorm and google it? So if the machine-generated solution happens to be more efficient, the argument "it's not fair because it was trained on data from the Internet" is not accepted 😉

Release the Kraken

When I initially asked ChatGPT to tackle the challenge, I copy-pasted the task from LeetCode. However, in this case, it might indeed seem like the AI pulled the solution from the depths of its "memory" without much "thinking". So let's rephrase the requirements and see if the machine can handle it. Here's the prompt I used:

The output:

Not bad, and according to LeetCode statistics, this is an average solution, more or less. Now let's push our beloved AI a bit further and ask it to enhance the code:

This is where things become really interesting! Not only did it offer an elegant solution without allocating a stack, but it also explained a potential issue that could arise from this optimization. Let's check it out on LeetCode:

The numbers speak for themselves, right? Of course, some might argue that LeetCode's benchmark is inconsistent, which is a valid point. Nevertheless, the fact remains that the AI instantly produced a decent solution and improved it in a way that not every software engineer can do.

What's Next?

So, are our jobs safe?

Yes 😅 (unless you work for Elon Musk)

To draw an analogy, today's ChatGPT (and other AI assistants like GitHub Copilot) is like an electric tool that can drill holes, drive screws, saw and more. However, if you just place it on the ground, it won't build a house for you. What is more, unskilled individuals might even harm themselves with this tool. On the other hand, experienced engineers can use the power and potential of AI to significantly improve the quality of their work.

That's it for now. Cheers!

Visual Studio 2022 vs Rider vs ChatGPT-4

Aleksei Zagoskin — Sun, 16 Apr 2023 09:23:25 +0000

Today I was going to post a tweet like "Hey fellow developers, use Rider/Resharper instead of good old Visual Studio because the former will find and fix some bugs for you", but then I decided to check what the latest Visual Studio 2022 can do against Rider, and while at it, I remembered our new friend ChatGPT... So instead of a short tweet, I'd like to offer you a small competition between Visual Studio 2022, Rider 2023.1 and the magical ChatGPT-4.

What we're going to do today is review a C# program and try to spot any bugs. Then we'll feed the code to our favorite IDEs (Rider and Visual Studio) to see if they can highlight any code issues. Finally, we're going to ask ChatGPT to review the code and fix all discovered bugs if any.

Shall we?

Requirements

Let's say we want to write a C# program that:

Generates 10 users with randomized ratings.
Finds users whose ratings are between X and Y.
If any users are found, then print:

Code

Instead of writing this program ourselves, we asked someone else to do it for us (someone less smart than modern AI systems), and here is what we got:

var allUsers = GetAllUsers();
var foundUsers = FindUsersByRating(allUsers, 0, 60);

if (foundUsers.Any())
{
    var userWithMinRating = foundUsers.OrderBy(x => x.Rating).FirstOrDefault();
    PrintUsers(foundUsers);
    Console.WriteLine($"{foundUsers.Count()} user(s) found.");
    Console.WriteLine($"Min rating: {userWithMinRating.Rating}.");
    var title = GetTitleByRating(userWithMinRating.Rating);
    Console.WriteLine($"Title: {title.ToUpper()}");
}
else
{
    Console.WriteLine("No users found.");
}

IEnumerable<User> FindUsersByRating(IEnumerable<User> users, int minRating, int maxRating)
{
    return users.Where(x => x.Rating >= minRating && x.Rating <= maxRating);
}

IEnumerable<User> GetAllUsers()
{
    var randomizer = new Random();
    return Enumerable.Range(1, 10)
                     .Select(x => new User(x, randomizer.Next(0, 100)));
}

string GetTitleByRating(int rating)
{
    return rating switch
           {
               > 0 and < 30 => "Beginner",
               >= 30 and < 80 => "Advanced",
               >= 80 => "Expert",
               _ => null
           };
}

void PrintUsers(IEnumerable<User> users)
{
    foreach (var user in users)
    {
        Console.WriteLine(user.ToString());
    }
}

record User(int Id, int Rating);

Now, let's take a moment and think about what issues this unreliable, to say the least, code has.

Finished? Most certainly, you managed to find some, but let's see if our beloved dev tools can simplify it for us and highlight issues that occasionally could escape our tired, red eyes.

Visual Studio 2022 Professional

The latest, at the time of writing, .NET IDE from Microsoft.

(The rest of the code didn't fit on the screenshot, but it doesn't matter).

As we can see, Visual Studio doesn't want to tell us anything (because it doesn't see any issues). Alright, let's move on to the next one Rider.

Rider (v 2023.1)

(Similar results to Visual Studio + Resharper)

Okay, we've got something here!

Possible multiple enumeration

The first thing Rider draws our attention to is the "Possible multiple enumeration" warning, which in this particular case is not just "possible", but an actual issue:

The GetAllUsers method returns a "lazy" IEnumerable<User> instead of actual objects, and, as a result, on lines 4, 6, 7 and 8, where we enumerate this IEnumerable<User>, new User objects will be created. Every time. In other words, when we run our program and the execution point reaches the code on line 1, no actual users will be generated. The same is true for line 2. And only when we reach line 4 (foundUsers.Any()) the actual User instances will be created, filtered and the if statement will check if we have any items left.

So far, so good, but the problem is that on line 6 the FirstOrDefault() method will initiate the process of creating and filtering new items over again. Completely new items. And the same thing happens inside of the PrintUsers method when we iterate over the IEnumerable with the foreach loop, and the last enumeration happens on line 8 when we call the Count() method.

Thus, we can see the following output:

User { Id = 6, Rating = 46 }
User { Id = 8, Rating = 70 }
0 Users found.
Min rating: 51.
Title: EXPERT.

What nonsense! We can see 2 users, but it says that none were found, then it prints a minimum rating that doesn't belong to either of the two users we saw just two lines above. To top it off, we get the EXPERT title... As we discussed, all this happens because new sets of users are being generated on lines 4, 6, 7 and 8.

Possible 'System.NullReferenceException'

Another fair point made by Rider is that userWithMinRating can be null, which can lead to a NullReferenceException being triggered on line 9:

Although it may seem like a simple and easy-to-spot bug, it's one of the most common exceptions that occur in production code.

ChatGPT

Alright, now it's time to test-drive the extremely hyped AI powerhouse that everyone is talking about these days ChatGPT-4🔥

Prompt

When dealing with ChatGPT (and other language models like Bing Chat), prompts are crucial, and hopefully, I didn't do a poor job here. So, I explained to the supermind what our program is expected to do and asked it to fix any bugs it can find in the code:

ChatGPT didn't notice the problems detected by Rider, but it found another one!

Wow! The machine figured out the possible values for the Rating property of the User class and noticed that it would be better to include 0 in the range of values that belong to the Beginner title! To be honest, I didn't expect any of the competitors to notice this issue, and I must admit that it's impressive!

Conclusions

So, what conclusions can we draw from this small competition?

First, if you write C# code for money, then go ahead and purchase a license for either Rider or for Resharper to use it with Visual Studio (if you haven't done already).
Visual Studio is continually improving, but it remains a few steps behind Rider / Resharper. It has always been trailing (since the first version of Resharper) and likely will be in the foreseeable future.
ChatGPT-4 is a beast! I've been playing around with it (not only coding and tech) since it became available, and I'm often (though not always) astonished by the results, which exceed my expectations. It's uncertain how quickly and in what manner these AI monsters will integrate into our daily work (as copilots, smart code analyzers, bug detectors, etc), but one thing is clear this is the future.

Thank you for reading, use the right dev tools and see you soon!

Cheers!

⚠️ Warning: Don't cache lazy IEnumerable in .NET

Aleksei Zagoskin — Fri, 10 Feb 2023 17:54:43 +0000

(The same is true for IAsyncEnumerable<T>)

A few days ago I came across a code where a developer used .NET MemoryCache to cache data retrieved from the database. Sounds boring, but... every time the cache needed to return a result, a call to the database was made.

Let's take a look at a simplified example:

var serviceProvider = new ServiceCollection().AddMemoryCache().BuildServiceProvider();
var randomizer = Random.Shared;
var memoryCache = serviceProvider.GetRequiredService<IMemoryCache>();

// NOTE: we cache the result of GetData()
var data1 = memoryCache.GetOrCreate("key", _ => GetDataFromDb()).ToList();
var data2 = memoryCache.GetOrCreate("key", _ => GetDataFromDb()).ToList();

IEnumerable<int> GetDataFromDb()
{
    // This method will be called twice!
    yield return randomizer.Next();
}

The problem here is that we cache not an array or collection as it may look at first glance, but a lazy IEnumerable, which is calculated not when we call the GetDateFromDb() method, but when we enumerate this lazy thing by calling ToList().

As a result, the method GetDataFromDb() gets called twice (this is what we wanted to avoid with the help of the cache), and also data1 and data will represent different lists with different values.

Solution

Cache the actual result enumerated result instead of lazy IEnumerable<T>:

var serviceProvider = new ServiceCollection().AddMemoryCache().BuildServiceProvider();
var randomizer = Random.Shared;
var memoryCache = serviceProvider.GetRequiredService<IMemoryCache>();

// NOTE: we cache GetData().ToList()
var data1 = memoryCache.GetOrCreate("key", _ => GetDataFromDb().ToList());
var data2 = memoryCache.GetOrCreate("key", _ => GetDataFromDb().ToList());

IEnumerable<int> GetDataFromDb()
{
    yield return randomizer.Next();
}

Now, the behavior will be as expected: the GetDataFromDb() method gets called only once and data1 equals data2.

Thank you for reading and be careful with the cache.

Cheers!

AutoFixture Tips and Tricks

Aleksei Zagoskin — Wed, 01 Feb 2023 20:53:01 +0000

AutoFixture is an amazing library that simplifies the process of creating test data in .NET. If for some reason you don't use this fantastic tool, it's time to consider it. Today, I'm going to share some tips for using AutoFixture that will be beneficial for developers of all skill levels. Let's get started!

Generate random enum members

(Boolean generator has the same behavior)

Default EnumGenerator of AutoFixture returns enum members in sequential order starting from the first element.

Example:

var fixture = new Fixture();

// Generate and print 8 colors
Enumerable.Range(1, 8)
          .Select(_ => fixture.Create<Color>())
          .ToList()
          .ForEach(x => Console.WriteLine(x));

enum Color
{
    None = 0,
    Black = 1,
    Red = 2,
    Blue = 3
}

Output:

None
Black
Red
Blue
None
Black
Red
Blue

If you need a random enum generator, it's here:

using AutoFixture.Kernel;

/// <summary>
/// AutoFixture random generator for enums
/// </summary>
public class RandomEnumGenerator : ISpecimenBuilder
{
    private static readonly Random _randomizer = Random.Shared;

    public object Create(object request, ISpecimenContext context)
    {
        var type = request as Type;

        if (type?.IsEnum != true)
        {
            return new NoSpecimen();
        }

        var values = Enum.GetValues(type);
        var index = _randomizer.Next(values.Length);
        return values.GetValue(index)!;
    }
}

Usage:

var fixture = new Fixture();
fixture.Customizations.Insert(0, new RandomEnumGenerator());

Enumerable.Range(1, 8)
          .Select(_ => fixture.Create<Colour>())
          .ToList()
          .ForEach(x => Console.WriteLine(x));

Output:

Red
Black
None
Blue
Red
Blue
Red
Blue

Generate a few customized objects

From time to time we need to generate a few objects and customize one or more properties like in the example below:

var fixture = new Fixture();
var randomizer = new Random();

// Generate a few users with customized RegisteredAt property.
var users = fixture.Build<User>()
                   .With(x => x.RegisteredAt, GetDateTimeInFuture())
                   .CreateMany()
                   .ToList();

DateTime GetDateTimeInFuture()
{
    return DateTime.Now.AddDays(randomizer.Next(10, 100));
}

public record User(int Id, string Name, DateTime RegisteredAt);

Although we expect all 3 users to have distinct values for the RegisteredAt property, the value will be the same:

Fix for this common mistake:

.With(x => x.RegisteredAt, () => GetDateTimeInFuture())
// or
.With(x => x.RegisteredAt, GetDateTimeInFuture)

Generate decimal and double values

Consider this code:

var fixture = new Fixture();

var value1 = fixture.Create<double>();
var value2 = fixture.Create<decimal>();

AutoFixture will always generate whole numbers, while we may expect something with decimal point (as long as we generate double and decimal).

Solution:

var fixture = new Fixture();
fixture.Register(() => fixture.Create<int>() * 1.33m); // for decimal
fixture.Register(() => fixture.Create<int>() * 1.33); // for double

var value1 = fixture.Create<double>();
var value2 = fixture.Create<decimal>();

Deal with circular dependencies

By default, Fixture is equipped with ThrowingRecursionBehavior, which throws exceptions whenever it needs to generate a graph of objects with a circular dependency:

var employee = fixture.Create<Employee>();

public record Employee(int Id, string Name, Department Department);
public record Department(int Id, string Name, IEnumerable<Employee> Employees);

Output:

Unhandled exception. AutoFixture.ObjectCreationExceptionWithPath: AutoFixture was unable to create an instance of type AutoFixture.Kernel.FiniteSequenceRequest because the traversed object graph contains a circular reference.

Solution:

As the description of the exception suggests replace ThrowingRecursionBehavior with OmitOnRecursionBehavior:

var fixture = new Fixture();

// Replace ThrowingRecursionBehavior with OmitOnRecursionBehavior
fixture.Behaviors
       .OfType<ThrowingRecursionBehavior>()
       .ToList()
       .ForEach(b => fixture.Behaviors.Remove(b));
fixture.Behaviors.Add(new OmitOnRecursionBehavior());

var employee = fixture.Create<Employee>();

public record Employee(int Id, string Name, Department Department);
public record Department(int Id, string Name, IEnumerable<Employee> Employees);

This is it for today and thank you for reading. Don't forget to give a to AutoFixture repository on GitHub, it deserved it.

Cheers!

Lazy thread-safe delegate for ConcurrentDictionary in C#

Aleksei Zagoskin — Thu, 26 Jan 2023 21:03:32 +0000

The ConcurrentDictionary<TKey, TValue> type is commonly used as a thread-safe alternative to the Dictionary<TKey, TValue> type. While the methods of this type are atomic, it's important to keep in mind that when the AddOrUpdate and GetOrAdd methods are called from multiple threads, the delegate (valueFactory parameter) may be executed more than once.

This is what official documentation says about it:

Let's take a look at this example:

using System.Collections.Concurrent;

var usersById = new ConcurrentDictionary<int, User>();

// Get or create a user with ID = 1 two times from different threads
var getUserTask1 = Task.Run(() => usersById.GetOrAdd(1, User.GenerateUserWithId));
var getUserTask2 = Task.Run(() => usersById.GetOrAdd(1, User.GenerateUserWithId));

await Task.WhenAll(getUserTask1, getUserTask2);

Console.WriteLine($"User 1: {getUserTask1.Result}");
Console.WriteLine($"User 2: {getUserTask2.Result}");

public record User(int Id, int Age)
{
    private static readonly Random _randomizer = Random.Shared;

    public static User GenerateUserWithId(int id)
    {
        Thread.Sleep(TimeSpan.FromSeconds(1));

        // Generate and return a new user with a given ID and random age.
        var user = new User(id, _randomizer.Next(1, 100));
        Console.WriteLine($"Created a new user: {user}");
        return user;
    }
}

Output:

Created a new user: User { Id = 1, Age = 91 }
Created a new user: User { Id = 1, Age = 30 }
Instance 1: User { Id = 1, Age = 91 }
Instance 2: User { Id = 1, Age = 91 }

As we can see, two User objects were created, but only one of them was added to the ConcurrentDictionary. While it may be acceptable for the delegate to be called multiple times in some cases, there may be situations where it is necessary to ensure that the delegate is only called once.

Solution

using System.Collections.Concurrent;

//! Replace User with Lazy<User>
var usersById = new ConcurrentDictionary<int, Lazy<User>>();

var getUserTask1 = Task.Run(() => usersById.GetOrAdd(1, x => new Lazy<User>(() => User.GetUserById(x))).Value);
var getUserTask2 = Task.Run(() => usersById.GetOrAdd(1, x => new Lazy<User>(() => User.GetUserById(x))).Value);

await Task.WhenAll(getUserTask1, getUserTask2);

Console.WriteLine($"Instance 1: {getUserTask1.Result}");
Console.WriteLine($"Instance 2: {getUserTask2.Result}");

Output:

Created a new user: User { Id = 1, Age = 99 }
Instance 1: User { Id = 1, Age = 99 }
Instance 2: User { Id = 1, Age = 99 }

We changed two things: (1) the type of the value of our dictionary (User became Lazy<User>) and (2) made the factory method lazy. So now instead of running the valueFactory delegate twice (and generating two users with the same ID), two Lazy instances are being created, and just like in the first example, only one of them becomes a member of the ConcurrentDictionary. This Lazy object will be returned by both calls to the GetOrAdd method made from two parallel threads, which, in turn, ensures that the delegate that generates our users will be called only once.

Thank you for reading

Non-nullable properties in C# 11

Aleksei Zagoskin — Sat, 14 Jan 2023 18:26:18 +0000

After taking a break from blogging, I am excited to be back and try something new. As an experiment, I have decided to focus on writing shorter articles, which hopefully, will allow me to share some of my thoughts, ideas and tips in a more concise and digestible manner. Let's see how it goes. Shall we?

Problem

First, take a look at this simple code:

public record User
{
    public string Name { get; init; }
    public string? Email { get; init; }
}

Nothing fancy here, an immutable record with two properties: Name and Email. At first glance, it may look fine, but the compiler won't like this code:

Program.cs(14, 19): [CS8618] Non-nullable property 'Name' must contain a non-null value when exiting constructor. Consider declaring the property as nullable.

This means that we created an immutable record with a non-nullable property Name, but nothing will stop us from creating a new user and not providing any name at all:

var user = new User { Email = "Sam" };

Solution 1: Assign `default!`

(Don't do that) Often, to shut the compiler up, programmers assign default values with an exclamation mark to such properties:

public record User
{
    public string Name { get; init; } = default!; // or null! or "" 
    public string? Email { get; init; }
}

Here we simply ask the compiler to ignore the issue, while the problem remains: we are still able to create an instance of that record and forget to assign a value to Name.

💩 Solution 1: Constructor

public record User
{
    public string Name { get; }
    public string? Email { get; init; }

    public User(string name, string? email = default)
    {
        Name = name;
        Email = email;
    }
}

Very boring and verbose code, which at the end of the day does the job. There is no way a developer can forget to pass a value for Namebecause now it's a mandatory constructor parameter.

Solution 2: Positional properties

public record User(string Name, string? Email = default);

In this case whenever we create a new instance of the User type, we have to provide a value for the Name property. Nice and clean.

Solution 3: `required` modifier

The new keyword required was introduced in C# 11, which can be applied to properties of classes, records and structs. You can find all details as well as information about existing limitations here.

public record User
{
    public required string Name { get; init; }
    public string? Email { get; init; }
}

Problem solved.

I hope it helps and thank you for reading!

Cheers!

My Top N Favorite Plugins and Tools for Developers

Aleksei Zagoskin — Mon, 23 May 2022 12:54:00 +0000

Software engineers are like children we love to play with toys. Fancy IDE themes, Quake-style terminals, dozens of plugins for everything its a lot of fun to play with all these lovely things, and it feels especially good when these tools do something useful. Today Im going to share a list of my favorite software that I use and recommend.

No long descriptions, just a list of the best tools for developers. Get ready do download things 🍿

1. JetBrains IDEs

JetBrains is building the best IDEs on this planet. Period. Long time ago Resharper changed the world of .NET development once and for all. It was slow and greedy for memory, but it was a game changer. These days I mostly use Rider, DataGrip and sometimes GoLand. Try and buy JetBrains products if you haven't done already (*they don't pay me, on the contrary, I pay them for my license).

2. Warp terminal (macOS)

I used to use Hyper with a bunch of plugins, but recently switched to Warp terminal. It's fast, offers lots of features out of the box, looks awesome and its AI Command Search is fantastic (at first I underestimated it thinking it was just a marketing ploy, but my assumption turned out to be wrong, it's really cool).

3. Fig autocomplete (macOS)

If you don't use Warp, then take a look at Fig an awesome autocomplete for your favorite terminal. It's much better than terminal autocomplete plugins I've seen so far.

4. Lens (UI for Kubernetes)

Lens Desktop is the only application you need to take control of your Kubernetes clusters. It's built on open source and free.

5. Plugins time🎉

My favorite plugins for JetBrains IDEs and Resharper (some of them are also available for Visual Studio / Visual Studio Code):

5.1 Heap Allocations Viewer

Highlights local object allocations, boxing, delegates and closure creations points.

A very useful and handy plugin to help you see, understand and, possibly, minimize heap allocations in your code.

5.2 NSubstitute Complete

If you use NSubstitute (the best mocking .NET framework), then you have to install this small yet useful plugin right now. It kindly generates mocks and Arg.Is / Arg.Any.

5.3 NUKE Support

This plugin makes Rider / Resharper more NUKE friendly by adding icons, live templates and runner features to your IDE.

5.4 CognitiveComplexity

This plugin will help you not to get carried away too much.

Implements live calculation of the Cognitive Complexity metric, which was proposed by G. Ann Campbell in Cognitive Complexity - A new way of measuring understandability (c) SonarSource S.A. 2016-2018, Switzerland.

5.5 .ignore

If you're a Git user, just install this one and keep reading.

5.6 Material Theme UI

The most popular set of themes for your favorite IDE.

5.7 Better Comments

Check out these comments. Aren't they beautiful?

5.8 Key Promoter X

Very annoying plugin that will teach you some useful hotkeys unless you remove it first.

5.9 GraphQL

If you work with GraphQL, then you'll like this one. Autocomplete, code highlight and query runner for GraphQL.

5.10 Rainbow Brackets

For those who loves brackets...

5.11 Structured Logging

For everyone who does logging (sounds like for everyone).

5.12 Nyan Progress Bar

And to top it off... the most useful plugin ever cute progress bar 🙄

Alright, we've had a quick look at almost all plugins I use (except a few themes in addition to Material Theme UI), and it's time to wrap it up. I hope you found something useful (or at least entertaining). And feel free to share your favorite software in the comments section below 😉

Cheers!

Unit Tests Done Right (Part 2)

Aleksei Zagoskin — Mon, 09 May 2022 11:56:01 +0000

In the previous article, Unit Tests Done Right (Part 1), we explored some of the best practices for unit testing and then compiled a list of must-have libraries that greatly improve the quality of tests. However, it didn't cover some common scenarios like testing LINQ and mappings, so I decided to fill this gap with one more example-driven post.

Ready to further improve your unit testing skills? Lets' get started🍿

The examples in this article make extensive use of the awesome tools described in the previous post, so it would be a good idea to start with Part 1 so that the code we're about to analyze makes more sense.

Testing LINQ

It's a matter of fact that all C# developers love LINQ, but we should also treat it with respect and cover queries with tests. By the way, this is one of the many advantages of LINQ over SQL (have you ever seen a real person who wrote at least one unit test for SQL? Neither have I).

Let's take a look at an example.

public class UserRepository : IUserRepository
{
    private readonly IDb _db;

    public UserRepository(IDb db)
    {
        _db = db;
    }

    public Task<User?> GetUser(int id, CancellationToken ct = default)
    {
        return _db.Users
                  .Where(x => x.Id == id)
                  .Where(x => !x.IsDeleted)
                  .FirstOrDefaultAsync(ct);
    }

    // other methods
}

In this example, we have a typical repository with a method that returns users by ID, and _db.Users returns IQueryable<User>. So what do we need to test here?

We want to make sure that this method returns a user by ID if it hasn't been deleted.
The method returns null if the user with the given ID exists, but is marked as deleted.
The method returns null if the user with the given ID doesn't exist.

In other words, all Where, OrderBy and other method calls must be covered by tests. Now let's write and discuss the first test (💡reminder: the test structure was explained in the previous article):

public class UserRepositoryTests
{
    public class GetUser : UserRepositoryTestsBase
    {
        [Fact]
        public async Task Should_return_user_by_id_unless_deleted()
        {
            // arrange
            var expectedResult = F.Build<User>()
                                  .With(x => x.IsDeleted, false)
                                  .Create();
            var allUsers = F.CreateMany<User>().ToList();
            allUsers.Add(expectedResult);

            Db.Users.Returns(allUsers.Shuffle().AsQueryable());

            // act
            var result = await Repository.GetUser(expectedResult.Id);

            // assert
            result.Should().Be(expectedResult);
        }

        [Fact]
        public async Task Should_return_null_when_user_is_deleted()
        {
            // see below
        }

        [Fact]
        public async Task Should_return_null_when_user_doesnt_exist()
        {
            // see below
        }
    }

    public abstract class UserRepositoryTestsBase
    {
        protected readonly Fixture F = new();
        protected readonly UserRepository Repository;
        protected readonly IDb Db;

        protected UserRepositoryTestsBase()
        {
            Db = Substitute.For<IDb>();
            Repository = new UserRepository(Db);
        }
    }
}

First of all, we created a user that meets the requirements (not deleted) and added it to a bunch of other users (with random different IDs and IsDeleted values). Then we mocked the data source to return the shuffled dataset. Note, that we shuffled the list of users to place the expectedResult in a random position. Finally, we called Repository.GetUser and verified the result.

Shuffle() is a small yet useful extension method:

public static class EnumerableExtensions
{
    private static readonly Random _randomizer = new();

    public static T GetRandomElement<T>(this ICollection<T> collection)
    {
        return collection.ElementAt(_randomizer.Next(collection.Count));
    }

    public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> objects)
    {
        return objects.OrderBy(_ => Guid.NewGuid());
    }
}

The second test is almost identical to the first one.

[Fact]
public async Task Should_return_null_when_user_is_deleted()
{
    // arrange
    var testUser = F.Build<User>()
                          .With(x => x.IsDeleted, true)
                          .Create();
    var allUsers = F.CreateMany<User>().ToList();
    allUsers.Add(testUser);

    Db.Users.Returns(allUsers.Shuffle().AsQueryable());

    // act
    var result = await Repository.GetUser(testUser.Id);

    // assert
    result.Should().BeNull();
}

Here we mark our user as deleted and check that the result is null.

For the last test, we generate a list of random users and a unique ID that doesn't belong to any of them:

[Fact]
public async Task Should_return_null_when_user_doesnt_exist()
{
    // arrange
    var allUsers = F.CreateMany<User>().ToList();
    var userId = F.CreateIntNotIn(allUsers.Select(x => x.Id).ToList());

    Db.Users.Returns(allUsers.Shuffle().AsQueryable());

    // act
    var result = await Repository.GetUser(userId);

    // assert
    result.Should().BeNull();
}

CreateIntNotIn() is another useful method often used in tests:

public static int CreateIntNotIn(this Fixture f, ICollection<int> except)
{
    var maxValue = except.Count * 2;
    return Enumerable.Range(1, maxValue)
                     .Except(except)
                     .ToList()
                     .GetRandomElement();
}

Let's run our tests:

Looks green enough, so let's move on to the next example.

Testing Mappings (AutoMapper)

Do we need tests for mappings at first place?

Despite many devs claim that it is boring or a waste of time, I believe unit testing of mappings plays a key role in the development process for the following reasons:

It's easy to overlook small, yet important differences in data types. For example, when a property of class A is of type DateTimeOffset and the corresponding property of class B is of type DateTime. The default mapping will not crash, but will produce an incorrect result.
New or removed properties. With mapping tests, whenever we refactor one of the classes, it's impossible to forget to change the other (because the well-written tests won't pass).
Typos and different spelling. We're all humans and often don't notice typos, which, in turn, can lead to incorrect mapping results. Example:

public class ErrorInfo
{
    public string StackTrace { get; set; }
    public string SerializedException { get; set; }
}

public class ErrorOccurredEvent
{
    public string StackTrace { get; set; }
    public string SerialisedException { get; set; }
}

public class ErrorMappings : Profile
{
    public ErrorMappings()
    {
        CreateMap<ErrorInfo, ErrorOccurredEvent>();
    }
}

It's pretty easy to overlook the issue of different spelling in the code above, and Rider / Resharper won't help with that either, because both Seriali z ed and Seriali s ed look fine to it. In this case, the mapper will always set the target property to null, which is definitely not desirable.

I hope I managed to convince you and proved the value of unit tests for mappings, so let's move on to the next example. We're going to use AutoMapper, but from a testing standpoint, the choice of mapper makes no difference. For instance, we can replace AutoMapper with Mapster and it won't affect our tests in any way. Moreover, the existing tests will indicate whether our mapping refactoring was successful or not, which is one of the points of having unit tests 🙂

Say we have these entities:

public class User
{
    public int Id { get; init; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public string Email { get; set; }
    public string Password { get; set; }
    public bool IsAdmin { get; set; }
    public bool IsDeleted { get; set; }
}

public class UserHttpResponse
{
    public int Id { get; init; }
    public string Name { get; set; }
    public string Email { get; set; }
    public bool IsAdmin { get; set; }
}

public class BlogPost
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
    public string Text { get; set; }
}

public class BlogPostDeletedEvent
{
    public int Id { get; set; }
    public int UserId { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
    public string Text { get; set; } 
}

public class Comment
{
    public int Id { get; set; }
    public int BlogId { get; set; }
    public int UserId { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
    public string Text { get; set; }
}

public class CommentDeletedEvent
{
    public int Id { get; set; }
    public int BlogId { get; set; }
    public int UserId { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
    public string Text { get; set; }
}

And mappings:

public class MappingsSetup : Profile
{
    public MappingsSetup()
    {
        CreateMap<User, UserHttpResponse>()
            .ForMember(x => x.Name, _ => _.MapFrom(x => $"{x.FirstName} {x.LastName}"));

        CreateMap<BlogPost, BlogPostDeletedEvent>();
        CreateMap<Comment, CommentDeletedEvent>();
    }
}

Nothing especially fancy: the mapping for User >> UserHttpResponse is slightly customized while the other two are default "map as is" instructions. Let's write tests for our mapping profile.

To begin with, here is the base class that you can use for all unit tests for mappings:

public abstract class MappingsTestsBase<T> where T : Profile, new()
{
    protected readonly Fixture F;
    protected readonly IMapper M;

    public MappingsTestsBase()
    {
        F = new Fixture();
        M = new MapperConfiguration(x => { x.AddProfile<T>(); }).CreateMapper();
    }
}

And our first test for User >> UserHttpResponse mapping:

public class MappingsTests
{
    public class User_TO_UserHttpResponse : MappingsTestsBase<MappingsSetup>
    {
        [Theory, AutoData]
        public void Should_map(User source)
        {
            // act
            var result = M.Map<UserHttpResponse>(source);

            // assert
            result.Name.Should().Be($"{source.FirstName} {source.LastName}");
            result.Should().BeEquivalentTo(source, _ => _.Excluding(x => x.FirstName)
                                                         .Excluding(x => x.LastName)
                                                         .Excluding(x => x.Password)
                                                         .Excluding(x => x.IsDeleted));
            source.Should().BeEquivalentTo(result, _ => _.Excluding(x => x.Name));
        }
    }
}

In this test we:

Generate a random instance of the User class.
Map it to the UserHttpResponse type.
Verify the Name property.
Verify the remaining properties by comparing resultsource and sourceresult (in order not to miss anything). Note that we exclude every property that is not present in any of the classes, instead of using ExcludingMissingMembers() which excludes properties with typos and distinct spelling (the test won't be able to detect the SerializedException vs SerialisedException issue).

Default mapping tests for classes with the same properties (e.g. BlogPost >> BlogPostDeletedEvent) can be written in a more generic and elegant way:

public class SimpleMappings : MappingsTestsBase<MappingsSetup>
    {
        [Theory]
        [ClassData(typeof(MappingTestData))]
        public void Should_map(Type sourceType, Type destinationType)
        {
            // arrange
            var source = F.Create(sourceType, new SpecimenContext(F));

            // act
            var result = M.Map(source, sourceType, destinationType);

            // assert
            result.Should().BeEquivalentTo(source);
        }

        private class MappingTestData : IEnumerable<object[]>
        {
            public IEnumerator<object[]> GetEnumerator()
            {
                return new List<object[]>
                       {
                           new object[] { typeof(BlogPost), typeof(BlogPostDeletedEvent) },
                           new object[] { typeof(Comment), typeof(CommentDeletedEvent) }
                       }
                    .GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
        }
    }

You may have noticed that lovely [ClassData(typeof(MappingTestData))] attribute. This is a clean way to separate the test data generated by the MappingTestData class from the test implementation. As you can see, adding a new test for a new default mapping is a matter of one line of code:

return new List<object[]>
                       {
                           new object[] { typeof(BlogPost), typeof(BlogPostDeletedEvent) },
                           new object[] { typeof(Comment), typeof(CommentDeletedEvent) }
                       }
                    .GetEnumerator();

Pretty cool, isn't it?

Final Words

Looks like you've read this far🎉 I hope it wasn't too boring🙂

Anyway, today we've dealt with unit tests for LINQ and mappings, which, in combination with techniques described in the previous post Unit Tests Done Right (Part 1), provide a solid background and understanding of the key principles for writing clean, meaningful, and most importantly, useful unit tests.

Cheers!

Forem: Aleksei Zagoskin

AI Coding Agent That Rocks 🚀

ℹ️ Disclaimer

🤖 AI Coding Agents I Tried

👨🏻‍💻 Tech I Used Them On

🏆 My Favorite

🚀 Why It Works

🎬 The End

Get To Know Your Message Broker

First In First Out (FIFO) in Message Brokers

The Problem

☠️ Approach 1: Keep Only One Consumer

✅ Approach 2: Use The Power Of Message Broker

Azure Service Bus

Amazon SQS

Apache Kafka

Conclusion

Dangerous Using Declaration (C# 8.0)

What is Using Declaration?

The Problem

Solution

Example

Bonus

Mastering AI: How to Make ChatGPT Write Code Your Way

💡Approach #1

🚀 Prompt

👍 Result

💡Approach #2

🚀 Prompt

🔥 Result

Is ChatGPT-3.5 Capable?

In Conclusion

ChatGPT-4 outperformed 90% of developers

The Challenge

Release the Kraken

What's Next?

Visual Studio 2022 vs Rider vs ChatGPT-4

Requirements

Code

Visual Studio 2022 Professional

Rider (v 2023.1)

Possible multiple enumeration

Possible 'System.NullReferenceException'

ChatGPT

Prompt

Conclusions

⚠️ Warning: Don't cache lazy IEnumerable in .NET

Solution

AutoFixture Tips and Tricks

Generate random enum members

Generate a few customized objects

Generate decimal and double values

Deal with circular dependencies

Lazy thread-safe delegate for ConcurrentDictionary in C#

Solution

Non-nullable properties in C# 11

Problem

Solution 1: Assign default!

💩 Solution 1: Constructor

Solution 2: Positional properties

Solution 3: required modifier

My Top N Favorite Plugins and Tools for Developers

1. JetBrains IDEs

2. Warp terminal (macOS)

3. Fig autocomplete (macOS)

4. Lens (UI for Kubernetes)

5. Plugins time🎉

5.1 Heap Allocations Viewer

5.2 NSubstitute Complete

5.3 NUKE Support

5.4 CognitiveComplexity

5.5 .ignore

5.6 Material Theme UI

5.7 Better Comments

5.8 Key Promoter X

5.9 GraphQL

5.10 Rainbow Brackets

5.11 Structured Logging

5.12 Nyan Progress Bar

Unit Tests Done Right (Part 2)

Solution 1: Assign `default!`

Solution 3: `required` modifier