Forem: Grontis Kostis

Building Pebbles: A Journey in AI Tooling

Grontis Kostis — Sat, 14 Mar 2026 22:15:19 +0000

I built Pebbles, a .NET CLI AI assistant, and learned a lot along the way. Here's what happened.

Making It Work

The first big challenge was multi-provider support. I started with Alibaba Cloud's DashScope, but wanted to try other models. Each provider has its own API format, authentication, and quirks. OpenAI uses Bearer tokens, Anthropic uses different headers, and they all have different features. I built a unified interface to hide the mess and created an interactive setup flow so new users don't have to edit config files. I also added 173 tests because supporting multiple providers means testing all of them.

Then I gave Pebbles actual capabilities. It could chat, but it couldn't do anything. I added three tools: run shell commands, write files, and browse directories. This required serious safety work: blocking dangerous commands like rm -rf /, validating file paths, and creating automatic backups before every change. I used Polly for retry logic because networks fail and files get locked. Watching Pebbles autonomously read a file, decide where to add code, and write it back was a wild moment.

Making It Clean

The code got messy fast. My CommandHandler class had 13 dependencies. That's a sign something's wrong. I refactored using the Command pattern, splitting everything into focused handlers: ChatCommands, FileCommands, MemoryCommands, etc. Each has 0-3 dependencies instead of 13. I embraced C# 12's primary constructors and made stateless commands static. The Options pattern replaced passing IConfiguration everywhere. The result: code that's easier to test, understand, and extend.

I also made the UI better by removing things. My fancy ASCII banner was eating half the screen. I killed it. Multi-line status panels became single compact lines. UI chrome dropped from 14 lines to 6. The lesson: good UI gets out of the way. Nobody cares about your banner.

Making It Remember

The final pieces were tools, compression, and memory. I formalized the tool system so the AI knows what it can do. For long conversations, I built compression: when you hit 70% of the context window, older messages get summarized into XML while keeping recent ones verbatim. The AI still knows what we discussed, just in compressed form.

The game-changer was memory extraction. Every 10 messages, Pebbles asks the AI what it learned about my preferences. It extracts things like "prefers primary constructors" or "uses xUnit for testing" and saves them to a file. Next session, that memory loads into the system prompt. Pebbles remembers who I am and how I work.

What I Learned

Building is how I understand. Pebbles started as a "hello world" and taught me a lot about how AI agents work: tool systems, context management, memory extraction, and the delicate balance between autonomy and safety. The key lessons: hide complexity behind clean interfaces, safety is not optional when giving AI file access, good architecture pays off, context management makes or breaks AI interactions, and sometimes the best code is the code you delete.

I probably won't keep working on Pebbles. Instead, I'll focus on contributing to pi-mono and qwen-code, the projects that inspired this whole adventure. Both are doing interesting work in the AI assistant space, and I'd rather help push those forward than maintain my own thing.

From Chatting to Reading: Teaching Pebbles to See My Code

Grontis Kostis — Mon, 09 Mar 2026 11:32:57 +0000

I connected Pebbles to a real AI. It felt nice.

Choosing the Alibaba Coding Plan

I went with Coding Plan. The API docs could use some work, but I managed to get it working. I wanted to support multiple models from day one. Why limit myself?

Setting up the API key was the first hurdle. Environment variables, config files, trying not to commit secrets to git. The usual dance. But once that was sorted, I was ready.

I have eight models to choose from: qwen3.5-plus, qwen3-coder-plus, qwen3-coder-next, qwen3-max-2026-01-23, glm-4.7, glm-5, MiniMax-M2.5, and kimi-k2.5.

The Moment of Truth

I typed my first real message:

❯ You: Write a hello world in C#

And then nothing. For like 3 seconds. Probably because the models are hosted in Singapore and I am in Europe.

But then:

⬡ Pebbles:
Here's a simple "Hello, World!" program in C#:

┌─ csharp ──────────────────────────────────
│ using System;
│
│ class Program
│ {
│     static void Main()
│     {
│         Console.WriteLine("Hello, World!");
│     }
│ }
└──────────────────────────────────────────

It worked. It actually worked.

Streaming is Magic

I implemented streaming responses. The text appears character by character instead of all at once. It's a small thing, but it makes the experience feel alive. Like there's something on the other end thinking and typing.

Watching the code block slowly appear on my screen, that was the moment I understood why people get excited about AI. It's not just the output. It's the process of getting there.

The Cost Reality Check

I added token tracking because GLM-5 told me to implement it. After a few conversations:

⎯ 156 input → 423 output • $0.0012 • 579 total tokens

I don't know if those numbers are accurate. I'll revisit this in the future since it's not very important to me at the moment.

Configuration Adventures

I spent quite a while trying to understand how others are doing it and what feels right to me. At the moment I've set up the API key as an env var and added the models in the app settings.

{
  "Pebbles": {
    "DefaultModel": "qwen3.5-plus",
    "AvailableModels": [
      "qwen3.5-plus",
      "qwen3-coder-plus",
      "qwen3-coder-next",
      "qwen3-max-2026-01-23",
      "glm-4.7",
      "glm-5",
      "MiniMax-M2.5",
      "kimi-k2.5"
    ]
  }
}

Eight models!

But Wait, It Was Flying Blind

So I had this AI assistant in my terminal. It could chat, it could answer questions, but it couldn't actually see my code. I'd ask it about my code, and it would give me generic answers because it had no context.

That had to change.

The @ Symbol Idea

I wanted a simple way to reference files. Everyone is using the @ symbol so why reinvent the wheel. It's easy to type, it feels like "at" or "address", and it's not used much in regular chat.

So now I could type:

❯ You: What does the Process method do in @Services/ChatService.cs?

And Pebbles would load that file and include it in the context.

Building the File Picker

But typing paths is annoying. So I built an interactive file picker. When you type @, you get:

❯ You: Check this file: @
                        Configuration/
                        Models/
                        Services/
                        UI/
                        Program.cs
                        Pebbles.csproj
                        README.md

You can navigate with arrow keys, press Tab to select, and even drill into directories. It's like having a tiny file explorer inside your chat.

The Technical Bits

Building this required:

A FileService to handle loading and parsing
Autocomplete logic that triggers on @
Path resolution (relative, absolute, nested directories)
Binary file detection (because you don't want to accidentally feed a PNG to the AI)
Size limits (1MB per file - learned that lesson the hard way)
Filtering out hidden files and directories
Sorted results (directories first, then files, both alphabetically)
A scrollable popup with up to 10 items
Navigation with arrow keys, Enter or Tab to select, Escape to dismiss
Tracking the current directory path for incremental navigation
Filtering by typing partial names after @
Lazy loading file content when the message is submitted
Caching of loaded files in the FileService

Of course, the file picker is still super buggy, but we have something
¯\_(ツ)_/¯!!! Need to stay motivated and fix it in the future!

The First Real Code Review

Once it was working, I tried my first real code review:

❯ You: Review this code for potential issues:
      @Program.cs
      @Services/ChatService.cs

✓ Program.cs (2.5 KB)
✓ Services/ChatService.cs (4.1 KB)
Loaded 2 file(s) into context

⬡ Pebbles: I've reviewed the files. Here are my suggestions...

And it found a potential null reference issue I'd missed. It's just pattern matching, but it found something useful.

Context Management

I also added a /context command to see what's loaded, and /clearfiles to start fresh. Managing context is important because:

Token limits are real
Too much context confuses the AI
You want to be intentional about what you're sharing

The Project Context File

It wasn't really my idea. All the cool kids are doing it. So I created a global .pebbles folder that needs to exist either at project level or globally in the user folder. Inside it, I added support for .pebbles/agent/AGENTS.md:

# Project Guidelines

## Code Style
- Follow existing project conventions
- Use meaningful variable names
- Keep functions under 50 lines
- Add comments for complex logic only

this one is taken from pi-mono I believe

Now every conversation starts with this context. It's like giving Pebbles a briefing before we start working.

What Surprised Me

The speed. I expected it to feel sluggish compared to the mock provider, but with streaming, it actually feels faster. Your brain processes the text as it arrives, so by the time the response is done, you've already read most of it.

Also, the variety in responses between models is fascinating. Same prompt, completely different approaches. Some are concise, some are verbose, some are more "creative" than others.

What I Learned

Context is everything. The same AI model gives wildly different answers depending on what you feed it. A vague question gets a vague answer. A specific question with relevant code gets a specific, useful answer.

Also, file handling is never as simple as it seems. Path separators, encoding issues, permission errors etc. There's always something.

The Joy of It

There's something deeply satisfying about typing @ and watching that file picker appear. It's like my terminal just got a little bit smarter. A little bit more alive.

And when the AI references something from my code in its answer? Chef's kiss. It actually understands (or appears to understand) what I'm working on.

The Bigger Picture

I think a lot of developers feel overwhelmed by AI right now. It's moving so fast, and it's easy to feel like you're falling behind. Building Pebbles is my way of catching up. Not by reading articles or watching videos, but by getting my hands dirty.

Every line of code teaches me something. Every bug I fix is a lesson. Every feature I add is a step toward understanding this new world.

Hello World, Meet Pebbles

Grontis Kostis — Sat, 07 Mar 2026 11:08:19 +0000

AI is everywhere, and I'm overwhelmed by how little I understand and how fast things are moving. So I thought it's time to build something, not to catch up, but to finally get it.

The Idea

I took inspiration from projects like pi-mono and qwen-code. Since these tools are open source, I can read the code and actually understand how they work. I've always loved terminal apps, so it made sense that I'd fall in love with coding agent CLIs.

I called it Pebbles. You can check it out on GitHub.

Starting Small

I built it with .NET and Spectre.Console. The first version had:

A mock AI provider that echoed responses
Basic command handling
A colorful terminal UI
Input handling with history

The mock let me focus on the experience first. What does it feel like to chat with an AI in the terminal?

The First Conversation

❯ You: Hello, Pebbles!

⬡ Pebbles:
Hello! I'm a mock AI provider.

Simple first "prototype", but it works. I can type, see responses, and navigate with arrow keys.

What I Learned

Terminal UI is hard - Layout, resizing, making it look good.
Input handling is complex - History, cursor movement, special keys.
Architecture matters - Clean separation between UI, commands, and AI paid off later.
AI as a tutor - I'm not writing everything by hand, and that's okay. I feel like the old ways of building software are long gone. I think using AI to help me understand how the tools I use every day actually work is the way to go, and maybe remove some of that magic.

Why This Matters

AI is moving fast. Building Pebbles is my way of catching up by getting my hands dirty.

Every line of code teaches me something.

What's Next?

Connect to a real AI. For now, I'll be exploring the Coding Plan offered by Alibaba Cloud. It offers a bunch of open-source models: Qwen3.5-Plus (vision), Kimi-K2.5 (vision), GLM-5, MiniMax-M2.5, Qwen3-Max-2026-01-23, Qwen3-Coder-Next, Qwen3-Coder-Plus, and GLM-4.7. See what happens when responses aren't predictable. Will it be slow? How is thinking working? Hard to integrate? Burn through free credits?

Not knowing, and building anyway. That's the fun part.

Exploring Identity Endpoints in .NET 8

Grontis Kostis — Wed, 13 Sep 2023 16:28:58 +0000

.NET Identity refers to the framework's built-in system for managing user authentication and authorization. For many devs , working with Identity can be a daunting experience, especially when dealing with its complex configuration settings, various user stores, and the myriad of options for customization. Fortunately, Microsoft has recently announced improvements in auth as part of the upcoming release of .NET 8, which promises to enhance the overall experience. You can learn more about these upcoming changes here. Today we are going to explore how to utilize the new API endpoints that enable token-based authentication!

Prerequisites

.NET 8.0.0-rc-1 installed.
Visual Studio Preview or VS Code.
A basic understanding of .NET Core and authentication concepts to follow the tutorial effectively.

Getting Started

Let's create a new project. Either from the IDE or the terminal. I'll be using VS Code and the terminal in this guide.

Open the integrated terminal.
Change directory to the desired path.
Run the commands to create and open the project in VS Code: ```powershell

dotnet new webapi -o ApiEndpoints -minimal -f net8.0
code -r .\ApiEndpoints\


> `dotnet new webapi`: This command creates a new .NET Web API project.
> `-o ApiEndpoints`: The `-o` option specifies the output directory for the project.
> `-minimal`: This flag means that the project will be created as a minimal api.
> `-f net8.0`: The `-f` flag specifies the framework to target.

Now that we have the project to work on lets add the packages needed.

Run the following commands to add the packages from the terminal. The version of the packages is the latest at the moment of writing this: 
```powershell


dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore --version 8.0.0-rc.1.23421.29
dotnet add package Microsoft.EntityFrameworkCore.Design --version 8.0.0-rc.1.23419.6
dotnet add package Microsoft.EntityFrameworkCore.Sqlite --version 8.0.0-rc.1.23419.6

We should be have everything set up to start adding code!

Implementation

Let's start by creating the app's user class. It's going to be inheriting from IdentityUser.



using Microsoft.AspNetCore.Identity;

namespace ApiEndpoints;
// Define the AppUser class, which represents a user in the application.
internal class AppUser :IdentityUser
{
    // You can add any additional properties needed for the user entity here.
}

Then, we have to create our DbContext class like so:



using ApiEndpoints.User;
using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace ApiEndpoints.DbContext;
// Create the AppDbContext class that inherits from IdentityDbContext.
internal class AppDbContext : IdentityDbContext<AppUser>
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
    {
        // Constructor for initializing the database context.
    }
}

When using Identity, IdentityDbContext should be used instead of DbContext.

And now we are ready to start adding the services needed for auth to the dependency container.

We register the db context class we created as a service in the Program.cs class, and we configure it with the database provider of our choice:



builder.Services.AddDbContext<AppDbContext>(dbContextOptionsBuilder => dbContextOptionsBuilder.UseSqlite("Data Source=myapp.db"));

Then we add authorization by calling the AddAuthorizationBuilder method. It's a method introduced in .NET 7 which is the preferred way to add authorization services into the IServiceCollection collection and it provides a builder for constructing policies.



builder.Services.AddAuthorizationBuilder();

And now we need to add identity. We do that by calling the AddIdentityApiEndpoints method and then chain the AddEntityFrameworkStores.



builder.Services
    .AddIdentityApiEndpoints<AppUser>()
    .AddEntityFrameworkStores<AppDbContext>();

AddIdentityApiEndpoints adds a set of common identity services and configures authentication to support identity bearer tokens and cookies. More specifically it adds the following:



public static IdentityBuilder AddIdentityApiEndpoints<TUser>(this IServiceCollection services, Action<IdentityOptions> configure)
    where TUser : class, new()
{
    ArgumentNullException.ThrowIfNull(services);
    ArgumentNullException.ThrowIfNull(configure);

    services
        .AddAuthentication(IdentityConstants.BearerAndApplicationScheme)
        .AddScheme<AuthenticationSchemeOptions, CompositeIdentityHandler>(IdentityConstants.BearerAndApplicationScheme, null, compositeOptions =>
        {
            compositeOptions.ForwardDefault = IdentityConstants.BearerScheme;
            compositeOptions.ForwardAuthenticate = IdentityConstants.BearerAndApplicationScheme;
        })
        .AddBearerToken(IdentityConstants.BearerScheme)
        .AddIdentityCookies();

    return services.AddIdentityCore<TUser>(configure)
        .AddApiEndpoints();
}

Finally we add a call to MapIdentityApi to add endpoints for actions like registering a new user, logging in and logging out using Identity.



app.MapIdentityApi<AppUser>();

You can read more about the endpoints that are being created by using this method, and what happens in each endpoint here.

Last but not least we have to run the migrations to our database.



dotnet ef migrations add InitialCreate
dotnet ef database update

To run the above commands you have to have installed the dotnet ef tools cli which you can find here.

Trying out the new endpoints

To test out the new auth we should add the RequireAuthorization method to any endpoint you would like to require authorization to call. I'm going to add it to the endpoint that comes with the template /weatherforecast. Let's run our web api to try it out.
Run the following command:



dotnet run

Your terminal should be showing something similar to this:

Grab the url that shows on the terminal and lets hit the endpoints. You can either do that on any api tool like Postman and Insomnia, or you could view the endpoints on Swagger.

These are all the endpoints that have been created (seeing them on Swagger UI):

We definitely get a lot out of the box with no configuration whatsoever!

If we try to hit the /weatherforecast endpoint this is the response we get:

The tool used for API testing in this article Insomnia.

We will have to register a new user, login with our credentials, grab the token and use it to authenticate ourselves and get the results from the protected endpoint.

Register endpoint (POST) /register

This is a POST request with a JSON request body of the following structure:



{
  "username": "string",
  "password": "string",
  "email": "string"
}

We see that it indeed exists in the database:

To view the sqlite db query results in VS Code, use an extension like SQLite.

Login endpoint (POST) /login

This is a POST request with the following JSON request body:



{
  "username": "string",
  "password": "string"
}

Weatherforecast endpoint (GET) /weatherforecast

We are going to use the access_token that was generated by the login endpoint, to authorize ourselves to be able to call the protected /weatherforecast endpoint.

And that's pretty much it!

Summary

In this guide, we've explored Identity Endpoints in .NET 8 for user login and security. It's certainly easier to handle authentication and authorization with the recent improvements from Microsoft, and it sure seems like a very promising step in the right direction!

Exploring Code Performance Testing in C# with BenchmarkDotNet

Grontis Kostis — Fri, 19 May 2023 11:35:00 +0000

There have been many times where, while coding, I was facing the dilemma of choosing the appropriate LINQ method, or questioning the efficiency and speed of my code. During those moments, when I didn't want to just flip a coin or make random choices, I turned to performance testing. In this article, we will explore how we can test the performance of our C# code by using a library called BenchmarkDotNet!

Introduction

BenchmarkDotNet is a popular open-source library that, as stated in the repo's README.md, helps us to transform methods into benchmarks, track their performance, and share reproducible measurement experiments. Using BenchmarkDotNet feels similar to writing unit tests. It's very important to note that the library only works with console apps. Finally, we can visualize the results in the terminal where the benchmark ran or in user-friendly formats such as markdown, HTML and CSV. We will explore examples of there formats later in the article.

The code of the examples shown in the article can be found here.

Installation

First and foremost, we need to create a console application to run our benchmarks.
We can create a new one using the dotnet CLI in the terminal :

 dotnet new console -n Benchmarks

Next, open the newly created project in your preferred IDE (I'll be using VS Code).
Install the BenchmarkDotNet NuGet package by including the following line in the .csproj file (Version 0.13.5 which is the latest version when this article was written) :

  <ItemGroup>
    <PackageReference Include="BenchmarkDotNet" Version="0.13.5" />
  </ItemGroup>

Alternatively, we can run dotnet add package BenchmarkDotNet in the terminal.

With that, we are ready to start writing our benchmarks!

Setup

Lets create the methods that we want to benchmark. The example is going to be a comparison between two methods that return the sum of all the integers in an array.

using BenchmarkDotNet.Attributes;

namespace Benchmarks;

public class SumBenchmark
{
    readonly int[] arr = new int[] { 1, 2, 3, 6, 7, 8 };

    [Benchmark]
    public int SumWithForLoop()
    {
        int sum = 0;
        for (int i = 0; i < arr.Length; i++)
        {
            sum += arr[i];
        }
        return sum;
    }

    [Benchmark]
    public int SumWithLinqSum()
    {
        return arr.Sum();
    }
}

All we have to do now to run our benchmarks and print the results to the console is to add BenchmarkRunner.Run<SumBenchmark>(); to Program.cs.

Our Program.cs should look something like this now:

using BenchmarkDotNet.Running;
using Benchmarks;

BenchmarkRunner.Run<SumBenchmark>();

We should make sure that the project is build and runs in Release mode, so lets go ahead and do that.

dotnet build -c Release

dotnet run -c Release

That was it, now we should be able to examine the results. We can find them in the BenchmarkDotNet.Artifacts/results folder.

Results

The results are being presented in three different user-friendly forms, markdown, HTML and CSV, as mentioned before. Lets see the results of our example :

Markdown

HTML

CSV (it's a long file so I'll show a part of it)

In the results we can see, for now, the columns Method Mean Error & StdDev. Lets explore what these terms actually mean.

Method. The name of the method being benchmarked.
Mean. By definition it's the sum of a collection of numbers divided by the count of numbers in the collection. In the context of benchmarking, Mean refers to the average execution time of a method over multiple iterations.
Error. It's a metric to let us understand the differences between each iteration. A smaller Error means the measurements were more consistent and closer to each other.
StdDev (Standard Deviation). It measures the variation from the Mean.

Judging from these results, we can see that the SumWithForLoop method performs better than the SumWithLinqSum method on the dataset we provided.
We can have additional metrics by adding configurations, but we will explore these later on this article.

Global Setup and Global Cleanup

In our example, we have hardcoded the values in the array. What if we wanted to create data for a test database and when we are done with benchmarking, to cleanup this database? We wouldn't want to measure the logic of the data creation and retrieval, or database cleanup together with the other two functions. That's where GlobalSetup and GlobalCleanup attributes come into play.

Global Setup

We can setup any method as a setup method by adding the GlobalSetup attribute. This method will be executed once per benchmark method before the execution of the benchmarks. In our case we would move the creation of the array into the method decorated with the attibute.

    [GlobalSetup]
    public void Setup()
    {
        arr = new int[6];
        for (var i = 0; i < arr.Length; i++)
        {
            arr[i] = Random.Shared.Next(1, 10);
        }
    }

Global Cleanup

The same goes for Global Cleanup. We just have to decorate the method that is cleaning up our resources with the attribute GlobalCleanup. This method will be executed once per benchmark method after the execution of the benchmarks.

    [GlobalCleanup]
    public void Cleanup()
    {
        // cleanup logic
        arr = Array.Empty<int>();
    }

It is worth mentioning that there are two more similar attributes IterationSetup and IterationCleanup that as their name suggests, they run before and after each benchmark method iteration.

Parameters

Parameters, in BenchmarkDotNet, add a lot of flexibility into our benchmarks, allowing us to create benchmarks that adapt to different input scenarios and test a range of use cases. When we introduce parameters, the benchmarking process is repeated for each combination of parameter values therefore, it may show separate results for each parameter combination.
Lets try to adjust our benchmarks to use parameters.

    [Params(5, 10, 25)]
    public int ArraySize { get; set; }

    [GlobalSetup]
    public void Setup()
    {
        arr = new int[ArraySize];
        for (var i = 0; i < arr.Length; i++)
        {
            arr[i] = Random.Shared.Next(1, 10);
        }
    }

The results after the parameter addition:

Method	ArraySize	Mean	Error	StdDev
SumWithForLoop	5	2.165 ns	0.0348 ns	0.0326 ns
SumWithLinqSum	5	3.222 ns	0.0097 ns	0.0081 ns
SumWithForLoop	10	4.713 ns	0.0038 ns	0.0032 ns
SumWithLinqSum	10	4.580 ns	0.1015 ns	0.1456 ns
SumWithForLoop	25	12.387 ns	0.1456 ns	0.1290 ns
SumWithLinqSum	25	9.102 ns	0.1543 ns	0.1652 ns

Notice the new column that appeared in our results, ArraySize.

Baselines

Baselines help us understand how well our code performs by giving us a starting point to measure against. They are like a friendly guide that tells us if our code is getting faster or slower. We can have benchmark baselines and job baselines. Lets set the SumWithForLoop method as a baseline, and lets create another variation of the Sum method with a while loop implementation.

    [Benchmark(Baseline = true)]
    public int SumWithForLoop()
    {
        int sum = 0;
        for (int i = 0; i < arr.Length; i++)
        {
            sum += arr[i];
        }
        return sum;
    }

    [Benchmark]
    public int SumWithWhileLoop()
    {
        int sum = 0;
        int counter = 0;
        while (counter < arr.Length)
        {
            sum = arr[counter];
            counter++;
        }
        return sum;
    }

    [Benchmark]
    public int SumWithLinqSum()
    {
        return arr.Sum();
    }

In the summary table we should see two additional columns Ratio and RatioSD.

Method	ArraySize	Mean	Error	StdDev	Ratio	RatioSD
SumWithForLoop	5	2.146 ns	0.0363 ns	0.0339 ns	1.00	0.00
SumWithWhileLoop	5	2.261 ns	0.0727 ns	0.0714 ns	1.05	0.05
SumWithLinqSum	5	3.353 ns	0.0932 ns	0.1244 ns	1.57	0.07

SumWithForLoop	10	4.870 ns	0.0909 ns	0.0759 ns	1.00	0.00
SumWithWhileLoop	10	5.274 ns	0.1219 ns	0.1403 ns	1.07	0.04
SumWithLinqSum	10	4.588 ns	0.0966 ns	0.1385 ns	0.95	0.03

SumWithForLoop	25	12.277 ns	0.1340 ns	0.1046 ns	1.00	0.00
SumWithWhileLoop	25	12.701 ns	0.2838 ns	0.2915 ns	1.04	0.02
SumWithLinqSum	25	9.030 ns	0.1183 ns	0.1106 ns	0.73	0.01

Since the SumWithForLoop method is the baseline, the Ratio is 1 and RatioSD 0. But what do these values mean for the other methods? Ratio is calculated by dividing each measurement of a benchmark to the equivalent measurement of the baseline and then calculating the Mean of all these values. So in our example, the SumWithWhileLoop method is slower than the SumWithForLoop by 0.05 times. RatioSD, which means Ratio Standard Deviation, represents
the consistency of the ratios between two measurements. If the RatioSD is small, it means the comparison is stable, while a high RatioSD means there's more variation in the comparison.

Configurations

BenchmarkDotNet gives us the option to configure the whole benchmarking process to cover everything we might need, from Jobs and Diagnosers, to Loggers and Exporters. Lets go through some of my most used ones!

Diagnosers

Diagnosers play a huge role within BenchmarkDotNet. They provide additional statistics and performance analysis. Whether we need to track memory allocation, monitor hardware performance counters to capture event tracing data, Diagnosers have us covered.

Lets look at an example on the usage. In the example we were using before, lets add a MemoryDiagnoser , which measures the number of allocated bytes and the GC frequency, and the HardwareCounters, which are a set of special-purpose registers built into modern microprocessors to store the counts of hardware-related activities within computer systems. We can do that by adding an attribute for each diagnoser:

[MemoryDiagnoser]
[HardwareCounters(
        HardwareCounter.BranchMispredictions,
        HardwareCounter.BranchInstructions)]
public class SumBenchmark

The final results now include the new columns we specified

Method	ArraySize	Mean	Error	StdDev	BranchInstructions/Op	Allocated
SumWithForLoop	5	3.239 ns	0.0617 ns	0.0547 ns	11	-
SumWithLinqSum	5	6.598 ns	0.0836 ns	0.0741 ns	17	-
SumWithForLoop	10	7.828 ns	0.2991 ns	0.8773 ns	21	-
SumWithLinqSum	10	8.288 ns	0.1952 ns	0.3097 ns	27	-
SumWithForLoop	25	17.850 ns	0.3752 ns	0.5381 ns	50	-
SumWithLinqSum	25	14.094 ns	0.2121 ns	0.1656 ns	56	-

Jobs

Jobs refer to the configuration options that define the target environment for benchmarking. They allow us to specify various parameters related to the runtime, platform, and launch settings, enabling us to simulate different execution scenarios during benchmark runs. With jobs, we can control factors such as the runtime version, runtime iteration mode (single or multithreaded), target platform (x86 or x64), and launch count and warm-up count, among others. By defining different jobs, we can explore how our code performs under various conditions and environments. Lets see an example :

[SimpleJob(BenchmarkDotNet.Jobs.RuntimeMoniker.Net70, baseline: true)]
[SimpleJob(BenchmarkDotNet.Jobs.RuntimeMoniker.Net60)]
public class SumBenchmark

In the above code, we have added the baseline: true parameter to the SimpleJob attribute. This parameter designates the .NET 7.0 job as the baseline job, indicating that it is the reference against which other jobs will be compared. This helps in benchmarking and comparing performance across different frameworks or runtime versions.

Then we can run the benchmarks in multiple frameworks by specifying the target framework moniker names via --runtimes|-r console argument, in our case :

dotnet run -c Release -f net7.0 --runtimes net6.0 net7.0

You can read more about targeting multiple frameworks here.

Conclusion

In conclusion, by leveraging BenchmarkDotNet, we can make informed decisions about our code's performance, identify bottlenecks, and optimize our implementations effectively. With performance testing as a valuable tool in our development toolkit, we can ensure that our code performs optimally and meets the requirements of demanding applications.

You can read further about BenchmarkDotNet here :
Official documentation
GitHub repo
Adam Sitnik's blog Adam is one of the maintainers of the library and his blogs are pretty cool.
Wojciech Nagórski's blog Wojciech is a contributor to BenchmarkDotNet and has a lot of cool articles about the library as well!

Deconstruction in C#

Grontis Kostis — Thu, 20 Apr 2023 15:43:18 +0000

In the past, when I needed to retrieve multiple values from a method, I would typically resort to either creating a new class or using an out parameter, which always felt a bit cumbersome. However, while exploring the features of c# 7, I stumbled upon something that I had been missing all along - Tuple literals and deconstruction. This discovery was a real gem, as it provided exactly what I had been looking for. So, let's delve a little deeper into what this is all about.

Tuple deconstruction

Tuple literal is a shorthand syntax for creating a tuple instance with specific values.

var myTuple = (33, "Hi!", true);

Let's see how we could use this in a method. Imagine that you want to retrieve some data for a person such as, the first name, the last name and the age.

(string,string,int) GetPerson(Guid id)
{
    // Get data from the Database
    // for the sake of the example lets hardcode the values
    string firstName = "John";
    string lastName = "Doe";
    int age = 30;

    return (firstName, lastName, age);
}

The method GetPerson has been designed to return a tuple consisting of three values, the first and second values being of type string, and the third value being of type int. Once the tuple is returned, you may wonder how to access its individual elements.

We can use the default names (Item1, Item2...) for the tuple elements:

var person = GetPerson(Guid.NewGuid());

var firstName = person.Item1;
var lastName = person.Item2;
var age = person.Item3;

Console.WriteLine($"{firstName} {lastName} is {age} years old");

We can change the signature of the method to use custom names for the tuple elements:

(string FirstName, string LastName, int Age) GetPerson(Guid id)
{
    string firstName = "John";
    string lastName = "Doe";
    int age = 30;

    return (firstName, lastName, age);
}

var person = GetPerson(Guid.NewGuid());

var firstName = person.FirstName;
var lastName = person.LastName;
var age = person.Age;

Console.WriteLine($"{firstName} {lastName} is {age} years old");

However my personal preference for utilizing tuples, is to deconstruct them. Deconstruction is a feature that allows us to break apart a complex data structure, such as a tuple, into its individual parts and assign them to separate variables in a single statement. This makes code more concise and easier to read.

So, going back to our example, without changing anything in our method, we could deconstruct the tuple into seperate variables like this:

(string firstName, string lastName, int age) = GetPerson(Guid.NewGuid());

We could even use var, either inside or outside:

(var firstName, var lastName, var age) = GetPerson(Guid.NewGuid());

var (firstName, lastName, age) = GetPerson(Guid.NewGuid());

Non-Tuple deconstruction

One of the major advantages of deconstruction is that it can be applied to any type, not just tuples! To implement a deconstructor, we simply need to create a method called Deconstruct with the following signature:

public void Deconstruct(out T1 x1, ..., out Tn xn) { ... }

Let's see in our example class.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
    public DateTime Created { get; set; }
    public string Address { get; set; }

    public void Deconstruct(out string firstName, out string lastName, out int age)
    {
        firstName = FirstName;
        lastName = LastName;
        age = Age;
    }
}

At this point, we have everything we need to proceed. What's left to do is use a deconstruction assignment to extract the values of the FirstName, LastName, and Age properties of the person object and assign them to variables firstName, lastName, and age, respectively. This will allow us to access these values more conveniently and use them as needed.

var person = new Person
{
    FirstName = "John",
    LastName = "Doe",
    Age = 30,
    Address = "Random Address",
    DateOfBirth = DateTime.Now,
};

var (firstName, lastName, age) = person;

It is worth noting that we are not limited to just one Deconstruct method. In fact, we can define multiple Deconstruct methods for a given type. This can provide us with greater flexibility when it comes to deconstructing objects and accessing their individual parts. However, it is important to ensure that each Deconstruct method accepts a different number of parameters, since methods with the same number of parameters cannot be distinguished during overload resolution.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
    public DateTime DateOfBirth { get; set; }
    public string Address { get; set; }

    public void Deconstruct(out string firstName, out string lastName, out int age)
    {
        firstName = FirstName;
        lastName = LastName;
        age = Age;
    }
    public void Deconstruct(out string firstName, out string lastName, out int age, out string address)
    {
        firstName = FirstName;
        lastName = LastName;
        age = Age;
        address = Address;
    }
}

var person = new Person
{
    FirstName = "John",
    LastName = "Doe",
    Age = 30,
    Address = "Random Address",
    DateOfBirth = DateTime.Now,
};
string firstName, lastName, address;
int age;

(firstName, lastName, age) = person;
Console.WriteLine($"{firstName} {lastName} is {age} years old");
// John Doe is 30 years old

(firstName, lastName, age, address) = person;
Console.WriteLine($"{firstName} {lastName} is {age} years old and is located at {address}");
// John Doe is 30 years old and is located at Random Address

And since i mentioned that the Deconstruct methods need to have different number of parameters, let's see what happens when they don't!

    public void Deconstruct(out string firstName, out string lastName, out int age)
    {
        firstName = FirstName;
        lastName = LastName;
        age = Age;
    }
    public void Deconstruct(out string firstName, out string lastName, out string address)
    {
        firstName = FirstName;
        lastName = LastName;
        address = Address;
    }

The difference here is in the last parameter, from int to string. This code does not compile and we get the following error:

The call is ambiguous between the following methods or properties: 'Person.Deconstruct(out string, out string, out int)' and 'Person.Deconstruct(out string, out string, out string)'

Conclusion

Simply put, deconstruction is a highly effective tool in C# that can enhance your code's brevity and clarity. With this feature, you can swiftly extract values from objects and tuples and assign them to individual variables, saving you from writing repetitive code and making your code more efficient and comprehensible. If you haven't tried using deconstruction in your C# programming yet, it's definitely worth giving it a shot.

View Generated Queries From EF Core

Grontis Kostis — Tue, 14 Mar 2023 18:02:17 +0000

Debugging SQL queries can be a challenging task, particularly when trying to identify issues with an Entity Framework Core application. Fortunately, there are effective ways to view generated SQL queries from EF Core. These techniques can be beneficial for detecting and fixing issues. By applying these approaches, it becomes simpler to identify problems with our Entity Framework Core application. In this article, we'll explore some of the most common methods for viewing generated SQL queries.

Debugging

The simplest way to view generated SQL queries is to use a debugger. We can set a breakpoint to the method that interests us and see what's inside DebugView -> Query

Alternatively, we can assign this value to a local variable with the ToQueryString() method of IQueryable.



var sql = query.ToQueryString();

The generated query looks like this:

Logging

EF Core provides a built-in logging mechanism that can be used to log generated SQL queries to the console, a file, or any other logging provider supported by .NET. We can enable logging with these two ways:

Using a logging provider

To use this approach, we need to add a logging provider and configure the logging options in our application's startup code. For example at our Program.cs file we can do the following :



var loggerFactory = LoggerFactory.Create(builder =>
{
    builder
        .AddFilter((category, level) =>
            category == DbLoggerCategory.Database.Command.Name
            && level == LogLevel.Information)
        .AddConsole();
});

builder.Services.AddDbContext<TodoDbContext>(opt => 
    opt.UseSqlServer(connectionString)
       .UseLoggerFactory(loggerFactory));

Here we use Microsoft's logging framework to create a logger factory that outputs log messages to the console with the .AddConsole() method and we add a filter that only logs messages with a DbLoggerCategory.Database.Command.Name category and a LogLevel.Information level.

Using the LogTo method

Another approach is to use the LogTo() method of the DbContextOptionsBuilder. For example:



builder.Services.AddDbContext<TodoDbContext>(opt => 
opt.UseSqlServer(connectionString)
   .LogTo(Console.WriteLine,LogLevel.Information));

The LogTo() method takes an Action as a parameter, that specifies where log messages should be sent, and a LogLevel value that specifies the minimum log level at which messages should be sent.

In both approaches the results will show up in the console like this :



info: Microsoft.EntityFrameworkCore.Database.Command[20101]


Executed DbCommand (28ms) [Parameters=[@p_0='?' (DbType = Int64)], CommandType='Text', CommandTimeout='30']


SELECT TOP(1) [t].[Id], [t].[IsComplete], [t].[Name]


FROM [TodoItems] AS [t]


WHERE [t].[Id] = @p_0

LINQPad

LINQPad is a popular tool for writing and testing LINQ queries in .NET applications. It also includes a feature for visualizing and analyzing generated SQL queries from EF Core, making it a useful tool for debugging and optimizing database access.

To use LINQPad with EF Core, we follow these steps:

1) Click at the left top corner on Add connection.

2) Select 'Entity Framework Core' on the Data Context prompt

3) We add the necessary information to connect to our database and test the connection by clicking Test.

4) After pressing the OK button , the database gets populated. To visualize the generated SQL query for a LINQ query, we simply run the query and view the SQL output in LINQPad.

For example:

Conclusion

In conclusion, there are several ways to see generated SQL queries from EF Core. Debugging and Logging are simple and effective ways to see SQL queries during development, and LINQPad is a useful tool for quick and ad-hoc debugging and optimization of database access. By using one of these methods, we can improve the performance and efficiency of our EF Core applications and ensure that they are working as expected.

Data Loading in Entity Framework

Grontis Kostis — Tue, 28 Feb 2023 08:34:53 +0000

Data retrieval is an important aspect of designing efficient applications in software development. It is common for applications to require data from a database in order to function. Data access is a critical performance factor that must be carefully considered in this regard. The three common methods of loading data from a database are lazy, eager, and explicit loading. In this article, we will look at the differences between these methods, as well as their benefits and drawbacks.

Lazy Loading

Lazy loading is a technique that allows us to defer the loading of related objects until they are accessed. In other words, we only load the required data when we need it, rather than loading everything at once.

Let's consider an example to understand lazy loading better. Suppose we have two entities, Author and Book, and we want to retrieve all authors and their corresponding books. With lazy loading, we would first retrieve all authors from the database and then retrieve the books for each author only when needed. This approach is beneficial because it reduces the number of queries sent to the database and avoids loading unnecessary data.

Implementation (by Proxies package)

We are going to see how to implement lazy loading in EF Core:

The first method is by installing a Proxy Package provided by Microsoft. All you have to do is install Microsoft.EntityFrameworkCore.Proxies package which will add all the required proxies needed to run Lazy Loading and enabling it with a call to UseLazyLoadingProxies.

This can be achieved either in OnConfiguring method of your Context class:

using Microsoft.EntityFrameworkCore;

namespace DataLoading;

internal class MyContext : DbContext
{
    protected override void OnConfiguring
       (DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseLazyLoadingProxies()
            .UseInMemoryDatabase(databaseName: "MyDb");
    }
}

or when using AddDbContext most likely in the Program.cs:

builder.Services.AddDbContext<MyContext>(
    b => b.UseLazyLoadingProxies()
          .UseInMemoryDatabase("MyDb"));

Any navigation property that can be overridden and is virtual and on a class that can be inherited from will then have lazy loading enabled by EF Core. The Author.Books and Book.Author navigation properties, for instance, will be lazy-loaded in the following entities.

public class Author
{
    public int Id { get; set; }
    public string Name { get; set; }
    public virtual ICollection<Book> Books { get; set; }
}

public class Book
{
    public int Id { get; set; }
    public int AuthorId { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public virtual Author Author { get; set; }
}

In the example above, we use the virtual keyword to mark the Books property as virtual, indicating that it should be lazily loaded. When we retrieve authors from the database, Entity Framework will generate SQL queries to retrieve only the authors, and not the books. When we access the Book property for a specific Author, Entity Framework generates another SQL query to retrieve the corresponding books.

Implementation (by ILazyLoader service)

The second method is by injecting the ILazyLoader service to an entity.

Lets look at an example:

public class Author
{
    private ICollection<Book> _books_;
    public Author()
    {
    }
    private Author(ILazyLoader lazyLoader)
    { 
        LazyLoader = lazyLoader;
    }

    private ILazyLoader LazyLoader { get; set; }

    public int Id { get; set; }
    public string Name { get; set; }
    public virtual ICollection<Book> Books
    { 
        get => LazyLoader.Load(this, ref _books); 
        set => _books = value; 
    }
}

public class Book
{
    private Author _author;

    public Book()
    {
    }
    private Book(ILazyLoader lazyLoader)
    {
        LazyLoader = lazyLoader;
    } 
    private ILazyLoader LazyLoader { get; set; }

    public int Id { get; set; }
    public int AuthorId { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
    public virtual Author Author
    { 
        get => LazyLoader.Load(this, ref _author);
        set => _author = value;
    }
}

This technique enables entity instances generated with new to lazy-load once they are attached to a context and does not require entity types to inherit from, or navigation properties to be virtual.

Now, when you query for an Author entity , EF will generate an SQL query that looks like this:

SELECT [Id], [Name]
FROM [Authors]
WHERE [Id] = @id

This query only selects the Id and Name columns from the Authors table, as EF knows that it doesn't need to load the Books collection yet.

Then, when you access the Books property on the Author entity, EF will generate another SQL query to load the related Book entities:

SELECT [Id], [Name], [Price], [AuthorId] 
FROM [Books] 
WHERE [AuthorId] = @authorId

Similarly, when you query for a Book entity, EF will generate a SQL query that looks like this:

SELECT [Id], [Name], [Price], [AuthorId] 
FROM [Books] 
WHERE [Id] = @id

This query only selects the Id, Name, Price, and AuthorId columns from the Books table, as EF knows that it doesn't need to load the related Author entity yet.

Then, when you access the Author property on the Book entity, EF will generate another SQL query to load the related Author entity:

SELECT [Id], [Name] 
FROM [Authors] 
WHERE [Id] = @authorId

This query selects the Id and Name columns from the Authors table, which is all that's needed to populate the Author property on the Book entity.

Eager Loading

The opposite of lazy loading is eager loading. When we retrieve data from the database using eager loading, we load the primary object as well as all the related objects. When we are certain that we will want all the relevant data and wish to reduce the number of database queries, this strategy is advantageous.

To further understand eager loading, let's look at an example. Let's say we have the same two entities, Author and Book, and we want to use eager loading to get a list of all authors and their books.

Implementation

Here is an example of how to implement eager loading using Entity Framework in C#:

// To load authors with eager loading
using (var context = new MyContext())
{
    var authors = context.Authors.Include(author => author.Books).ToList();
    foreach (var author in authors)
    {
        Console.WriteLine(authors.Name);
        foreach (var book in author.Books)
        {
            Console.WriteLine(book.Name);
        }
    }
}

The Include method is used in the example above to express the desire to eagerly load the Booksproperty for each Author. The Authors and Books tables are joined together by Entity Framework to provide a single SQL query that returns all the necessary information.

SELECT [a].[Id], [a].[Name], [b].[Id], [b].[Name], [b].[Price], [b].[AuthorId]
FROM [Authors] AS [a]
LEFT JOIN [Books] AS [b] ON [a].[Id] = [b].[AuthorId]
WHERE [a].[Id] = @authorId

It is worth mentioning that you can include multiple levels of related data using the ThenInclude method. For example:

using (var context = new MyContext())
{
    var authors = context.Authors
        .Include(author => author.Books)
        .ThenInclude(book => book.CoverImage)
        .Include(author => author.ContactDetails)
        .ToList();
}

Additionally, we can configure to always include a navigation in a model, by using the AutoInclude method on the modelBuilder.

modelBuilder.Entity<Author>().Navigation(author => author.Books).AutoInclude();

Use the IgnoreAutoIncludes method in your query if you don't want to load associated data through a navigation that is defined at the model level to be automatically included. The user-configured auto-include navigations will all cease loading if this approach is used. Using the query below will retrieve all authors from the database, but Books won't load even if it is set to AutoInclude.

using (var context = new MyContext()) 
{ 
    var authors = context.Authors.IgnoreAutoIncludes().ToList(); 
}

We have to be extra cautious when we use eager loading on collection navigation, because it might cause serious performance issues.

Explicit Loading

After the main object has been loaded, explicit loading allows you to load related entities as needed. By limiting the amount of data that needs to be imported from the database, it offers a mechanism to selectively load relevant entities only when they are required, which can enhance efficiency.

In explicit loading, you use the Load method on a CollectionEntry or ReferenceEntry object to explicitly load the related entities. A CollectionEntry object represents a collection navigation property on an entity, while a ReferenceEntry object represents a reference navigation property on an entity.

When you don't want to suffer the overhead of loading associated entities each time the primary entity is loaded, explicit loading can be helpful. For instance, you can use explicit loading to load only the related entities you require at the moment if you have a lot of entities but only occasionally need to access related entities.

Lazy loading must be enabled for explicit loading to function because it depends on it. Calling Load on a CollectionEntry or ReferenceEntry object has no effect if lazy loading is not enabled.

Implementation

Lets see an example and the SQL query generated by EF Core:

var author = dbContext.Authors.Find(authorId);
dbContext.Entry(author).Collection(a => a.Books).Load();

Assuming that lazy loading is enabled, the initial query to retrieve the Author entity would look something like this:

SELECT [a].[Id], [a].[Name]
FROM [Authors] AS [a]
WHERE [a].[Id] = @authorId

When Load is called on the CollectionEntry object for the Books collection, Entity Framework generates a separate query to retrieve the related Book entities:

SELECT [b].[Id], [b].[Name], [b].[Price], [b].[AuthorId]
FROM [Books] AS [b]
WHERE [b].[AuthorId] = @authorId

Conclusion

In conclusion, lazy loading automatically loads related entities when they are visited for the first time, making it a practical and simple method. If too many related entities are loaded at once, however, it may cause performance issues.

In contrast, eager loading loads related entities in addition to the main entity in a single query, which might be more effective than lazy loading in circumstances when you know you will require the associated entities in advance. It can, however, lead to queries that are more complex and may take longer to perform.

In circumstances when you only need to access related entities for a subset of entities, explicit loading is a selective technique that loads related entities as needed after the primary entity has been loaded. On the other hand, it could be less straightforward to use and takes more code to implement. The optimal strategy ultimately depends on the particular needs of your application and the trade-offs between simplicity, performance, and complexity.