# Steven Giesel

> Hey, I'm Steven a .NET Developer in Switzerland. I am a Microsoft MVP. Also, this blog is open source on  GitHub.

## Blog posts

- [A personal note: I built a running App for iOS and watchOS](https://steven-giesel.com/blogPost/38a0d0f4-e9ff-4947-a05c-527af68b6cd1/a-personal-note-i-built-a-running-app-for-ios-and-watchos.md): Since some time I had an issue with my running app, as more and more stuff was locked behind a monthly paywall. Plus certain things were missing, so I created my own: taperwise.
- [If It Quacks - Part 2](https://steven-giesel.com/blogPost/41599817-4457-441e-b874-1a5c67f4e7cc/if-it-quacks-part-2.md): Some days ago I wrote about duck-typing in C# with interceptors. Back then it was a proof-of-concept with a lot of rough edges. Now it is a real library: IfItQuacks.
- [Quack Quack: Duck-Typing in C# with Interceptors](https://steven-giesel.com/blogPost/5170e165-29e8-437a-b5ce-446a84943809/quack-quack-ducktyping-in-c-with-interceptors.md): If it walks like a duck and it quacks like a duck - it is a duck. So duck it and make that work in C# thanks to interceptors!
- [Adding Properties with extension methods in C# 14](https://steven-giesel.com/blogPost/4368fcea-c922-403e-bb3b-6b4990eb36d2/adding-properties-with-extension-methods-in-c-14.md): Thanks to @toupswork for starting a funny discussion about extension properties on a recent post I made: "Adding static getter thanks to extensions". Therefore let's discuss two ridiculous ideas to add properties to existing types using extension methods in C# 14.
- [Claude Memory Admin](https://steven-giesel.com/blogPost/b26c70f8-c11e-4b2b-81ad-54088ed674cf/claude-memory-admin.md): I vibe-coded a small tool to get a grasp on your projects MEMORY.md that is in ~/.claude.
- [xUnit.v3 4.0.0 released](https://steven-giesel.com/blogPost/b0e1aadf-8e88-4553-9636-19df43b1b068/xunitv3-400-released.md): xUnit.v3 got a new major release. This blog post is more about the consequences of that for your local build and CI/CD pipelines than about the new features.
- [.NET Toolbox August Update](https://steven-giesel.com/blogPost/5adbbd4f-8979-4e97-9797-2e1f05ad19b2/net-toolbox-august-update.md): Quite some time passed since I posted a changelog to the .NET Toolbox. And there are big news: The Toolbox is running dotnet native in the browser thanks to wasm and Mono!
- [.NET 11 Performance Edition](https://steven-giesel.com/blogPost/86620358-bb91-4295-84fc-a1329b2567ae/net-11-performance-edition.md): As always my yearly take on the latest .NET release. In a few months dotnet 11 will be released and I wanted to have a look into some performance metrics.
- [Adding static getter thanks to extensions](https://steven-giesel.com/blogPost/605274d2-719b-4b1f-b0d5-3ad9001d9b56/adding-static-getter-thanks-to-extensions.md): Here a simple scenario: You have a StringComparer and you want to add your own comparer to the mix - for example a "natural sort" order, so "file2" sorts before "file10" instead of after. With C# 14 we can extend the family and make it feel natural!
- [Set LogLevel of Blazor](https://steven-giesel.com/blogPost/1cfa82eb-1108-4355-8815-615b094bf9ec/set-loglevel-of-blazor.md): Blazor is a bit talkative when it comes to the Developer Console. PageSpeed Insights for example does complain: Browser errors were logged to the console The fix is easy.
- [LinkedIn - What a dumbster fire](https://steven-giesel.com/blogPost/bf118bb2-0ea4-45ef-babb-26f67bfb0523/linkedin-what-a-dumbster-fire.md): LinkedIn: The "professional" network where critical thinking takes a backseat and everyone is an expert in everything.
- [Signals in Blazor](https://steven-giesel.com/blogPost/495d87ca-61df-4c52-a253-8ba4abc186b7/signals-in-blazor.md): Signals - more often used in Angular - are a nice way to tell the UI that something has changed. Blazor doesn't have that natively, but how would it look, if it did?
- [EF Core 11 makes your split queries faster](https://steven-giesel.com/blogPost/d4401fd0-805a-4703-9d9e-5fe3b57c25ea/ef-core-11-makes-your-split-queries-faster.md): If you use AsSplitQuery anywhere in your codebase, EF Core 11 has a present for you: your queries get faster.
- [Zstandard compression in .NET 11](https://steven-giesel.com/blogPost/6066abb6-640a-4225-ac33-3f4d5a1a1d16/zstandard-compression-in-net-11.md): .NET has had DeflateStream, GZipStream, ZLibStream, and BrotliStream for a while now. In .NET 11, a new one joins the party: ZstandardStream. And now we get to say "Zstd" in .NET.
- [BackgroundService exceptions now propagate in .NET 11](https://steven-giesel.com/blogPost/00fcb870-6bf7-4f97-824f-8eab1b8838be/backgroundservice-exceptions-now-propagate-in-net-11.md): Here's a bug that lived in .NET for over four years As in: Reported over 4 years ago. If your BackgroundService threw an exception after its first await, your host would catch it, log a critical message, and then exit cleanly with exit code 0. So everyone would think it terminated successfully. That got fixed!
- [ConfigurationIgnoreAttribute in .NET 11](https://steven-giesel.com/blogPost/18a61100-6074-43ac-86ae-573ad66a2c8a/configurationignoreattribute-in-net-11.md): Microsoft.Extensions.Configuration has had ConfigurationKeyNameAttribute since .NET 6 which it lets you rename the key a property maps to. But there was never an official way to say "don't bind this property at all." That gap is finally closed in .NET 11 with ConfigurationIgnoreAttribute.
- [Source code generated string enums with exhaustion support](https://steven-giesel.com/blogPost/3acc78ff-5ae2-4be3-af7e-62bfcbf3fb6d/source-code-generated-string-enums-with-exhaustion-support.md): Some time ago (over 4.5 years ago!) I wrote a blog post titled: "A better enumeration - Type safe from start to end". While cool and so - it had some issues. Let's tackle them!
- [records ToString and inheritence](https://steven-giesel.com/blogPost/9be39ff1-b7fc-4814-abd4-5ea41a07f8d7/records-tostring-and-inheritence.md): What is the output of that code snippet? \<div class="code-block"\>\<div class="code-block-header d-flex align-items-center"\>\<button class="btn btn-sm py-0 ms-auto border border-primary text-primary copy-btn"         type="button"         onclick="navigator.clipboard.writeText(this.closest('.code-block').querySelector('pre code').textContent)"\>         \<i class="copy"\>\</i\> \</button\> \</div\> Console.Write(new Derived("Test"));  public abstract record Base(string Key) {     public override string ToString() =\> Key; }  public sealed record DerivedRecord(string Key) : Base(Key); \</div\>Probably "Test"?
- [FullJoin in .NET 11 - potentially](https://steven-giesel.com/blogPost/5a750fbf-cbf1-44dc-b864-70bedd8a29a9/fulljoin-in-net-11-potentially.md): We have Join. We have LeftJoin. We have RightJoin. But somehow we still don't have a proper full outer join in LINQ. That might come soon!
- [Tool-Highlight: Handy](https://steven-giesel.com/blogPost/c193059f-33d5-4332-9b4b-96a5652bb67c/toolhighlight-handy.md): I am using a tool called Handy, which is basically nothing else than speech to text. But it does it so well that I thought, okay, let's give it some broader audience.
- [Being stupid is fun: Let's create long exception messages!](https://steven-giesel.com/blogPost/63431000-1192-4210-a85c-5fff00910d93/being-stupid-is-fun-lets-create-long-exception-messages.md): Sometimes doing arbitrary stuff feels just good! So let's do that!
- [New runtime async is hitting .NET 11 - Part 1](https://steven-giesel.com/blogPost/1fb10ed2-df84-4080-b660-72c04a4cc674/new-runtime-async-is-hitting-net-11-part-1.md): Some time back I wrote about "async2 - The .NET Runtime Async experiment concludes" basically moving the async state machine into the runtime. Now with .NET 11 we are seeing the fruits of that labor.
- [Collection Expression Arguments in C# 15 are "out"](https://steven-giesel.com/blogPost/441e0a21-9869-49e4-beac-b30bb9f9494c/collection-expression-arguments-in-c-15-are-out.md): The first preview of .NET 11 and C# 15 did just release. Some weeks back I did add already an article about that: "Collection Expression Arguments in C# 15+". Well quicker than anticipated that feature is now part of it!
- [.NET Toolbox February Update](https://steven-giesel.com/blogPost/ec7526ca-9f43-4e28-b8cf-2bbcd30349ca/net-toolbox-february-update.md): In Dezember 2025 and January 26 I created a small helper tool: the .NET Toolbox. I also made a post about, if you wanna be "up to speed": ".NET Toolbox". I did some bug fixes and updates.
- [Sometimes you just need extensions methods to model your stuff](https://steven-giesel.com/blogPost/7f6e2ade-b5b9-4de6-a060-281e45b2448e/sometimes-you-just-need-extensions-methods-to-model-your-stuff.md): I came across a recent thing, where I hit the limit with the "normal" approach of modeling my entity and had to resort to extension methods.
- [Collection Expression Arguments in C# 15+](https://steven-giesel.com/blogPost/352fe495-9cc4-4df8-8ad1-a3e26a64185c/collection-expression-arguments-in-c-15.md): There is a nice proposal which would make collection expressions a bit better - Giving the users the ability to pass in arguments to the creation.
- [.NET Toolbox](https://steven-giesel.com/blogPost/043491b9-9d2c-433f-bb9b-1cec5b957083/net-toolbox.md): Let's start the new year with a bang: I created a new tool called "Toolbox" to offer some helpful tools for your everyday .NET life. Totally free, open-source and everything client-side!
- [Task.Delay fails if you wait longer than 49.7 days](https://steven-giesel.com/blogPost/c3bdad0d-f9eb-4dcf-b650-98ec0f5dd4d4/taskdelay-fails-if-you-wait-longer-than-497-days.md): Task.Delay fails if you wait longer than 49.7 days. So something like: await Task.Delay(TimeSpan.FromDays(50)); will fail. But why and should you care?
- [One Minute Knowledge: Is ToArrayAsync or ToListAsync faster for Entity Framework?](https://steven-giesel.com/blogPost/55dbb67c-cd14-444f-81e8-dec9f5ce1448/one-minute-knowledge-is-toarrayasync-or-tolistasync-faster-for-entity-framework.md): Short question, and a short answer: ToListAsync - but why?
- [GitHub Runners might not be a good benchmark baseline](https://steven-giesel.com/blogPost/77f3667e-cf86-4e62-b09f-b32c0aaf58cd/github-runners-might-not-be-a-good-benchmark-baseline.md): I saw mutliple places where people use GitHub runners to do some benchmarking. That can be a tricky thing to do.
- [Mime Type Helper in .NET 11](https://steven-giesel.com/blogPost/8f41d316-f6ac-4712-bf11-ea36b7c2f2e6/mime-type-helper-in-net-11.md): New helper will be available with .NET 11: MediaTypeMap.GetMediaType and MediaTypeMap.GetExtension which makes the web-development a bit easier!
- [Using sortable UUID / GUIDs in Entity Framework](https://steven-giesel.com/blogPost/d6150b89-a3ef-407e-add2-7afa4a2a8729/using-sortable-uuid-guids-in-entity-framework.md): .NET 9 introduced Guid.CreateVersion7() / Guid.CreateVersion7(DateTimeOffset) methods to create sortable UUIDs / GUIDs based on the time of their creation. This can be particularly useful in databases where you want to maintain a chronological order of records (plus some perf benefits). Currently, there is no native way to configure Entity Framework to use these methods when generating new GUIDs for primary keys. But we can do this on our own.
- [No more public partial class Program in .NET 10](https://steven-giesel.com/blogPost/9c156006-3e54-45b9-8e0c-ea933e005983/no-more-public-partial-class-program-in-net-10.md): If you are using API Tests with the WebApplicationFactory you might did something like this to have a public Program class: \<div class="code-block"\>\<div class="code-block-header d-flex align-items-center"\>\<button class="btn btn-sm py-0 ms-auto border border-primary text-primary copy-btn"         type="button"         onclick="navigator.clipboard.writeText(this.closest('.code-block').querySelector('pre code').textContent)"\>         \<i class="copy"\>\</i\> \</button\> \</div\> public partial class Program; \</div\>No more!
- [Capturing Console Output in xUnit.v3](https://steven-giesel.com/blogPost/63a50c08-ddba-4f23-9ce0-b47917e32875/capturing-console-output-in-xunitv3.md): In xUnit v2 ITraceOutputHelper was needed (and injected) to make the console output inside your production code visible inside a test - in v3 it is easier: CaptureConsoleAttribute
- [ArrayPool Benchmarks: We have a problem](https://steven-giesel.com/blogPost/b8dffa1a-84f7-49a2-9dad-3bf8f7f4e410/arraypool-benchmarks-we-have-a-problem.md): Many benchmarks that are using ArrayPool, or more specificly ArryPool\<T\>.Shared, are not actually measuring a "real" scenarion or the benchmark is flawed in some way. Let's examine a bit on what is going on.
- [LinkedIn: "Are you still using new Random() everywhere?"](https://steven-giesel.com/blogPost/cc2a3f52-9d35-43d2-9687-c276a2de8e07/linkedin-are-you-still-using-new-random-everywhere.md): You need some advice around Random? Sure there is something on LinkedIn for that. Let's have a look.
- [Inlining and structs in C#](https://steven-giesel.com/blogPost/e89d7156-f3fd-4152-b78a-cb908bc43226/inlining-and-structs-in-c.md): In this - somewhat technical and barely usable - blog post, we will have a look at inlining and structs in C#. And how they can optimize performance in some interesting ways.
- [Use CancellationTokens](https://steven-giesel.com/blogPost/080baaef-27d4-4d98-b0a8-9c3ab96c335e/use-cancellationtokens.md): This is a very small blog post on why you should use CancellationTokens in your API.
- [LinkedIn Benchmarks again](https://steven-giesel.com/blogPost/06cb9eb9-927e-4bc6-a68a-1471288b9609/linkedin-benchmarks-again.md): Another day, another dollar. LinkedIn has the tips for you! Performance, performance! Let's get right into it.
- [ToDictionaryAsync retrieves the whole object from the database in Entity Framework](https://steven-giesel.com/blogPost/1af57355-7978-40e6-a0f1-3d0ba2c6e1bc/todictionaryasync-retrieves-the-whole-object-from-the-database-in-entity-framework.md): In Entity Framework Core ToDictionaryAsync (and of course) also the the synchronous counter part ToDictionary retrieve the whole object from the database.
- [Divide and Conquer the Database](https://steven-giesel.com/blogPost/c0562c02-9073-46f2-8f66-00e4ebd7c9e3/divide-and-conquer-the-database.md): For a lack of a better title, this blog post shows a database improvement that helped me quite a bit and what to do to make it work.
- [Quick one: Difference between collection expressions and collection initializer](https://steven-giesel.com/blogPost/fea0b033-ccf5-4197-b62c-ffd8ca6d79c7/quick-one-difference-between-collection-expressions-and-collection-initializer.md): Did you ever wonder if there is a noticeable difference between: \<div class="code-block"\>\<div class="code-block-header d-flex align-items-center"\>\<button class="btn btn-sm py-0 ms-auto border border-primary text-primary copy-btn"         type="button"         onclick="navigator.clipboard.writeText(this.closest('.code-block').querySelector('pre code').textContent)"\>         \<i class="copy"\>\</i\> \</button\> \</div\> List\<int\> a = \[1, 2, 3\]; // And List\<int\> b = new() {1,2,3}; \</div\>Let's find out:
- [Two more LINQ extensions in dotnet 10](https://steven-giesel.com/blogPost/5d88d808-03ac-431a-82fa-756b59b38a7d/two-more-linq-extensions-in-dotnet-10.md): The preview 6 of dotnet 10 brings two more functions: InfiniteSequence and Sequence.
- [How to not return all properties in SqlRaw](https://steven-giesel.com/blogPost/c6bea409-9e49-4915-8529-8a8a8574ba80/how-to-not-return-all-properties-in-sqlraw.md): Entity Frameworks SqlRaw has a small, sometimes annoying limitation: The SQL query must return data for all properties of the entity type. Sometimes that isn't desireable, so let's overcome that super easy.
- [Disabling thread safety check in Entity Framework](https://steven-giesel.com/blogPost/f1c14e0f-840c-4dd6-921c-364298a35d6f/disabling-thread-safety-check-in-entity-framework.md): In this blog post we will have a look into how to disable the thread safety check in Entity Framework. What are the implications of doing so and how to do it.
- [Using Architecture Tests for CancellationTokens and sealed classes](https://steven-giesel.com/blogPost/feac44f3-2c6e-4994-80c3-e2a17efbb8f3/using-architecture-tests-for-cancellationtokens-and-sealed-classes.md): Architectural Unit tests are nice to constraint your system (like which parts of your application can access other parts of your application). This blog post is not about that - that is covered a lot in the internet. No, I want to show what I did in a recent project: Checking if all controllers do use CancellationToken and some other entities are sealed.
- [Why Lists are not lowered to a while loop](https://steven-giesel.com/blogPost/2c204a37-1af5-45a4-ac4b-439d2d8a02f0/why-lists-are-not-lowered-to-a-while-loop.md): Some while ago I was explaining what "Lowering" is. And the interesting part is that List behaves differently like an array while also a List is backed by an array. But why?
- [ToListAsync is fast again in Entity Framework (kind of)](https://steven-giesel.com/blogPost/dd7ab934-c311-45e0-9a04-9a28c624b957/tolistasync-is-fast-again-in-entity-framework-kind-of.md): Last year I wrote an article about how ToListAsync was slow in Entity Framework titled: "Be careful with ToListAsync and ToArrayAsync in Entity Framework Core". Things have evolved since then, so let's celebrate!
- [Adding test description for data-driven tests in xUnit](https://steven-giesel.com/blogPost/80a53df4-a867-4202-916c-08e980f02505/adding-test-description-for-datadriven-tests-in-xunit.md): Often times, you find yourself in writing data-driven tests in xUnit (like Theory tests) and you want to add a description to each test case. Let's explore how to do that.
- [You can't use switch expressions in Blazor (sometimes)](https://steven-giesel.com/blogPost/b839cab5-55ad-4fd8-90ca-7799cde8ace0/you-cant-use-switch-expressions-in-blazor-sometimes.md): Did you ever try to have a switch expression in Blazor? Yes, and did it go well? Sometimes not. Let's see why!
- [.NET 10 Performance Edition](https://steven-giesel.com/blogPost/c518e8d6-54b4-407f-af82-e79e0889bc03/net-10-performance-edition.md): As every year, the dotnet team adjusted the runtime and libraries to improve performance. So let's go over some of the highlights. I will link the corresponding blog post or GitHub issue for each item, so you can read more about it if you are interested. And of course: You will find the benchmarks at the end of the article.
- [How to get to know the latest dotnet features - the nerdy way](https://steven-giesel.com/blogPost/f6ad319b-b095-47a0-91d7-800d30a0e3c2/how-to-get-to-know-the-latest-dotnet-features-the-nerdy-way.md): If you want to be up to date with dotnet development, you can obviously follow the official blogs from Microsoft and release notes. But what if you want to pick into the future or smaller details that aren't released or covered? Then let's go to GitHub!
- [Why is enumerating over List faster than IList?](https://steven-giesel.com/blogPost/c624c170-c16c-4414-8506-2ae25ba54df7/why-is-enumerating-over-list-faster-than-ilist.md): If we have a List\<T\> and an IList\<T\>, enumerating over the List\<T\> is faster than enumerating over the IList\<T\>. Why is that?
- [Avoiding reflection in C# in way unsafer ways!](https://steven-giesel.com/blogPost/53691229-fbb1-48cf-95e5-f586f9800ee1/avoiding-reflection-in-c-in-way-unsafer-ways.md): For good reasons, many folks don't want to use reflection. Since .NET 8, we have a better way of dealing with this in most of the cases (when known in advance). But we can go the opposite: Make it even unsafer for a tiny bit performance!
- [Writing new guards with extensions in C# 14](https://steven-giesel.com/blogPost/e2552b7a-293a-4f46-892f-95a0cd677e4d/writing-new-guards-with-extensions-in-c-14.md): In C# we have many nice guards sitting on top of static exceptions classes like ArgumentNullException, ArgumentOutOfRangeException, etc: As ArgumentException.ThrowIfNullOrEmpty, ArgumentException.ThrowIfNullOrWhiteSpace. Now we can extend them easily!
- [Clearing NuGet Caches](https://steven-giesel.com/blogPost/ef7e9271-3b8d-4658-988f-b48bbd11e320/clearing-nuget-caches.md): NuGet can cache a lot of packages and other stuffs over time. Here a small rundown on how to clear the biggest chunk.
- [Does .NET Documentation get ads? Aka: Is Copilot in the docs something useful?](https://steven-giesel.com/blogPost/42cfcbfa-8e70-4b42-ba98-f8f2b7715185/does-net-documentation-get-ads-aka-is-copilot-in-the-docs-something-useful.md): The dotnet documentation gets hints about using GitHub Copilot. Is this an ad? And can we expect more in the future?
- [HttpClient improvements in .NET 10](https://steven-giesel.com/blogPost/58680a06-7870-4a36-8a8a-bf1bf5cf30f1/httpclient-improvements-in-net-10.md): New dotnet version means new features and improvements. There is a nice update to the HttpClient class in .NET 10.
- [Extensions get an update in .NET 10](https://steven-giesel.com/blogPost/d84875c9-c363-45ac-b716-d0b4047396cf/extensions-get-an-update-in-net-10.md): With the latest preview: .NET 10 preview 3, we did get an overhaul on extensions. It might enable some nice tricks in the future.
- [A custom 404 page in Blazor Web Apps](https://steven-giesel.com/blogPost/38a4f1dc-420f-4489-9179-77371a79b9a9/a-custom-404-page-in-blazor-web-apps.md): Sometimes you want to have a custom 404 page - and since .NET 8 and "Blazor WebApps" the \<NotFound\> tag of the Router doesn't work anymore, so let's create a custom page for that.
- [More LinkedIn "Tips": Dragging your whole database into memory!](https://steven-giesel.com/blogPost/1534963c-fcf4-427c-847c-6ebfd8c91f31/more-linkedin-tips-dragging-your-whole-database-into-memory.md): LinkedIn is never short on performance tips on .NET - And this time we drag the whole database towards the client, twice!
- [C# Language Mind map v14](https://steven-giesel.com/blogPost/91563474-ffe6-4c47-b7ee-fb04b5731a74/c-language-mind-map-v14.md): After some time, I updated my C# language mind map to the latest version: C# 14. Either as "poster" or clickable version!
- [Solving Problems you wouldn't have if you wouldn't use Entity Framework](https://steven-giesel.com/blogPost/1b432667-3b2d-4c41-8557-b4c3a3c554d9/solving-problems-you-wouldnt-have-if-you-wouldnt-use-entity-framework.md): Long title - short intro? Well - I recently came across my own stupidity and wanted to display that to the world. Basically, how to dynamically selecting a column with Entity Framework.
- [TypeScript-Go: A 10x Faster TypeScript without .NET but in Go](https://steven-giesel.com/blogPost/a36cc4df-4dce-47e0-b154-9a4a9e4a7a37/typescriptgo-a-10x-faster-typescript-without-net-but-in-go.md): Recent news came out that Microsoft is working on a new TypeScript compiler written in Go (or golang - whatever you prfer). It promises to be 10x faster than the current compiler that is written - well in TypeScript itself. While this is certainly good news, why isn't Microsoft betting on .NET and C#?
- [System.Linq.Async is part of .NET 10 - LINQ for IAsyncEnumerable](https://steven-giesel.com/blogPost/e40aaedc-9e56-491f-9fe5-3bb0b162ae94/systemlinqasync-is-part-of-net-10-linq-for-iasyncenumerable.md): IAsyncEnumerable is a type that was introduced in netcoreapp3.1 times. While somewhat an enumerable (even though async in nature), it never had the capabilities as its synchronous counterpart. Until dotnet 10! Now we have some feature-parity between those two.
- [Tailwind v4 with Blazor - It just got easier](https://steven-giesel.com/blogPost/364c43d2-b31e-4377-8001-ac75ce78cdc6/tailwind-v4-with-blazor-it-just-got-easier.md): Tailwind version 4 was just released. With the new CLI, it is just so much easier to use tailwindcss with Blazor. So in this post, I will show you how to use the new CLI to create a new Blazor project with Tailwind v4. Short disclaimer: If you still want to use version 3, I already wrote an article about this some time ago: "Blazor with TailwindCSS".
- [C# 14: Null-conditional assignment](https://steven-giesel.com/blogPost/b6d22649-7fba-488b-b252-31efdb3686c5/c-14-nullconditional-assignment.md): The preview 1 of dotnet 10, and therefore the next iteration of the C# language, is right in front of our doorsteps. So let's have a look at one of the first potential additions to the language: Null-conditional assignment.
- [IEnumerable vs IEnumerator in C#: One is 2x Faster - LinkedIn Edition](https://steven-giesel.com/blogPost/b705be3e-8d80-4de1-aefb-29c9262c49b7/ienumerable-vs-ienumerator-in-c-one-is-2x-faster-linkedin-edition.md): During my recent browsing on LinkedIn I saw that question: IEnumerable vs IEnumerator in C#: One is 2x Faster – Which One? Naturally, I was very suspicious. So let's find out what is going on here.
- [Managed Postgres Instance: Neon](https://steven-giesel.com/blogPost/e4720110-d276-4591-adf2-bea2351de6da/managed-postgres-instance-neon.md): A contributor for this blog was recently filing a Pull Request to support Postgres. As I didn't want to run that thing locally to test, I needed a cloud service. That is why I tried neon.
- [LINQ MindMap: .NET 10 Edition](https://steven-giesel.com/blogPost/00443661-f75b-4694-852b-175b4a10d6c4/linq-mindmap-net-10-edition.md): Very small update - as the work on .NET 10 starts - or better - continues with full force, I did update the LINQ MindMap.
- [Validate that your DI Container can be created in ASP.NET Core](https://steven-giesel.com/blogPost/d67df2e6-b8f7-4fd8-92ba-426e268b5216/validate-that-your-di-container-can-be-created-in-aspnet-core.md): The .NET provided DI container has some means to check if the container can be created. This is useful to ensure that all dependencies can be resolved and that the container is correctly configured. Let's have a quick look.
- [When will .NET Framework retire?](https://steven-giesel.com/blogPost/6de02565-a08e-4968-b610-22826582c1f1/when-will-net-framework-retire.md): Did you ever ask yourself: When will the good ol' .NET Framework retire? The short answer: I don't know, but we can make a good guess!
- [Cache CORS Preflight Requests](https://steven-giesel.com/blogPost/5fc7cb62-d5ad-4f07-831c-d6c1c6974641/cache-cors-preflight-requests.md): Almost all applications are using CORS (Cross-Origin Resource Sharing) to allow the client to access the resources from the server. When the client sends a request to the server, the server will respond with the Access-Control-Allow-Origin header to allow the client to access the resources.
- [Announcing Developer Academy](https://steven-giesel.com/blogPost/abe1b169-78df-4b0e-a31e-8e274c43549a/announcing-developer-academy.md): Fabian Gosebrink and I finally launch our new website: developer-academy.ch. A website meant for developers that want to level up their skills!
- [Equipping 3rd party types with debugging capabilities](https://steven-giesel.com/blogPost/48d50101-fa20-4f26-9a59-5c1229302460/equipping-3rd-party-types-with-debugging-capabilities.md): Debugging is important, and it's often useful to be able to inspect the state of objects in the debugger. However sometimes you're working with 3rd party types that don't have any debugging capabilities, so you can't see their internal state easily. In this blog post we will have a look on how to equip 3rd party types with debugging capabilities.
- [Why is Open Source important? And is it free?](https://steven-giesel.com/blogPost/591f2354-a205-4507-bbb2-7d88781e0563/why-is-open-source-important-and-is-it-free.md): As I am an open source maintainer myself, I want to highlight my personal thoughts on why open source is important. I will put a bit more focus on the .NET side of things, but most of the thoughts are "valid" in the broader open source world.
- [Authenticate videos and images in Angular](https://steven-giesel.com/blogPost/caa09b13-83e4-452e-899f-598c66181e63/authenticate-videos-and-images-in-angular.md): Sometimes you are faced with the need to authenticate videos and images in Angular. And yes I know, normally I write about .NET, but this one took my some time - so I thought it might be worth sharing.
- [Some news about .NET 10: BackgroundServices and new String Comparer](https://steven-giesel.com/blogPost/3a8c29a3-750a-40f0-aa43-c236b855813e/some-news-about-net-10-backgroundservices-and-new-string-comparer.md): Recently, there were two new features merged in .NET 10 I think are small little quality of life improvements: Avoid Blocking on startup with BackgroundServices and a new string comparer.
- [LINQ might get a "left join" operator in .net 10](https://steven-giesel.com/blogPost/82ebfd51-23c0-44b7-9602-628d1aba5f3c/linq-might-get-a-left-join-operator-in-net-10.md): LINQ has a Join operator, that basically translates to something like a SQL INNER JOIN. There is no built in operator for a LEFT JOIN in LINQ, but you can achieve the same result by using a combination of GroupJoin, SelectMany and DefaultIfEmpty. But there is a chance that this might change in the future, as there is a proposal to add a LeftJoin operator in .net 10.
- [Having fun with ValueTuple](https://steven-giesel.com/blogPost/0a3db64c-e514-45fc-a1a1-2b79cc42f797/having-fun-with-valuetuple.md): Just as a heads up: This blog post will probably bring you 0 value in your daily life - well, maybe a short smile. Let's put ValueTuple to its extreme!
- ["Always use early returns" - LinkedIn Edition](https://steven-giesel.com/blogPost/ba94e3fe-57e7-4f27-83a7-97f349a4b39c/always-use-early-returns-linkedin-edition.md): Ahhhh dear LinkedIn - a pool of gems where everyone is expert in everything. Over the time I collected some trophies from there and today I want to discuss one of them: "Always use early returns".
- [How to assert assumptions in code that might not be true?](https://steven-giesel.com/blogPost/0c8009eb-0bb6-4716-ae6c-fcb3de4a26e6/how-to-assert-assumptions-in-code-that-might-not-be-true.md): Sometimes we have to make assumptions in our code. For example, that a certain property or variable has a specific value. On top comes, we have a specific idea but we are not 100% sure if they are correct. Let's meet Debug.Assert.
- [An awaitable Blazor Modal Dialog](https://steven-giesel.com/blogPost/79ab37d4-5fdf-4c36-8b99-ac17bbe1fc01/an-awaitable-blazor-modal-dialog.md): I already showcased a simple modal dialog in a previous post. However, the dialog was not awaitable. In this post, I'll show you how to create an awaitable modal dialog.
- [Be careful with ToListAsync and ToArrayAsync in Entity Framework Core](https://steven-giesel.com/blogPost/70cebcf5-d171-4852-ae73-4950accfe999/be-careful-with-tolistasync-and-toarrayasync-in-entity-framework-core.md): Entity Framework has two methods for converting a query to a list or an array: ToListAsync and ToArrayAsync. Of course there is also the sync version of these methods: ToList and ToArray. And sometimes, you should use the latter one!
- [ToArray(Async) vs ToList(Async) in Entity Framework 8](https://steven-giesel.com/blogPost/4ec751cd-d773-44c2-996e-cc4ae9ae966c/toarrayasync-vs-tolistasync-in-entity-framework-8.md): When retrieving data from your database with Entity Framework, there are two major options: ToArray and ToList. Besides the different return type, is there any significant difference in performance between the two? Let's find out!
- [Comparing the performance between the Minimal API and classic Controllers](https://steven-giesel.com/blogPost/698c45c3-58c5-4157-b4da-2cde4e27862e/comparing-the-performance-between-the-minimal-api-and-classic-controllers.md): Today, we are going to benchmark the performance of the Minimal API in ASP.NET 9 (and for reference against ASP.NET 8 as well) against the classic Controllers. We will test a few scenarios and check how the performance of the Minimal API compares to the classic Controllers. Let's get right into it!
- [Git Tricks: Get the last checked out branch](https://steven-giesel.com/blogPost/bbfb8333-e05a-4de7-88b9-17ac2248d77f/git-tricks-get-the-last-checked-out-branch.md): In this blog post I will show you two tricks how to easily switch between a branch back and forth and how to get the last checked out branches.
- [Centralize your packages in .NET with NuGet](https://steven-giesel.com/blogPost/988c047a-914a-446d-bd28-4840643dcfb9/centralize-your-packages-in-net-with-nuget.md): A feature that isn't really new but still didn't get my attention until recently is: "Central Package Management". So let's have a look at this in this blog post.
- [xUnit v3 and some stuff about TUnit](https://steven-giesel.com/blogPost/669d5aa2-b86a-4096-948c-9a767b7071e3/xunit-v3-and-some-stuff-about-tunit.md): I know that there is a lot of fuse about TUnit and I am here writing about xUnit. I might cover TUnit in the future, but for now, the topic is the v3 prerelease of xUnit!
- [Fullstack Web Applications with .NET, Nx and Angular Seminar](https://steven-giesel.com/blogPost/c5b4262e-fa6b-4b45-848c-cb5b44c8435c/fullstack-web-applications-with-net-nx-and-angular-seminar.md): Join us for an exciting seminar with Fabian Gosebrink about .NET 8, Nx, and Angular! Learn the latest trends and best practices. More details: here
- [Swagger Replacement in ASP.NET 9](https://steven-giesel.com/blogPost/777776a2-a13c-46bb-bf6b-89316d88508c/swagger-replacement-in-aspnet-9.md): You might have heard that Swagger is removed in the templates of ASP.NET 9. So this blog post will show you alternatives.
- [Managing TaskCancellationTokens in a central service in ASP.NET](https://steven-giesel.com/blogPost/cacc60e5-4fbf-473a-a5af-c9fb333d9183/managing-taskcancellationtokens-in-a-central-service-in-aspnet.md): In async code it is very common to pass a CancellationToken to the method that is being awaited. This allows the caller to cancel the operation if it is no longer needed. But this will lead to some ceremonial code that is repeated in every method. In this article I will show you how to manage CancellationToken in a central service in ASP.NET.
- [LINQ Joins on multiple columns in Entity Framework](https://steven-giesel.com/blogPost/78753461-d80f-4f81-9b4d-6484066aa43e/linq-joins-on-multiple-columns-in-entity-framework.md): I came across a very annoying "issue" with LINQ joins (left joins) in Entity Framework where the compiler drove me nuts!
- [How to test HttpClient inside API Tests](https://steven-giesel.com/blogPost/47e4a351-0f1b-4bb5-a3d5-0ce4d7c1fa61/how-to-test-httpclient-inside-api-tests.md): I am a great fan of API tests. I do like to utilize the WebApplicationFactory for this. I even wrote some articles about this in the past "Introduction to WebApplicationFactory". But what if we need to "mock" HttpClient calls inside our tests?
- [To Soft Delete or Not to Soft Delete](https://steven-giesel.com/blogPost/a807373c-dcc6-42f9-995f-e69dcea1cd47/to-soft-delete-or-not-to-soft-delete.md): In this blog post I will discuss the pros and cons of soft deleting records in a database versus other approaches you can take. Heat up your pop corn and get your salt ready!
- [FormattableStringFactory - Creating dynamic FormattableString instances](https://steven-giesel.com/blogPost/f824cfce-2da4-4037-9f4e-ff652f0ee124/formattablestringfactory-creating-dynamic-formattablestring-instances.md): I recently came across the FormattableStringFactory to create dynamic FormattableString instances. This is a very useful feature in combination with safe SQL queries and the SqlQuery method of Entity Framework Core.
- [async2 - The .NET Runtime Async experiment concludes](https://steven-giesel.com/blogPost/59752c38-9c99-4641-9853-9cfa97bb2d29/async2-the-net-runtime-async-experiment-concludes.md): The .NET team has been working on a new experiment called async2, which is a new implementation of the async/await pattern that is designed to be more efficient and more flexible than the current implementation. It started with green threads and ended with an experiment that moves async and await to the runtime. This post will cover the journey of async2 and the conclusion of the experiment.
- [Organizing Parameters in Minimal API with the AsParametersAttribute](https://steven-giesel.com/blogPost/ee26a396-8f5a-40a7-9dd5-f08cd8c03518/organizing-parameters-in-minimal-api-with-the-asparametersattribute.md): Even though it was introduced in .NET 7, I came across recently the AsParametersAttribute. Let's have a look what it is good for.
- [How many API's does .NET have?](https://steven-giesel.com/blogPost/09952d3c-6bbe-477b-b0ea-07276cdb3ba6/how-many-apis-does-net-have.md): .NET is big, very big! So how many API's does it have? Let's find out!
- [The state machine in C# with async/await](https://steven-giesel.com/blogPost/720a48fd-0abe-4c32-83ac-26926d501895/the-state-machine-in-c-with-asyncawait.md): You often here that the async/await keywords leads to a state machine. But what does that mean? Let's discuss this with a simple example.
- [How not to benchmark!](https://steven-giesel.com/blogPost/98458f74-5205-4b2b-9f5b-535e34ec2fea/how-not-to-benchmark.md): I came across a recent LinkedIn post about the let statement in LINQ and it's performance implication. And in typically influencer fashion it out right claimed that using let in LINQ is a bad idea and should be avoided. But is it a bad idea?
- [UUID v7 in .NET 9](https://steven-giesel.com/blogPost/ea42a518-4d8b-4e08-8f73-e542bdd3b983/uuid-v7-in-net-9.md): .NET natively knows UUID v4 aka Guid.NewGuid(). But with preview 7 we get Version 7 of UUID's natively.
- [Codespaces for your open-source project](https://steven-giesel.com/blogPost/3b993efb-5f70-4d71-8ac9-89f4b85a3dfa/codespaces-for-your-opensource-project.md): In this blog post, I will show you how to use GitHub Codespaces to make it easier for contributors to get started on your open-source project. We will set up a codespace for a .NET repository and configure it to install the required dependencies and tools.
- [ReadOnlySet\<T\> in .NET 9](https://steven-giesel.com/blogPost/f368c7d3-488e-4bea-92b4-abf176353fa3/readonlysett-in-net-9.md): The next preview (preview 6) will bring a new type ReadOnlySet\<T\>. This is a read-only set that is similar to ReadOnlyCollection\<T\>. Let's see how it works and why it was introduced.
- [NCronJob - June Edition](https://steven-giesel.com/blogPost/40647b2f-6efa-4bc2-a7ab-53df460dd6fe/ncronjob-june-edition.md): The last update of NCronJob was some time ago - and as always, there are some new features in the meantime. So here we are, let's go through to highlight them!
- [Are my EF LINQ to SQL queries safe?](https://steven-giesel.com/blogPost/35ec8819-220a-42bc-9224-a812ec358434/are-my-ef-linq-to-sql-queries-safe.md): Have you ever asked yourself if your EF LINQ queries are susceptible to SQL injection attacks? Either because you are querying some user data from a text field or directly taking whatever your API hits against the database?
- [Does an HttpClient await the Header and the body?](https://steven-giesel.com/blogPost/e2c3bcba-4f81-42b0-9b25-060da5e819fa/does-an-httpclient-await-the-header-and-the-body.md): If you call HttpClient.GetAsync or HttpClient.PostAsync and then await the result, does the await wait only for the headers to be received or does it wait for the body to be received? Let's find out!
- [StringBuilders magic for very large strings](https://steven-giesel.com/blogPost/c0144fea-0ff8-4638-be01-b62b48ef7188/stringbuilders-magic-for-very-large-strings.md): The StringBuilder class is used to create mutable sequences of characters. Strings are immutable, so if you need to perform multiple operations on a string, it is better to use a StringBuilder instead of a string. This is especially useful when you need to concatenate a large number of strings. But there is more magic to it, especially when we go BIG!
- [Cancel WhenAny - linked CancellationTokenSource](https://steven-giesel.com/blogPost/cd950c5f-467b-48a3-99fe-e72865460579/cancel-whenany-linked-cancellationtokensource.md): In today's short post, I will show you how to cancel a Task with multiple inputs (aka multiple CancellationTokens) using CancellationTokenSource and CancellationTokenSource.CreateLinkedTokenSource.
- [Help my memory dump always shows me some exceptions!](https://steven-giesel.com/blogPost/fef763ee-d4ef-4379-9dc5-ca6994ba2b70/help-my-memory-dump-always-shows-me-some-exceptions.md): I made a memory dump in my simplest console application and there are a bunch of exception instances around, what is going on? Let’s see in this blog post, why you see a few exception instances in your memory dump.
- [MemoryCache, DistributedCache and HybridCache](https://steven-giesel.com/blogPost/e3ee537a-f70b-43d3-8d13-5cf81bc4406b/memorycache-distributedcache-and-hybridcache.md): The latest preview (.NET 9 preview 4) brought another caching structure to the .NET world - so let's order some things here.
- [Generate http files from a swagger definition](https://steven-giesel.com/blogPost/9fa236ef-67da-4113-95e7-99770dc70444/generate-http-files-from-a-swagger-definition.md): Http files are nice and handy - but they are also a bit of a pain to update. So why not generate them from a swagger definition?
- [NCronJob - Big Updates](https://steven-giesel.com/blogPost/2cb4a908-2dbb-4a9d-9c32-73d094b6670f/ncronjob-big-updates.md): Since the last blog post a lot has happened and many new features have been added to NCronJob. In this blog post I would like to introduce you to the new features and explain how you can use them.
- [.NET 9 LINQ Performance Edition](https://steven-giesel.com/blogPost/783a404a-e39e-480f-bc99-a514a75d752d/net-9-linq-performance-edition.md): As with almost every edition of .NET, the team has been working on improving performance. In this blog post, we will see some improvements to the related tickets and benchmarks.
- [Boosting Productivity with Analyzers](https://steven-giesel.com/blogPost/a5f6f281-1d0c-4b9e-8812-dc84faf41bcf/boosting-productivity-with-analyzers.md): I am a big fan of Analyzers, and in this blog post, I will showcase some of my favorite ones!
- [Checking your solution for NuGet vulnerabilities or deprecated packages](https://steven-giesel.com/blogPost/a825c041-26dc-4488-8707-17697871d08e/checking-your-solution-for-nuget-vulnerabilities-or-deprecated-packages.md): While your software might be the best in the world, it's only as good as the libraries it uses. In this small blog post, we will discover how to check your solution for NuGet vulnerabilities or deprecated packages.
- [ How does a List know that you changed it while enumerating it?](https://steven-giesel.com/blogPost/6c39fcc6-2218-44b9-8280-deadb995aac2/-how-does-a-list-know-that-you-changed-it-while-enumerating-it.md): Everyone falls for that and tries to change a list while enumerating it greeted by the System.InvalidOperationException: Collection was modified; enumeration operation may not execute. message. But how does the List know that you changed it? Let's find out.
- [Does readonly make your code faster?](https://steven-giesel.com/blogPost/50b84029-4f1e-4e6d-8fd1-0311b0605562/does-readonly-make-your-code-faster.md): In this blog post we will discover whether or not the readonly modifier can make your code faster. So without further ado let's get started.
- [AI Hype - Am I out of work in five years?](https://steven-giesel.com/blogPost/5194faba-28db-4949-9d33-d7c1000b1156/ai-hype-am-i-out-of-work-in-five-years.md): AI is a hot topic - one would say hype topic, and there are bold claims like this: There Will Be No (Human) Programmers in Five Years Source: https://decrypt.co/147191/no-human-programmers-five-years-ai-stability-ceo Now how far is this from reality? Let's take a look at the current state of AI in the context of programming.
- [Fluent API to await multiple calls and get their respective results](https://steven-giesel.com/blogPost/d55cdae5-7294-40cc-a9d5-7552e092205e/fluent-api-to-await-multiple-calls-and-get-their-respective-results.md): Sometimes, you have multiple async calls to make, and you want to do that asynchronously and get the results afterward. Let's build a fluent API to do that.
- [Equip 3rd party types with a deconstructor](https://steven-giesel.com/blogPost/0775d3d3-8f90-4546-95d8-71a6b1e7b0e8/equip-3rd-party-types-with-a-deconstructor.md): Deconstructor are a C# language feature that allows you to define a method that will be called when an object is being split up into its components. While this is straightforward to implement for your own types, it is not possible to add a deconstructor to a 3rd party type - or is it?
- [Pattern matching and the compiler can be surprising](https://steven-giesel.com/blogPost/9892bd03-96bf-4ab0-aacc-973a99d5f5e0/pattern-matching-and-the-compiler-can-be-surprising.md): Pattern matching is a powerful feature in C#. It allows you to match a value against a pattern and extract information from the value. The compiler does the magic for you - and sometimes it struckles with that.
- [C# 13: Allow ref and unsafe in iterators and async](https://steven-giesel.com/blogPost/0d4216e5-4445-48c4-8d9c-3ff5aa1bfdc3/c-13-allow-ref-and-unsafe-in-iterators-and-async.md): C# 13 might get a new feature soon that allows ref and unsafe in iterators and async methods.
- [NCronJob - Scheduling made easy](https://steven-giesel.com/blogPost/f58777b8-e10b-4023-845b-9f5ad3b7e48f/ncronjob-scheduling-made-easy.md): Hangfire/Quartz or BackgroundService? Why not something in the middle? Did you ask yourself this question from time to time? Do you want to have a full-blown job scheduler with lots of setups, but more than BackgroundService is needed? Meet: NCronJob!
- [bUnit v2 - The Blazor unit testing library vNext](https://steven-giesel.com/blogPost/0827131c-9b33-4c92-a2fa-5dd6616b72f9/bunit-v2-the-blazor-unit-testing-library-vnext.md): Next to the big release of .NET 8, we also released the first preview bUnit v2. This release is a major release, with a lot of new features and improvements. In this post, I will highlight some of the most important changes. This includes new features but also some breaking changes.
- [Typesafety in xUnit with TheoryData\<T\>](https://steven-giesel.com/blogPost/a8aa3385-8829-444a-b269-7ecb38aeaf2f/typesafety-in-xunit-with-theorydatat.md): I recently discovered this small but very useful utility in xUnit: TheoryData\<T\>.
- [Lock statement patterns](https://steven-giesel.com/blogPost/4cf6d48a-ec9d-4c68-961c-31fd8d8c1340/lock-statement-patterns.md): A few weeks back, I wrote an article "A new lock type in .NET 9" where I showcased the new Lock type. Nothing fancy - well, at least it was more expressive. But now the dotnet team went a step further with this!
- [Avoid multiple boolean parameters](https://steven-giesel.com/blogPost/9994b00c-8bc2-4794-ae74-80e6ee4cd5e5/avoid-multiple-boolean-parameters.md): Boolean parameters are nice, but it's hard to keep track of what each one does when you have multiple of them. In this blog post, we will see why it's better to avoid multiple boolean parameters and how to refactor them.
- [LINQ MindMap: .NET 9 Edition](https://steven-giesel.com/blogPost/62049533-001a-46fb-a1da-88effc0183f1/linq-mindmap-net-9-edition.md): After my first LINQ MindMap: Here is an updated version that includes everything up until .NET 9.
- [Garbage Collector (over)simplified](https://steven-giesel.com/blogPost/2e23afb8-4dc6-461e-8110-4122c7fefee7/garbage-collector-oversimplified.md): In this blog post, a small and (over)simplified infographic on how the Garbage Collector works.
- [SearchValues object become better with .NET 9](https://steven-giesel.com/blogPost/080c8f82-f376-489f-a304-72d419978294/searchvalues-object-become-better-with-net-9.md): SearchValues, which were introduced with .NET 8 will become an upgrade and becomes more usable! Let's see how.
- [Three new LINQ methods in .NET 9](https://steven-giesel.com/blogPost/0594ba85-356b-47f1-89a9-70e9761c582e/three-new-linq-methods-in-net-9.md): Even though we are in the alpha of .NET 9 and .NET 8 was released not more than two months ago, the dotnet team does not sleep and pushes new changes! In this blog post, we are checking what new methods were added to everyones favorite: LINQ.
- [A replacement for BinaryFormatter in .NET 8](https://steven-giesel.com/blogPost/4271d529-5625-4b67-bd59-d121f2d8c8f6/a-replacement-for-binaryformatter-in-net-8.md): In the old .NET Framework days, you could use the BinaryFormatter class to serialize and deserialize objects. This can be convenient for cloning or storing some session states. As the BinaryFormatter has some serious security concerns, the .NET team marked it as obsolete (as error) in .NET 7 and onwards.
- [An alternative to AutoMapper](https://steven-giesel.com/blogPost/3368bf96-648e-4fa2-9c6c-be71e40ac4cc/an-alternative-to-automapper.md): I am not the biggest fan of AutoMapper. It starts with good intentions but often ends up being a big mess. I have seen it used in many projects, and the configuration of the mappings is often scattered all over the place, and or they are huge!
- [Const strings are not so const after all](https://steven-giesel.com/blogPost/544c33da-be2e-4d96-99c9-9313f48548bd/const-strings-are-not-so-const-after-all.md): We know the const keyword with strings - but are they really constant after all? Or can we use some tricks to modify them? Let's see.
- [An asynchronous lock free ring buffer for logging](https://steven-giesel.com/blogPost/11f0ded8-7119-4cfc-b7cf-317ff73fb671/an-asynchronous-lock-free-ring-buffer-for-logging.md): In this blog post, I showcase a very simple lock-free ring buffer for logging. I'll show why it's useful and how it works.
- [A new lock type in .NET 9](https://steven-giesel.com/blogPost/d7f923b3-13ff-4ecc-8b8f-d847ae581f68/a-new-lock-type-in-net-9.md): There is a new sheriff in town when it comes to the lock keyword, And that is the new System.Threading.Lock type that is introduced in .NET 9. And yes, I know - we still need time to digest the big .NET 8 release.
- [The first possible new feature of C# 13: Params collection](https://steven-giesel.com/blogPost/5f4fef86-d251-4a47-b893-ca4c515ca314/the-first-possible-new-feature-of-c-13-params-collection.md): Only one month after the big release of .NET 8, the dotnet team is already working on the next iteration: .NET 9. With that also comes new language features. The first one is about to be merged into the main development branch: Params Collections.
- [bUnit Generators - Generate your stubs automatically](https://steven-giesel.com/blogPost/76b40ab1-033b-488e-b11a-a5922fa8a4b7/bunit-generators-generate-your-stubs-automatically.md): We made a recent addition to bUnit that we think will make your life easier. We call it bUnit Generators. It's a set of code generators that will help you create stubs for your third-party components.
- [Entity Framework - Storing complex objects as JSON](https://steven-giesel.com/blogPost/5bf635cb-3533-4207-905f-81eb86512219/entity-framework-storing-complex-objects-as-json.md): From time to time, it is nice to store complex objects or lists as JSON in the database. With Entity Framework 8, this is now easily possible. But this was possible all along with Entity Framework 7.
- [A journey about the new interceptors of .NET 8](https://steven-giesel.com/blogPost/be1252ac-ba95-41e6-a105-1fdbf3b955a6/a-journey-about-the-new-interceptors-of-net-8.md): This blog post describes my journey writing a new interceptor for .NET 8. This is not meant as a general tutorial, even though I will showcase some of the code samples.
- [Blazor .NET 8 - Enhanced Form Navigation](https://steven-giesel.com/blogPost/2e87048d-cbf3-4378-8938-efd4648453a1/blazor-net-8-enhanced-form-navigation.md): There are many new cool features with .NET 8 and Blazor in particular. In this blog post, I want to highlight a feature that I believe is very useful in the new context Blazor is living.
- [A more flexible and enhanced way of logging in .NET 8](https://steven-giesel.com/blogPost/1add3827-4233-4e31-9ce9-bcc34d64e76f/a-more-flexible-and-enhanced-way-of-logging-in-net-8.md): The latest version of the .NET (version 8) has introduced a "better" way of logging. This new way of logging is more flexible and enhanced than the previous versions. It is about the LoggerMessageAttribute.
- [Interactive LINQ tutorial, especially for beginners](https://steven-giesel.com/blogPost/e0a98ec5-6da2-4b89-9ebd-39df175a079c/interactive-linq-tutorial-especially-for-beginners.md): LINQ (Language Integrated Query) is a powerful feature of C# that allows you to query data from different data sources. It is a must-have skill for every C# developer. That is why I created: https://linqmarbles.info/
- [Redux Pattern in Blazor](https://steven-giesel.com/blogPost/d62f8d80-ba9b-47c3-9040-8e17affda513/redux-pattern-in-blazor.md): In this blog post, we will use the Redux pattern with a small Blazor application. To demonstrate the inner workings, we will built everything from scratch.
- [Yes you can create classes on the stack!](https://steven-giesel.com/blogPost/74cc8abc-b6e3-4cb0-ba98-9c92f9a5a4d2/yes-you-can-create-classes-on-the-stack.md): In this article we will create a class, aka a reference type on the stack, and therefore don't use any managed memory!
- [Interfaces can have private methods](https://steven-giesel.com/blogPost/03957748-73b3-40f9-a9f7-cc95501a3a8e/interfaces-can-have-private-methods.md): Let's drop some "useless" knowledge here. Interfaces can have private methods. This comes with the C# 8 feature: "Default interface methods".
- [Blazor with TailwindCSS](https://steven-giesel.com/blogPost/351838ba-e308-4a09-b9f6-75bb95c39610/blazor-with-tailwindcss.md): Ever wondered how to use TailwindCSS with Blazor? Let's make it work!
- [Structured Concurrency in C#](https://steven-giesel.com/blogPost/59e57336-7c73-472f-a781-b0b79f0d47ad/structured-concurrency-in-c.md): Did you ever hear about "Structured Concurrency"? If not, this article is for you. We will discover what it is, why it is useful, and what it could look like in C#.
- [.NET 8 and Blazor United / Server-side rendering](https://steven-giesel.com/blogPost/3c71e553-490f-4d52-8104-eb8338c0207f/net-8-and-blazor-united-serverside-rendering.md): New .NET and new Blazor features. In this blog post, I want to highlight the new features that are hitting us with .NET 8 in the Blazor world. So let's see what's new.
- [Questions I asked as .NET interviewer](https://steven-giesel.com/blogPost/d64172d0-6b72-4d60-9935-0159c72997e4/questions-i-asked-as-net-interviewer.md): This blog post is a small collection of questions I asked as a technical interviewer when we had candidates for software developer positions. This might be helpful for you if you are preparing for a job interview.
- [Less boilerplate code with the new primary constructor in C# 12](https://steven-giesel.com/blogPost/1b2a4f18-86da-42d3-9ddc-8b41ed1eba0f/less-boilerplate-code-with-the-new-primary-constructor-in-c-12.md): The new language feature "primary constructor" which will be released with C# 12 / .NET 8 this year (November 2023) allows you to remove some ceremonial code. Let's see how.
- [A new way of doing reflection with .NET 8](https://steven-giesel.com/blogPost/05ecdd16-8dc4-490f-b1cf-780c994346a4/a-new-way-of-doing-reflection-with-net-8.md): .NET 8 introduced a new way of doing reflection. Why did they introduce this, and what are some benefits - this blog post will give you some insights.
- [Building a Minimal ASP.NET Core clone](https://steven-giesel.com/blogPost/e84dec43-51f1-4c70-8b3b-dcdb1c3164ce/building-a-minimal-aspnet-core-clone.md): In this article, we will build a minimal version of what ASP.NET Core does - yes, you read right. We will create a very simplistic clone of ASP.NET Core to discuss how the whole thing works. Beginning with a simple console application, we will add the necessary components to make it work as a web server. Bonus points for our own middleware pipeline and dependency injection.
- [Enabling List\<T\> to store large amounts of elements](https://steven-giesel.com/blogPost/37b32c2a-245f-4cb9-9e32-73a1091b025b/enabling-listt-to-store-large-amounts-of-elements.md): List\<T\> is one of the most versatile collection types in .NET. As it is meant for general-purpose use, it is not optimized for any specific use case. So, if we look closely enough, we will find scenarios where it falls short. One of these scenarios is when you have lots of data. This article will look at precisely this.
- [Turn on Nullability checks by default](https://steven-giesel.com/blogPost/f65dee5e-a4eb-44b4-b338-a453acfdd5bd/turn-on-nullability-checks-by-default.md): Since C# 8, we have nullable reference types. The word sounds odd, given the fact that reference types are always nullable. The idea is that the default is that your reference types have to be properly initialized. Here are my thoughts after a few years of using them.
- [The "Weak Event" Pattern in C#](https://steven-giesel.com/blogPost/675b75fc-2c1b-43da-9ff8-42962ca8159b/the-weak-event-pattern-in-c.md): Events in C# are a powerful mechanism for decoupling components and enabling a publisher/subscriber model. However, they have a significant drawback: the publisher holds a strong reference to the subscriber, and this can cause memory leaks. This article describes a pattern for implementing weak events in C#.
- [Expression-bodied members in properties](https://steven-giesel.com/blogPost/a15563a2-257d-469a-a359-830debfba4ce/expressionbodied-members-in-properties.md): Are these two expressions the same? \<div class="code-block"\>\<div class="code-block-header d-flex align-items-center"\>\<button class="btn btn-sm py-0 ms-auto border border-primary text-primary copy-btn"         type="button"         onclick="navigator.clipboard.writeText(this.closest('.code-block').querySelector('pre code').textContent)"\>         \<i class="copy"\>\</i\> \</button\> \</div\> public class MyClass {     public int A { get; } = Random.Shared.Next(1000);     public int B =\> Random.Shared.Next(1000); } \</div\>
- [Enum.TryParse unexpected behavior](https://steven-giesel.com/blogPost/64d479f1-823f-4fc7-a56a-2b1ff06dcf72/enumtryparse-unexpected-behavior.md): Enums are very simple structures, but some functions like Enum.TryParse can have unexpected behavior. In this short blog post, we discover why and what are the alternatives.
- [Creating Your Own Fakes Instead of Using Mocking Libraries](https://steven-giesel.com/blogPost/2ad414c8-273f-4976-a9de-c95f0e791d51/creating-your-own-fakes-instead-of-using-mocking-libraries.md): With respect to the current topic around Moq, I want to showcase how you can easily roll out your own fakes so that you are not depending on a third party library.¨
- [What's going on with Moq? SponsorLink and burnt soil!](https://steven-giesel.com/blogPost/1939d20c-2493-4bf7-9636-96436283fb72/whats-going-on-with-moq-sponsorlink-and-burnt-soil.md): The famous Moq library faced some criticism due to the usage of SponsorLink. What is the problem, and what is going on here? And obviously, I will add all the sources to the articles.
- [Keyed Services in the IServiceProvider in .NET 8 preview 7](https://steven-giesel.com/blogPost/40dab3bb-d17e-4357-b579-b1d95fb9bfda/keyed-services-in-the-iserviceprovider-in-net-8-preview-7.md): The .NET 8 preview 7 will bring another exciting feature some of you probably awaiting for a long time: Keyed services.
- [The combined power of F# and C#](https://steven-giesel.com/blogPost/2f70d926-ec92-4dfe-b278-18f78078253d/the-combined-power-of-f-and-c.md): Where C# is the most dominant language in the .NET world, other languages are built on top of the Framework that deserves their respective place. F# is strong when it comes down to functional programming! In this blog post, we will leverage the power of F# and C# to showcase where both excel!
- [How to benchmark different .NET versions](https://steven-giesel.com/blogPost/59cfb6f8-8b87-4707-a99e-e372541b696a/how-to-benchmark-different-net-versions.md): With the famous BenchmarkDotNet library you can benchmark a lot - but it doesn't stop with a single .NET version. You can benchmark multiple versions of the same code that targets different runtimes!
- [Gracefully Handling Entity Framework Exceptions with EntityFramework.Exceptions](https://steven-giesel.com/blogPost/693e8b9c-4b97-43a4-8bf7-991c633900b4/gracefully-handling-entity-framework-exceptions-with-entityframeworkexceptions.md): Working with databases can sometimes be daunting, mainly when errors occur. These errors or exceptions can be due to many reasons, such as constraint violations, connection issues, or syntax errors. Entity Framework throws a generic DbException or DbUpdateException for most of these database issues. But we cand get more specific exceptions based on the concrete "problem"! That's where EntityFramework.Exceptions comes in.
- [.NET Framework 4.8 to .NET 6 migration](https://steven-giesel.com/blogPost/f531dded-44af-4341-871c-d54875877900/net-framework-48-to-net-6-migration.md): I was recently tasked to migrate an application with around 150 projects from the "old"It is still supported .NET Framework 4.8 to a recent .NET 6. As the application is still under development and used, the migration should be done step by step over time in iterative steps rather than a big bang refactoring. This blog post will go a bit into more detail about how I approached the situation and what I learned. This is a highly subjective post, and there are plenty of ways of approaching it - so take it with a grain of salt and mileage may vary.
- [Three tricks with Dictionary](https://steven-giesel.com/blogPost/53090b7c-d594-4b55-b513-60bcc7b36f35/three-tricks-with-dictionary.md): In this short blog post, I want to showcase three nice tricks you can do with everybody's favorite data type: the dictionary. It is a versatile data structure, and we can make it even more versatile!
- [Overload resolution in C#](https://steven-giesel.com/blogPost/3ebbefe2-7db7-4d1d-8d81-719009504027/overload-resolution-in-c.md): On a recent LinkedIn Post from Saeed Esmaeelinejad, he asked what is the outcome of: \<div class="code-block"\>\<div class="code-block-header d-flex align-items-center"\>\<button class="btn btn-sm py-0 ms-auto border border-primary text-primary copy-btn"         type="button"         onclick="navigator.clipboard.writeText(this.closest('.code-block').querySelector('pre code').textContent)"\>         \<i class="copy"\>\</i\> \</button\> \</div\> bool flag = SomeMethod();  M(flag ? 1 : 2);  void M(long number) =\> Console.WriteLine("long"); void M(short number) =\> Console.WriteLine("short"); \</div\>What is the outcome?
- [Why I like and prefer xUnit](https://steven-giesel.com/blogPost/c24c5326-22f4-4035-9f87-a20e4814121d/why-i-like-and-prefer-xunit.md): In almost all of my projects, I only use xUnit, and here is a small love letter. Especially the one fact I do think makes it a good choice!
- [LINQ: Select.Where or Where.Select?](https://steven-giesel.com/blogPost/57ed9867-4afd-4d02-9f35-e0941bc6f715/linq-selectwhere-or-whereselect.md): LINQ is a very powerful tool for querying data. As the majority of functions are built on top of IEnumerable\<T\> and it, in most cases returns IEnumerable\<T\> as well, it is very easy to chain multiple functions together. That leaves you with a question: which one should I use, Select.Where or Where.Select?
- [Missing Stack trace when eliding the await keyword](https://steven-giesel.com/blogPost/aa63a951-e619-4a31-9baf-5a15eb802b93/missing-stack-trace-when-eliding-the-await-keyword.md): You may have heard that when you elide the await keyword in a method that returns a Task or Task\<T\>, you lose the stack trace. Buy why does that happen? Let's find out!
- [Create your own Mediator (like Mediatr)](https://steven-giesel.com/blogPost/dc27bbf9-55c7-4f11-bec5-cf1704df3a21/create-your-own-mediator-like-mediatr.md): In this blog post, I'll show you the fundamentals of the Mediator pattern and how to implement it in your application from scratch. And yes, we basically implement the famous MediatR library.
- [C# 12: Collection literals](https://steven-giesel.com/blogPost/9916410c-0428-4caf-b88e-9fbae72b6a1f/c-12-collection-literals.md): A new feature is hitting C# 12 and it is called Collection literals. In this blog post, I will show you what it is and how it works.
- [How does List work under the hood in .NET?](https://steven-giesel.com/blogPost/06e2c8e8-0119-4e8d-9227-3cb922a8c916/how-does-list-work-under-the-hood-in-net.md): A List is one of the most used data types in .NET. You can dynamically add elements without taking care of how that happens. But do you know what is going on under the hood?
- [Span / Memory / ReadOnlySequence in C#](https://steven-giesel.com/blogPost/8bb02704-a113-40a1-9414-fe7b8cb3dda5/span-memory-readonlysequence-in-c.md): There are many different memory types used in modern C# programs. The more common ones are Span\<T\> and Memory\<T\>. Occasionally there is also ReadOnlySequence\<T\>. What do these types do?
- [Time abstraction in .NET 8](https://steven-giesel.com/blogPost/4d5b70fe-35c1-43c7-bebe-49194195ffcb/time-abstraction-in-net-8.md): With the upcoming release of .NET, the team introduced an abstraction of time itself. That can bring you major benefits especially if you have to test scenarios where time is a crucial part! Until now, you had to create your own wrapper. This, of course, makes integration with 3rd party libraries tricky.
- [New Terminal logger for .NET 8](https://steven-giesel.com/blogPost/f6e0accf-9493-4cc4-8992-e8300e6b0cbc/new-terminal-logger-for-net-8.md): With preview 4 of .NET 8, a new terminal logger was introduced. It basically removes a lot of the noise that the default logger produces. It also adds some nice colors to the output. Let's see how to use it!
- [nameof get's a bit better in C# 12](https://steven-giesel.com/blogPost/5b0bcb83-4508-4cde-9299-80940bf4709a/nameof-gets-a-bit-better-in-c-12.md): The nameof operator is a great way to get the name of a variable, type, or member. With C# 12 it's getting even better. Let's see how.
- [How does TryGetNonEnumeratedCount work?](https://steven-giesel.com/blogPost/c341ffbc-d816-49ca-82a7-0e0e3b3e5910/how-does-trygetnonenumeratedcount-work.md): TryGetNonEnumeratedCount attempts to determine the number of elements in a sequence without forcing an enumeration. It returns true if it could and false if it couldn't. The API was added with .NET 6 - let's have a look at how that thing works.
- [6 useful extensions for IEnumerable ](https://steven-giesel.com/blogPost/1b8eaaef-01a3-4799-9a96-f0d37197d175/6-useful-extensions-for-ienumerable-.md): I did already write about some useful extension methods for Task and ValueTask. Today I want to show you some useful extension methods for IEnumerable.
- [Some cool things you can do with ValueTuple](https://steven-giesel.com/blogPost/bcbb602f-4080-4e89-9929-019bb4e1cb58/some-cool-things-you-can-do-with-valuetuple.md): In this blog post, we will explore some cool things you can do with ValueTuple. Also, a short explanation of what ValueTuple is and how it works.
- [Becoming a Microsoft MVP](https://steven-giesel.com/blogPost/2809a9a9-66e3-4928-a5fb-6abbdbfdf272/becoming-a-microsoft-mvp.md): In this article, I will talk about my journey to becoming a Microsoft MVP. I will talk about the process, the requirements, and the benefits of becoming a Microsoft MVP. Of course, this is my personal experience and journey, so mileage may vary.
- [Entity Framework and ordered indexes](https://steven-giesel.com/blogPost/12c2926a-cf51-438a-af5a-5d160e9f3844/entity-framework-and-ordered-indexes.md): In Entity Framework 7, the team has added support for ordered indexes to the fluent API. In this blog post we will look at how to use this feature and what it means for your database.
- [Controlling the log level of your application](https://steven-giesel.com/blogPost/90c41e56-5a68-448a-ae0e-f7476d141c29/controlling-the-log-level-of-your-application.md): In this blog post, we will have a look at the different log levels and how to control them.
- [Verifying your DI Container](https://steven-giesel.com/blogPost/ce948083-974a-4c16-877f-246b8909fa6d/verifying-your-di-container.md): Microsoft's integrated dependency injection (short DI) container is very powerful, but there are also certain pitfalls. In this article, I will show you what some of the pitfalls are and how you can verify them.
- [Create your own Validationattribute in ASP.NET Core](https://steven-giesel.com/blogPost/004506a9-4c70-483d-a14f-3a56086fe6f1/create-your-own-validationattribute-in-aspnet-core.md): In this small blog post, I will show you how to create your own Validation attribute in ASP.NET Core to tailor-made your validation rules.
- [Domain events and the "Unit of Work" pattern](https://steven-giesel.com/blogPost/ae55581a-9722-4735-8d0e-bfcfe4f6ad5a/domain-events-and-the-unit-of-work-pattern.md): In this blog post, we will discuss the "Unit of Work" pattern and how it can be used to implement domain events in a DDD application. For that, we will also discuss how we can leverage middleware to implement the "Unit of Work" pattern in a .NET application. A lot of things are going to happen in this blog post, so let's get started.
- [Covariance and Contravariance in C#](https://steven-giesel.com/blogPost/cda93276-c9ab-42c3-8288-a9b3e5c8aa5c/covariance-and-contravariance-in-c.md): Let's talk about Contravariance and Covariance in C# using .NET Framework examples! Contravariance and covariance are essential concepts in C# when dealing with generics, enabling us to have more flexibility when assigning generic types. So let's have examples straight from the framework itself! Also, we will go a bit deeper and talk what some differences between generic constraints and things like Contravariance are.
- [.NET 8 Performance Edition](https://steven-giesel.com/blogPost/f6504300-7bf0-48d2-8a14-ba4e2bbea02e/net-8-performance-edition.md): As with every .NET release, Microsoft improves the performance of the runtime and guess what: This release is no exception to this. In this blog post, I want to go through some of the improvements made so far (.NET 8 preview 3).
- [5 useful extensions for Task\<T\> in .NET](https://steven-giesel.com/blogPost/d38e70b4-6f36-41ff-8011-b0b0d1f54f6e/5-useful-extensions-for-taskt-in-net.md): In this short blog post, I will show you 5 useful extensions for Task in .NET. We will build them as extension methods, so there are easy to use. On top, I will show a small example of how to use them. So let's go!
- [Source Generators and Regular Expressions](https://steven-giesel.com/blogPost/667db4f5-d34a-4625-bc3d-aa47187c591a/source-generators-and-regular-expressions.md): Source Generators are more and more an integral part of the .NET ecosystem. But how does that play together with everyone's favorite: Regular Expressions? In this blog post we will dive in how we can leverage source generators in combination with regular expression to have a debuggable, but also very performant way of executing regular expressions!
- [LINQ on steroids with SIMD](https://steven-giesel.com/blogPost/faf06188-bae9-484d-804d-a42d58d18cad/linq-on-steroids-with-simd.md): In this blog post, we will explore the use of SIMD instructions to speed up LINQ queries. We will use the Vector type of performing SIMD operations on arrays of data. We will also use the BenchmarkDotNet library to measure the performance of our code. We will also see how this works hand in hand with the new "generic math" feature of C# 10.
- [Creating a ToolTip Component in Blazor](https://steven-giesel.com/blogPost/fda6848e-61f6-40d0-95c8-45925712b462/creating-a-tooltip-component-in-blazor.md): In this blog post we will create a ToolTip component in Blazor from scratch. We will use the Blazor WebAssembly template to create a new project. We will then add a ToolTip component to the project and use it in the Index page. We will also add some styling to the ToolTip component. The advantage over using a library is that we can customize the component to our needs as well as keeping it simple! So let's get started!
- [C# Source Generators: How to get build information?](https://steven-giesel.com/blogPost/cec8df6e-b271-4b4c-8ff6-e9f3aa5e26a1/c-source-generators-how-to-get-build-information.md): Source generators are a powerful feature introduced to C#, allowing developers to generate additional code during the compilation process automatically. They can help reduce boilerplate, improve performance, and simplify your codebase. This blog post will introduce source generators, discuss how they work, and walk through an example of a source generator for generating build information.
- [Leverage 'is not' Operator for Exception Filtering!](https://steven-giesel.com/blogPost/d3b295a1-45d0-4399-8486-c3b67d5bc9e4/leverage-is-not-operator-for-exception-filtering.md): Did you know you can use the 'is not' operator with exception filtering to simplify and improve your error handling in C#? In this short blog post, I will show you how to use it.
- [Caching in .NET with MemoryCache](https://steven-giesel.com/blogPost/b355a042-2c5b-4d96-b1ca-a9dc0fc23509/caching-in-net-with-memorycache.md): In this blog post, we will discuss how we can "cache" entries from the database. We will talk about why we would do this in the first place and how to achieve that. Also, we will talk about some implications and what "cache invalidation" is.
- [Write your own AutoMapper in C#](https://steven-giesel.com/blogPost/16bf84c2-1464-40ab-8ef6-58f225e21c15/write-your-own-automapper-in-c.md): Sometimes you have to map an object to another representation in C#. And you think: Why isn't C# duck-typing capable? You might hear of libraries like AutoMapper that do the tedious work of mapping one object to another with the same structure. This blog post will give a super simple introduction to how those libraries are working internally. In the end a bit of a subjective topic on whether or not I would use such libraries.
- [LINQ // Skip and Take](https://steven-giesel.com/blogPost/ce9ba892-bafe-4a62-8806-7ebf91f28a94/linq-skip-and-take.md): Skip and Take are used for pagination or limit the number of elements returned by a query. Since C# 8 you can use Take with a Range. Let's see some examples.
- [How to write your own cron Job scheduler in ASP.NET Core (like Quartz, Hangfire, ...)](https://steven-giesel.com/blogPost/fb1ce2ab-dd27-43ed-aaab-077adf2d15cd/how-to-write-your-own-cron-job-scheduler-in-aspnet-core-like-quartz-hangfire-.md): In this blog post we will discover how to write your own small task scheduler / job scheduler with cron notation in ASP.NET Core. You might know similar approaches under the name of Quartz or Hangfire. With the help of BackgroundService we will build our own, lightweight version of it.
- [Benchmarking - A matter of perspective](https://steven-giesel.com/blogPost/34c613f4-8962-40bc-80ad-ac270d285e75/benchmarking-a-matter-of-perspective.md): In recent months and years, there was a certain hype around benchmarking, also in the .NET community. This blog post is meant to ground some of the benchmarking topics and put this into relation to other things so you get a better understanding if it's worth the effort.
- [Is a square a rectangle? Liskov substitution principle in action](https://steven-giesel.com/blogPost/67425427-01cd-4707-8572-991c3f9c5fc2/is-a-square-a-rectangle-liskov-substitution-principle-in-action.md): I will put that simple question in the room: "Is a square a rectangle?" And you might thank: "Well dah, of course!" But wait for a second and let's check it together. We will use the L in SOLID: The Liskov Substitution principle to check if this relationship makes sense for us!
- [The Humble Object Pattern](https://steven-giesel.com/blogPost/47acad0a-255c-489b-a805-d0f46bde23e5/the-humble-object-pattern.md): The Humble Object Pattern is a design pattern to make especially unit testing easier with the goal of separating behaviors that are easy to handle (domain logic) from behaviors that are hard to handle (like external events or dependencies). So let's have a look at what it is and how you can utilize it.
- [Performance (ReadOnly)List vs Immutable collection types](https://steven-giesel.com/blogPost/3bd2cb74-58a4-42cd-90e3-6c3a8befe854/performance-readonlylist-vs-immutable-collection-types.md): A bit back on LinkedIn, there was a discussion about read-only collection and immutability where this is not the point I want to discuss now, as I already covered that here: "ReadOnlyCollection is not an immutable collection". This post is just about the performance of those types compared to our baseline, the good old List\<T\>. It also explains why we see the results we see.
- [From Testing Pyramid to Diamond](https://steven-giesel.com/blogPost/86b6fae7-95a7-44fa-a85a-00ee1b6dd697/from-testing-pyramid-to-diamond.md): In this article, we will discuss the testing pyramid - what it is and what are some problems with that. We will also discuss a different approach: The testing diamond.
- [Getting git version information in your C# code](https://steven-giesel.com/blogPost/b8f685c2-4bdb-4ca4-a129-3fc81a3678c6/getting-git-version-information-in-your-c-code.md): Did you ever need git-specific information like the latest tag or the current commit inside your C# code? Or even the semantic version number of your current build= Well, there is an easy solution involving source generators.
- [error NETSDK1194: The "--output" option isn't supported when building a solution.](https://steven-giesel.com/blogPost/554ba273-9594-4d55-aac2-1366e28954b3/error-netsdk1194-the-output-option-isnt-supported-when-building-a-solution.md): Did you see the following error in recent days in your build-pipeline: error NETSDK1194: The "--output" option isn't supported when building a solution. If so - that is not necessarily your fault at all! Microsoft released a new SDK version, which breaks your builds. Let's see why and what we can do to tackle that.
- [A (performance) quirk with JsonSerializer](https://steven-giesel.com/blogPost/0e7512b0-c854-4cce-8606-765fcaf1e69c/a-performance-quirk-with-jsonserializer.md): System.Text.Json.JsonSerializer has a weird quirk in regard to performance and memory management. So we will discuss what is "wrong" with this code: JsonSerializer.Serialize(myObject, new JsonSerializerOptions(...));.
- [What is a Middleware and how to use it in ASP.NET Core?](https://steven-giesel.com/blogPost/16535182-1fb0-4fa9-8ffa-7b90e1355e5b/what-is-a-middleware-and-how-to-use-it-in-aspnet-core.md): Did you ever ask yourself: What is a middleware, and why should I use it? If so, this blog post is exactly for you. We will see where we could use a middleware and also how we can use the Dependecy Injection container of ASP.NET Core.
- [Multi-Tenancy with RavenDB and ASP.NET Core](https://steven-giesel.com/blogPost/3f18ed50-487f-45fa-a71f-6b0ddf3d87ec/multitenancy-with-ravendb-and-aspnet-core.md): Multi-tenancy is a software architecture pattern where a single instance of a software application is used by multiple customers, with each customer having separate and isolated data, configurations, and resources. RavenDB is a NoSQL document database that provides a flexible and scalable solution for multi-tenant applications. This blog post will explore why multi-tenancy exists, the advantages of using RavenDB for multi-tenant applications, and provide code examples to get you started.
- [C# Language Mind map](https://steven-giesel.com/blogPost/f17d2762-b184-474b-9565-d5d40bf7cf49/c-language-mind-map.md): This blog post contains a mind map of language features starting from C# 1 up til now - including some of the new C# 12 features that will be released in November 2023.
- [Repository Pattern - A controversy explained](https://steven-giesel.com/blogPost/9fa7fe83-3ede-4ecb-ab27-4012b1333c0e/repository-pattern-a-controversy-explained.md): In this blog post, we'll dive into the ins and outs of the repository pattern and examine both its benefits and its potential drawbacks. We will start from the very basic to some more advanced use cases. So let's dive right into it.
- [Native DateOnly and TimeOnly support in Entity Framework 8 in SQL Server](https://steven-giesel.com/blogPost/eae9904c-152f-4087-add9-ea78d1b15442/native-dateonly-and-timeonly-support-in-entity-framework-8-in-sql-server.md): .NET 6 brought us two new datatypes: DateOnly and TimeOnly. For those types we don't have any first class support in Entity Framework - until now. There is a recent change, that hit us with Entity Framework 8 that might ease the situation and brings native support for those types.
- [C# Lowering](https://steven-giesel.com/blogPost/69dc05d1-9c8a-4002-9d0a-faf4d2375bce/c-lowering.md): Did you ever hear the word "compiler magic" or "syntactic sugar"? Probably yes and therefore we want to dissect what this "magic" really is! We can see how we can predict performance or bugs by "lowering" our code. Also we will see how things like foreach, var, lock, using, async, await, yield, anonymous types, record, stackalloc, pattern matching, Blazor components, deconstructor, extension methods... do not really exist.
- [Deep nesting - Why and how to avoid](https://steven-giesel.com/blogPost/61c2f923-c100-449b-b67c-563970a7b214/deep-nesting-why-and-how-to-avoid.md): ... if you need more than 3 levels of indentation, you're screwed anyway, and should fix your program. This is written in the Linux style guide. Let's see why they have that rule and how we can overcome deeply nested code.
- [C# 12: Primary Constructors](https://steven-giesel.com/blogPost/a210c97e-fe68-45de-afa1-d053d75f6f7d/c-12-primary-constructors.md): Another new C# 12 feature might drop soon and makes its debut with the next iteration: Primary Constructors. The blog post will talk about what a Primary constructor is, why we already have it, and what the proposal tries to change. Exciting times are ahead of us!
- [Cohesion - An indicator for refactoring](https://steven-giesel.com/blogPost/d0784f04-fe7a-4426-bdb7-314d0f9e1b6b/cohesion-an-indicator-for-refactoring.md): Cohesion represents the degree to which the elements of a module belong together. A module or class is said to be highly cohesive if its methods and data are highly related, meaning that a change in one affects just a small number of elements. We can use this metric to know whether or not an object is in a good shape or needs some refactoring.
- [Entity Framework 8: Raw SQL queries on unmapped types](https://steven-giesel.com/blogPost/d1f069fb-7f6d-4f80-a98f-734755474ae1/entity-framework-8-raw-sql-queries-on-unmapped-types.md): The next iteration of Entity Framework, namely Entity Framework 8, will have a new and exciting feature: Support raw SQL queries without defining an entity type for the result That means less boilerplate code!
- [Easy Pagination for Entity Framework in 3 steps](https://steven-giesel.com/blogPost/09285b33-79e6-4879-95e0-35aeae5fbcc6/easy-pagination-for-entity-framework-in-3-steps.md): Pagination is the process of dividing a set into discrete pages. In the context of Entity Framework, that means we are only getting a certain amount of entries from the database. And we will implement a very easy solution to make that happen in 3 steps. The result will look like this: \<div class="code-block"\>\<div class="code-block-header d-flex align-items-center"\>\<button class="btn btn-sm py-0 ms-auto border border-primary text-primary copy-btn"         type="button"         onclick="navigator.clipboard.writeText(this.closest('.code-block').querySelector('pre code').textContent)"\>         \<i class="copy"\>\</i\> \</button\> \</div\> var pagedList = DbContext.BlogPosts.ToPagedList(page: 1, pageSize: 5); \</div\>
- [No, No, No - Tasks are not threads and they are not for performance!](https://steven-giesel.com/blogPost/d095383f-7ea9-4419-96b8-889c6981cce0/no-no-no-tasks-are-not-threads-and-they-are-not-for-performance.md): I often read that Task is used for multithreading in C# / .NET, but that is not the case. And it is crucial to understand why this isn't the case. We will also see which problem exactly Task is solving in the first place.
- [Using GitHub as your portfolio](https://steven-giesel.com/blogPost/2516bdf5-43f3-4940-a0c0-ee83dcaa5e55/using-github-as-your-portfolio.md): GitHub is a powerful platform for developers to showcase their work and projects. It can be an excellent tool for landing a job, as many employers use it to search for and review potential candidates. In this post, we'll discuss how to effectively use GitHub as a portfolio to impress potential employers and increase your chances of getting hired.
- [.NET Tips and Tricks \& ValueStringBuilder](https://steven-giesel.com/blogPost/66075e5c-c95a-44c4-8030-cd45d7855d1c/net-tips-and-tricks-valuestringbuilder.md): I want to showcase two of my many side projects. My .NET Tips and Tricks website, where I collect and categorize, well, tips and tricks around .NET-related topics as well as my ValueStringBuilder.
- [Give your strings context with StringSyntaxAttribute](https://steven-giesel.com/blogPost/d2b2fc18-ca4c-4879-b87f-a1d36f435805/give-your-strings-context-with-stringsyntaxattribute.md): Strings are one of the most universal data types. We use them for URLs or regular expressions or even to define some date. With .NET 7 we have a new way of giving those strings a bit of meaning. Meet StringSyntaxAttribute. I also show you a way how to use them in .NET 6 and earlier.
- [C# 12: Default Parameters in Lambdas](https://steven-giesel.com/blogPost/79ce95ad-17a9-4537-8f1b-48d71efc585d/c-12-default-parameters-in-lambdas.md): There is still a long road ahead of us until the release of .NET 8, but the first new language constructs are getting public. The first one I want to present is: Default Parameters in Lambdas.
- [ReadOnlySpan\<char\> and strings - How not to compare them](https://steven-giesel.com/blogPost/969cc5e7-da27-4742-ae9a-ab7a66715ff6/readonlyspanchar-and-strings-how-not-to-compare-them.md): Many know that you can take ReadOnlySpan\<char\> objects when dealing with strings. They give you a direct way of operating on the underlying memory. Often times you can use them interchangeably, but there are scenarios where you really have to watch out what is going on. This blog post will have a look at a major problem with ReadOnlySpan when used like a "regular" string.
- [Structure and order your DI container](https://steven-giesel.com/blogPost/f557493c-0919-44fc-8073-40b4fb90d53e/structure-and-order-your-di-container.md): Does your Dependency Injection container is one big pile of method calls one after the other? Are there 50 lines of just AddScoped, AddTransient, and so on? Well, let's fix this. We can utilize extension methods to make an order to that mess!
- [Array, List, Collection, Set, ReadOnlyList - what? A comprehensive and exhaustive list of collection-like types](https://steven-giesel.com/blogPost/f11aadf5-5a55-4742-b046-28dddd0b3ebf/array-list-collection-set-readonlylist-what-a-comprehensive-and-exhaustive-list-of-collectionlike-types.md): .NET knows a big list of collection-like types like: IEnumerable, IQueryable, IList, ICollection, Array, ISet, ImmutableArray, ReadOnlyCollection, ReadOnlyList, and many more. This blog post will give you an exhaustive list of types in .NET and when to use what.
- [Simple DI - Container](https://steven-giesel.com/blogPost/8cd29874-1bb5-4df5-8e0a-293a293eb25a/simple-di-container.md): This blog post will show you a very simple Dependency Injection container. This will give a better understanding of what Dependency Injection is and how it is done. And sure we will see how this is related to IoC - Inversion of Control.
- [Delete a record without prior loading in Entity Framework](https://steven-giesel.com/blogPost/5f58e2a2-2b50-4e0c-8062-09d003c729a9/delete-a-record-without-prior-loading-in-entity-framework.md): Sometimes you have an Id of an object and want to delete the underlying thing from the database. But it doesn't make sense to load the whole object from the database to memory first. So how can we achieve this quickly?
- [ChatGPT - Current state for .NET - and in general](https://steven-giesel.com/blogPost/566d2090-eb8e-492d-ac99-fb6f14b6e042/chatgpt-current-state-for-net-and-in-general.md): ChatGPT is going viral right now. Besides funny conversations, you can use that tool to generate also code for you. But does it really hold up to its reputation and it is a serious pairing partner? Let's see.
- [Check for elevated rights in .NET 8](https://steven-giesel.com/blogPost/fea90d87-a7d5-4312-b426-b976fa941ab9/check-for-elevated-rights-in-net-8.md): In the past, it was tricky to get if the current process runs under elevated rights. In the sense of it is run under the sudo group in \*nix (Unix, Linux, macOS, you name it) or administrative rights in Windows. But that changes with .NET 8 as we now have a unified API for that.
- [Abstraction vs Encapsulation](https://steven-giesel.com/blogPost/db756623-13af-420e-bf86-a14c5ef85aa0/abstraction-vs-encapsulation.md): Abstraction and Encapsulation are two fundamental concepts in object-oriented programming. So let us have a small look what the difference is between those two.
- [How to enumerate through a StringBuilder](https://steven-giesel.com/blogPost/5161909a-a223-4312-b939-996a0f97bf75/how-to-enumerate-through-a-stringbuilder.md): Did you ever wonder how we can iterate through a StringBuilder? I mean, of course, we can just call ToString and use the returned string, but that means we materialize the whole thing without good reason. We can also use a normal for-loop. But we can also find a completely different and probably dumber way!  And if you wonder: No, this is not something you do in your daily life, but by doing so, I can show some cool stuff C# and .NET offer.
- [New ArgumentException and ArgumentOutOfRangeException helpers in .NET 8](https://steven-giesel.com/blogPost/f4bc6fcc-5691-4f72-b9bb-75aeeb59230a/new-argumentexception-and-argumentoutofrangeexception-helpers-in-net-8.md): Do you remember how .NET 6 introduced the ArgumentNullException.ThrowIfNull guard? And afterward, with .NET 7 we've got this excellent bit: ArgumentException.ThrowIfNullOrEmpty? Guess what, there might come some new handy additions for the upcoming .NET 8 iteration. So let's see what are those new changes and how they make the code simpler.
- [A new wave of analyzers in .NET 8](https://steven-giesel.com/blogPost/1a03a998-e428-4a42-9c30-1cfbf6ac5f4c/a-new-wave-of-analyzers-in-net-8.md): Analyzers did become an integral part of the .NET ecosystem. Their main responsibility is to find potential code issues and warn you. Often times this comes even with potential fixes you can directly apply. And Microsoft will continue this journey with the upcoming .NET 8 release. This blog post will show you potential candidates, which will make the cut.
- [Frozen collections in .NET 8](https://steven-giesel.com/blogPost/34e0fd95-0b3f-40f2-ba2a-36d1d4eb5601/frozen-collections-in-net-8.md): .NET 7 was freshly released but Microsoft does not sleep. .NET 8 is already in the making and I want to showcase to you one new area where the dotnet team is working on Frozen collections. So let's have a look at what frozen collections are and how they are working.
- ["Use always a StringBuilder" - Internet myths](https://steven-giesel.com/blogPost/480539f1-98ab-45bc-ba24-9ccec65b459a/use-always-a-stringbuilder-internet-myths.md): Use always a StringBuilder That is what you can read from time to time. The basic idea is, that a StringBuilder is "better" to be defined. Why are people telling that lie? Let's discuss this and see what it isn't true.
- [How to get allocations in .NET? And how big is an empty array?](https://steven-giesel.com/blogPost/db43d6f4-4b93-415f-be03-600ee358cdfd/how-to-get-allocations-in-net-and-how-big-is-an-empty-array.md): Often times we hear about allocations on the heap. How can we easily measure this? This article will show you a very easy way of doing so. Plus we will answer the question how big is an empty array? And if you think 0 bytes, then spoiler alert, that is not the case at all.
- [Anonymous test data with AutoFixture](https://steven-giesel.com/blogPost/0a7d1bff-6c97-4d98-97cf-d72cd2b3888e/anonymous-test-data-with-autofixture.md): Often times we have unit or integration tests that rely on some input data. The easiest solution is just to take some hard-coded values and move on with life. This has some major downsides: Giving specific values in a test carries meaning, but we are often times not interested in that. We just need to pass the object around to fulfill the API. Also the simplest solution to fulfill your test is literally checking against those values. Here is an elegant solution to that problem: AutoFixture. I will show you what it can do, especially in combination with xUnit.
- [Design patterns explained with sketches](https://steven-giesel.com/blogPost/91629412-1440-4aa6-add8-acd925831b35/design-patterns-explained-with-sketches.md): This article will explain design patterns, which we use on a daily base, with smaller (over)simplified illustrations.
- [Mutable value types are evil! Sort of...](https://steven-giesel.com/blogPost/7b896127-41a4-4008-87cb-d2fbdd5a0d5b/mutable-value-types-are-evil-sort-of.md): You might have heard that mutable value types are evil. But why is that and why does the .NET framework use them then? Are they really that evil? Let's have a look at a few examples and have a look what is going on!
- [Marking API's as obsolete or as experimental](https://steven-giesel.com/blogPost/1d97ea56-9a32-4067-9919-10b9af5623a6/marking-apis-as-obsolete-or-as-experimental.md): Often times your API in your program or library evolves. So you will need a mechanism of telling that a specific API (an interface or just a simple method call) is obsolete and might be not there anymore in the next major version. Also it can happen that you have a preview version of a API, which might not be rock-stable and the API-surface might change. How do we indicate that to the user?
- [Infographics Compendium III - Exceptions, EF Sanitized, Operators, ...](https://steven-giesel.com/blogPost/b0a7d757-a13e-4bea-9f72-af0ddca5d701/infographics-compendium-iii-exceptions-ef-sanitized-operators-.md): This edition has the following infographics: DebuggerDisplayAttribute Entity Framework input and LINQ - is it safe? ExceptionDispatchInfo implicit and explicit operator
- [local functions vs lambda expressions](https://steven-giesel.com/blogPost/8e2f551d-0812-4c5f-9f00-b353a37c48a1/local-functions-vs-lambda-expressions.md): .NET knows local functions and lambda expressions. You can almost take them interchangeably, but there are also some differences between them. This article will show the differences between them.
- [Throwing exceptions - Why is my stack trace lost?](https://steven-giesel.com/blogPost/bc82fda9-eb47-47bd-850b-9d115a59a571/throwing-exceptions-why-is-my-stack-trace-lost.md): You might have read, that re-throwing an exception like this: throw exc; is considered bad practice and you should just do this: throw; instead. But why is it like that?
- [LiteDB - A .NET embedded NoSQL database](https://steven-giesel.com/blogPost/d376a46c-ec5b-4e37-81b3-23772c47ed85/litedb-a-net-embedded-nosql-database.md): In this article we will have a closer look at LiteDB, a .NET NoSQL Document Store in a single data file. We will discover the advantages of LiteDB and why it is a viable candidate for your next project. We will also explore what are the differences between a NoSQL and a classical SQL database are and what this has to do with the reminiscent SQL CE or the more modern SQLite database.
- [Cursed C# - Doing shenanigans in C#](https://steven-giesel.com/blogPost/5360d1c3-89f6-4a08-9ee3-6ddbe1b44236/cursed-c-doing-shenanigans-in-c.md): In this short blog post I want to show you two silly things so that you can apply right now! Both of them equally silly, but that is not the point (is it ever?). We will see how to await an integer or TimeSpan and how to foreach through an integer. All of this thanks to the magic of extensions methods.
- [Infographics Compendium II - ThrowHelper, null Task and more](https://steven-giesel.com/blogPost/daf89cc8-4f07-4c9b-bc27-1865856e7986/infographics-compendium-ii-throwhelper-null-task-and-more.md): This edition has the following infographics: ConfigureAwait on IAsyncDisposable Index in foreach Non-destructive mutations with struct Returning null for a Task Throw-Helper verbatim strings
- [Low-level struct improvements in C# 11](https://steven-giesel.com/blogPost/2a807220-166a-4fd0-99cc-a56765767fbd/lowlevel-struct-improvements-in-c-11.md): C# 11 brings some major improvements for structs. You remember Span\<T\>, which you couldn't create? Now you can. C# 11 allows ref fields in a struct. Why this is a cool thing and what you can do with it, you will see in a minute.
- [How does the key exchange in HTTPS work?](https://steven-giesel.com/blogPost/f90d8190-7fd9-452a-b16f-7c2c973b07aa/how-does-the-key-exchange-in-https-work.md): In this small blog post we will have a look at how HTTPS works. Well, we will look how the cryptographic part works a bit more in detail. The focus is on the Diffie Hellman Key algorithm, an asymmetric key exchange.
- [Introduction to WebApplicationFactory](https://steven-giesel.com/blogPost/cd62475b-2c7d-4ce2-bd97-9670f91ebac8/introduction-to-webapplicationfactory.md): This article will show you what exactly a WebApplicationFactory is and why it is so "mighty" when it comes down to testing. I will highlight some of the properties, which you can leverage to write powerful tests.
- [Infographics Compendium I - Generators, pure functions and more](https://steven-giesel.com/blogPost/3ba2e619-4fb2-4f98-ae20-968fc1fe687c/infographics-compendium-i-generators-pure-functions-and-more.md): Sometimes I publish parts of my infographics I publish on various channels with more explanation. And then sometimes I don't. This time I just put some of my (hopefully self-explanatory) infographics here. Pure functions Generator functions Cost of anonymous types
- [x86 vs x64 in .NET](https://steven-giesel.com/blogPost/392d8179-c02c-4d7d-897d-e6a055c970b9/x86-vs-x64-in-net.md): In this article I will show you what is the difference between x86 (32-bit) vs x64 (64-bit) in the .NET World. What is the impact if you choose on or another.
- [Pattern matching is awesome](https://steven-giesel.com/blogPost/d411dc5c-5618-43b2-9b60-8385e50647a3/pattern-matching-is-awesome.md): Pattern matching, which was introduced in C# 9, is a hell of a beast and does more than you might think. In this small blog post I show you where the magic is and what it does under the hood.
- [How does Pagination work?](https://steven-giesel.com/blogPost/573dc606-f7bc-4e77-bd56-0ebdce11e896/how-does-pagination-work.md): Pagination is a technique to load only smaller chunks of data you make visible to the user. Look at Google web search. You only have a certain amount of shown results even though there are millions. So Google has pages (like in a book) where you can go forth and back. This has multiple advantages: First from a UX point of view you only show a reasonable amount of data to your user. The second benefit is for your API / DB as it only has to load a small page instead of the whole book.
- [Blazor Project Structure](https://steven-giesel.com/blogPost/ada40079-6e97-4497-91b6-c9e7baef8dda/blazor-project-structure.md): Did you ever wonder what is a nice way of structuring your Blazor application? I will show you how I structure my Blazor projects (as well as this very blog). What are the upside in contrast to the "default" structuring you get with the Blazor template.
- [Memory is complicated](https://steven-giesel.com/blogPost/fee60a27-b1c4-491d-a2f1-3371db73ffac/memory-is-complicated.md): This is a small story about how memory operates in your .NET application. Well not only .NET but how memory does or does not get allocated. We will see how a 1 Gigabyte big array is only a few megabytes big to some extend. Furthermore I will discuss working set and committed memory.
- [ASP.NET Core - Why async await is useful](https://steven-giesel.com/blogPost/b925c8c1-03ba-4eb6-9b81-f09df56e0158/aspnet-core-why-async-await-is-useful.md): Did you ever wonder why you "should" use async and await in your ASP.NET Core applications? Most probably, you heard something about performance. And there is some truth to it, but not in the way you might think. So let's discuss this with smaller examples.
- [LINQ explained with sketches - the eBook](https://steven-giesel.com/blogPost/8d12d9ef-c4e6-439c-9f88-46825cf35576/linq-explained-with-sketches-the-ebook.md): After covering and collecting multiple parts of LINQ explained with sketches I bundled them all together in a small booklet with more explanation and code samples. Therefore I present: LINQ explained with sketches - the eBook. Over 30 pages with smaller explanations and more LINQ operations than in my last post. Litte Bonus: There are interactive links with smaller examples to fiddle around with.
- [EF7 - Bulk updates and Bulk deletes](https://steven-giesel.com/blogPost/09dd41f9-a0ca-497b-90db-19a89b68b8a0/ef7-bulk-updates-and-bulk-deletes.md): Finally the long awaited bulk update and bulk delete feature is heading towards Entity Framework 7. So we will have a look how to use it and what might be some limitations. Also I will have a quick look at the performance aspect, because this was the main driver for that feature.
- [NDepend](https://steven-giesel.com/blogPost/2448d93b-8309-4d4b-be9c-b87aa938dade/ndepend.md): NDepend is a static analysis tool for .NET managed code. The tool proposes a large number features, from dependency visualization to Quality Gates and Smart Technical Debt Estimation. For that reasons the community refers to it as the "Swiss Army Knife" for .NET Developers. So let's check if that descriptionI shamelessly stole from Wikipedia checks out and what we can do with that tool.
- [LINQ explained with sketches](https://steven-giesel.com/blogPost/d65c5411-a69b-489f-b73f-18ce0ed8678d/linq-explained-with-sketches.md): Often times it is easier to have a nice illustration at hand, which explains you things the easy way. So let's do this for a lot of LINQ operations like Where, Select and friends. Of course a small explanation will be attached as well.
- [Mediator Pattern - CQRS with MediatR](https://steven-giesel.com/blogPost/064ca62a-b384-45da-9212-4c3840e5ba9c/mediator-pattern-cqrs-with-mediatr.md): The famous mediator pattern. Used so often especially in combination with CQRS. If you know how to order food at a restaurant then you already halfway there to understand how the CQRS pattern works. I promised it is not that difficult 😉 In this article I will show how the mediator pattern itself works, what CQRS is and its advantages. For that we will write a small application, which demonstrates how to use the pattern and what we gain from using it.
- [Logging Source Code Generators](https://steven-giesel.com/blogPost/48697958-4aee-474a-8920-e266d1d7b8fa/logging-source-code-generators.md): Since .NET6 we have the possibility to define an easy way of logging common statements: Meet Compile-time logging source generators. This article will show why we have them and how to use them. Of course a smaller benchmark will also follow.
- [Git-Flow, GitHub-Flow, Gitlab-Flow and Trunk Based Development explained](https://steven-giesel.com/blogPost/ff50f268-c0bf-44d8-a5b8-41554ab50ba8/gitflow-githubflow-gitlabflow-and-trunk-based-development-explained.md): There are plenty of models how to do your branching in git. All of them are viable approaches with their respective pros and cons. So let's have a look at those branching strategies and where they are great and where they are falling off. So let's deep dive into: Git-Flow, GitHub-Flow, Gitlab-Flow, Trunk Based Development.
- [Blazor Client - Loading Screen](https://steven-giesel.com/blogPost/6dc1be8f-159c-45fb-90c3-7ec87bfd7e3b/blazor-client-loading-screen.md): If you are using Blazor WebAssembly aka client-side Blazor you are faced with an issue: The .NET runtime including your assemblies has to be downloaded first. We are taking about some megabytes as the initial load. Depending on the connection of your client there is a time where basically nothing happens. The default template just has a simple "Loading..." text. So let's change that.
- [How does git work?](https://steven-giesel.com/blogPost/327faa1b-3802-4e48-bf39-8b06590da57b/how-does-git-work.md): In this blog post I will show you how git works. Or better we will see how git works on the example of some of the commands. Are you confused about origin, remote, rebase or merge? You see stuff like origin/main and origin main and just question marks appear? Say no more!
- [Abstract class vs interface](https://steven-giesel.com/blogPost/3992a289-4cc9-460c-b484-0cc137cccafa/abstract-class-vs-interface.md): In C# we have abstract classes and we also have interfaces. Both seem very similiar but they are fundamentally different concepts. Therefore let's discover what the difference is, what the overlap is and when to use what.
- [SOLID Principles in C#](https://steven-giesel.com/blogPost/a252f2da-1ae8-4449-9b5f-43657308eabb/solid-principles-in-c.md): SOLID principles is one of those words/phrases you hear so often about. Also one of those things you most often get asked by your recruiter in a technical assessment. So let us dissect why Uncle Bob formulated them and how they contribute to "Clean Code".
- [C# vNext - What could come](https://steven-giesel.com/blogPost/d502edb0-331a-4041-b491-b4a907ddcc1e/c-vnext-what-could-come.md): C# 11 is in front of our doorsteps. A lot of the features are know, so let us have a look at the future. We will discover some features which could be included in C# 12 or later. Base for this is the csharplang-repository. So let's discover brand new features and how they could help us in our everyday life. We will see things like: Compound assignments in object initializer Discriminated unions semi-auto properties aka field ConfigureAwait(false) on assembly level Exponentiation operator
- [Central nuget store for your UNO Platform App](https://steven-giesel.com/blogPost/be9722bb-3077-401f-b88d-7393e7afe880/central-nuget-store-for-your-uno-platform-app.md): With the newest UNO Platform update to .NET 6 we can leverage some cool things to simplify our dependency management. We combine .NET 6 with the new feature called Directory.Build.props to make that work.
- [When does Blazor (not) render?](https://steven-giesel.com/blogPost/4fd1ba1d-f244-460e-8de4-06f2cc9c19cb/when-does-blazor-not-render.md): This blog post whill shed some light on when Blazor renders your content. Of course there are obvious candidates, but there are also some things to be aware about.
- [Wrap Event based functions into awaitable Tasks - Meet TaskCompletionSource](https://steven-giesel.com/blogPost/9ad214ff-1f32-4ed0-a5ac-1b996e1e9a68/wrap-event-based-functions-into-awaitable-tasks-meet-taskcompletionsource.md): You might have code where an object offers you an event to notify you when a specific operation is done. But event's can be tricky to use, especially when you want to have a continuous flow in your application. That is where TaskCompletionSource comes into play. We can "transform" an event based function into something which is await-able from the outside world via the await keyword.
- [goto in action - The exception from the rule](https://steven-giesel.com/blogPost/a1de0393-e0f9-491e-8c26-8ec34da60d16/goto-in-action-the-exception-from-the-rule.md): A lot of developers will say never use goto. This keyword is bad as it promotes spaghetti code. But as so often in live the exception confirms the rules. Let's see where goto can increase the readability and maintainability.
- [What is the difference between C#, .NET, IL and JIT?](https://steven-giesel.com/blogPost/aa23a1c9-8ab2-4b05-9bd2-52624af7b684/what-is-the-difference-between-c-net-il-and-jit.md): When you get started or even if you have quite some knowledge it can be confusing to juggle with those terms. So what is the difference between C# and .NET? And what does it have to do with IL and JIT?
- [Delegate, Action, Func, Lambda expression - What the heck!?](https://steven-giesel.com/blogPost/aa77f7fb-41a7-47d2-8e48-ef9e101cf08e/delegate-action-func-lambda-expression-what-the-heck.md): C# offers a lot of utility especially around the delegate topic. So let's see what exactly a delegate is and how the distinct types like delegate, Action, Func, Predicate, anonymous function,  lambda expressions and MulticastDelegate behave. A lot to digest and discover so let's go.
- [The garbage collector in .NET - Part 2: Compacting](https://steven-giesel.com/blogPost/e0c236dc-40dc-4100-97bc-b68a2ccb5f4f/the-garbage-collector-in-net-part-2-compacting.md): I already made a post about how the Garbage Collector works in .NET and also introduced the topic of Generation slightly. This article will look a bit more in detail into why we have those mechanisms in the first place, including the Large Object Heap.
- [ObjectPool - Rent and return some instances](https://steven-giesel.com/blogPost/389e5983-9726-448d-a693-1f7379165c4d/objectpool-rent-and-return-some-instances.md): Just imagine a car pool: There is a dealer which bought the car and lent's it to you. After a while you will return this car where you got it from. Much like that works an ObjectPool in C#. You can rent an expensive object from the pool and when you are done with it, you just return it. Sounds beautiful, doesn't it? Let's explore the advantages and disadvantages of a ObjectPools and how they work.
- [Blazor with an RSS Feed](https://steven-giesel.com/blogPost/29f1d469-8bfb-422a-8c5b-0bee9c8d6b96/blazor-with-an-rss-feed.md): If you use a public Blazor Server application (like this blog is) and you want to expose an RSS Feed (I know kind of old school) you can perfectly do that with Blazor Server and a little help from a nuget package from Microsoft. Furthermore this guide is not only valid for Blazor but every ASP.NET Core endpoint.
- [How to unit test a RavenDB](https://steven-giesel.com/blogPost/0cbe9770-40e7-43b1-980f-d1d3a8b5203d/how-to-unit-test-a-ravendb.md): RavenDB is a well known open-source document-oriented databse for .NET. And of course we want to test our logic and not only locally while developing, but also our continuous integration pipeline should be able to run our tests. So let's tackle exactly that.
- [The garbage collector in .NET](https://steven-giesel.com/blogPost/01252906-c486-484b-811c-9af43e943c7e/the-garbage-collector-in-net.md): This article will talk about the garbage collector in .NET. Why do we have and need him? And why it is essential to understand the behavior to know what impact on our application he has.
- [Blazor with CancellationToken support](https://steven-giesel.com/blogPost/69051bce-81b6-410c-9b9e-c2a0f1c88371/blazor-with-cancellationtoken-support.md): What happens when a user navigates away and still has a pending request to our server? Or what happens if we have a request which might take forever and wastes our resources? Let's tackle these problems with a CancellationToken.
- [Stop using Finalizers in C#](https://steven-giesel.com/blogPost/3b55d5ac-f62c-4b86-bfa3-62670f614761/stop-using-finalizers-in-c.md): Finalizers (historically referred to as destructors) are in C# since its dawn of time and are used to cleanup resources. But they should not used in every use-case and can harm your applications performance.
- [Tail-Recursion - Explained with the Fibonacci series](https://steven-giesel.com/blogPost/ccdbefd9-2875-49e6-929c-c5081d5b4d27/tailrecursion-explained-with-the-fibonacci-series.md): What is Tail-Recursion? We will discover this "special" form of recursion on the example of the Fibonacci series. Also we will check how much faster it is and why.
- [Why are  sealed classes faster in C#? And should I seal them?](https://steven-giesel.com/blogPost/9e7fbbb6-f82a-4ca6-8f6a-b124afc30d48/why-are-sealed-classes-faster-in-c-and-should-i-seal-them.md): In C# we can add the sealed modifier to a class to indicate that no one is allowed to derive / inherit from that class. Let's have a look at the compiler in certain scenarios what happens if you seal a class.
- [Passing by value or by reference - What is faster?](https://steven-giesel.com/blogPost/d205e99c-e784-49be-a2e6-7f9c44ab890f/passing-by-value-or-by-reference-what-is-faster.md): When we are passing objects around we can do this either via reference or by value.  Which of those two methods is faster? To answer this question we have to dive into a bit of info about what happens exactly when you pass something around and how the other side will receive this.
- [ReadOnlyCollection is not an immutable collection](https://steven-giesel.com/blogPost/c20eb758-a611-4f98-9ddf-b9e2b83fcac9/readonlycollection-is-not-an-immutable-collection.md): In this blog post we discover how we can mutate a ReadOnlyCollection to have more or less entries than its original state. Readonly does not mean it is immutable. Also we will check out the ImmutableArray.
- [Is public const bad?](https://steven-giesel.com/blogPost/bfb3e48e-c18b-40f1-97f8-b4c8d97a0f95/is-public-const-bad.md): Is declaring a number or string as public const considered bad practice? Let's have a look what a const variable means in the first place. Let's find out and also check what are the alternatives.
- [Modal Dialog component with Bootstrap in Blazor](https://steven-giesel.com/blogPost/5fc5b957-d62e-40e6-b0c4-f2a0df5c8aa1/modal-dialog-component-with-bootstrap-in-blazor.md): This short blog post will show you how to utilize Bootstrap to create a small and reuseable ModalDialogComponent.
- [4 Different ways of creating an array](https://steven-giesel.com/blogPost/72f3bada-f6c6-4c06-b6ee-e9ac48cd1c94/4-different-ways-of-creating-an-array.md): In this blog post I will show you 4 different ways of creating an array and how they differ from each other.
- [default(MyStruct) vs new MyStruct() - what is the difference?](https://steven-giesel.com/blogPost/f95934a9-e786-4236-b512-e821f4376feb/defaultmystruct-vs-new-mystruct-what-is-the-difference.md): There are multiple ways to create a new struct, either via var myStruct = default(MyStruct) or via var myStruct = new MyStruct(); . Are there any differences?
- [From Zero to Production - Generate everything with a single button](https://steven-giesel.com/blogPost/5f9e9f0d-2413-4e4b-8e38-9eebe9503e52/from-zero-to-production-generate-everything-with-a-single-button.md): This blog post will show you how to setup, from scratch, your GitHub repository so you can in a matter of a single click: Run tests and build your application Release the application for example to nuget Create a Release on GitHub with Release notes Update the documentation utilizing GitHub Pages and DocFx Therefore we will build a "template" repository you can take as a foundation.
- [struct vs readonly struct vs ref struct vs record struct](https://steven-giesel.com/blogPost/2a52cd8d-b3b2-42e4-87e8-d6dc14147ddb/struct-vs-readonly-struct-vs-ref-struct-vs-record-struct.md): C# knows struct since its down of time. But there are also recent additions like readonly struct, record struct  and ref struct. This article will show what are the differences between those 4.
- [Create a low allocation and faster StringBuilder - Span in Action](https://steven-giesel.com/blogPost/4cada9a7-c462-4133-ad7f-e8b671987896/create-a-low-allocation-and-faster-stringbuilder-span-in-action.md): .NET ships a nice StringBuilder since the dawn of time or at least since the beginning of the framework itself. The intention is simple: If we need to concatenate a lot of strings we can't rely on the + operator as we introduce a lot of unnecessary allocations plus it is slow! That is where the StringBuilder jumps into the picture. Why is that? Why is the StringBuilder better? And can we do better? Spoiler: Yes!
- [Reusable loading Bar Component in Blazor](https://steven-giesel.com/blogPost/d1884385-90de-43a1-ae24-0178495f1484/reusable-loading-bar-component-in-blazor.md): In our Blazor components we often call a repository or web API which takes some time. So it is nice to indicate to an user what the current state is. That is why we will create a small indicator even with steps to indicate how far we are in the progress.
- [UNO Platform - Build a Todo App - Part 5](https://steven-giesel.com/blogPost/2c025ac6-d67f-45ec-a616-009e0285c999/uno-platform-build-a-todo-app-part-5.md): This is the last part of the series (for now 😄). In the last. Two parts are missing: Drag and Drop the items from one lane to another Save and load the state And exactly those two things we will tackle. I also will give a small conclusion of my journey.
- [UNO Platform - Build a Todo App - Part 4](https://steven-giesel.com/blogPost/2d96d970-ef11-48f4-a102-9339fc362a75/uno-platform-build-a-todo-app-part-4.md): In the forth part we will take care of our newly created todo item. Until now we clicked on a button and that's all. Sure we have a nice form where we can enter the basic information, but that is all. The time has come to put our element into the respective swimlane. We will also learn how to add further nuget packages to our project.
- [The Trie - A powerful data structure](https://steven-giesel.com/blogPost/3b5e865d-0c84-4d82-a981-d8fac1772419/the-trie-a-powerful-data-structure.md): A Trie is a common data structure used for example for auto completing words. We will discover how to built our own Trie and check how fast he competes against a "normal" Hashset. Also we will build a TypeAHead input component which automatically offers us some suggestion based on our input. Of course, we will use our newly created Trie.
- [UNO Platform - Build a Todo App - Part 3](https://steven-giesel.com/blogPost/a3179d55-d5be-48ba-b570-ee7d494a8b21/uno-platform-build-a-todo-app-part-3.md): In the third part of our small mini series: "Building an todo app with the Uno Platform" we will dive deeper into creating a modal dialog where we can enter the details of our todo item. We will see how we can import additional Nuget packages and how we can leverage validation.
- [UNO Platform - Build a Todo App - Part 2](https://steven-giesel.com/blogPost/85814db0-3495-492c-8ce1-5c83d708590b/uno-platform-build-a-todo-app-part-2.md): This is the second part of our small mini series, where we build a todo app Kanban style with the UNO Platform. In this episode we are laying some ground work as well as defining all of our requirements we want to achieve. We will slowly start creating our first components and make everything work smoothly together.
- [UNO Platform - Build a Todo App - Part 1](https://steven-giesel.com/blogPost/b2234ada-0978-4c7b-841e-ca6a255247b0/uno-platform-build-a-todo-app-part-1.md): This is the beginning of a mini series shedding some lights on the UNO Platform. The UNO Platform enables us to write code once and run it on a wide range of platforms (Windows, MacOS, Android, Linux, ...). So let's have a look at this. To do so we will create a small Todo App Kanban-style so we can organize our thoughts and work 😉
- [Using SSE in C# on the example of the sum of a list](https://steven-giesel.com/blogPost/d80d9367-3a1f-407f-9bdb-067fae9ea527/using-sse-in-c-on-the-example-of-the-sum-of-a-list.md): SSE stands for Streaming SIMD Extensions. What does that exactly mean and how can we leverage that in our C# code? This blog post will shed some light on this topic. Also we make a small comparison to PLINQ.
- [Decorator Pattern using the example of a cached repository](https://steven-giesel.com/blogPost/35df92c5-d5dd-488b-9b6b-25ed12c0420e/decorator-pattern-using-the-example-of-a-cached-repository.md): The decorator pattern is a common pattern in object oriented languages. It allows us to add behavior to an individual object without changing the object itself. We will exactly that with a repository. We introduce a caching layer via the decorator pattern.
- [RequiredIf - Extend the validation in Blazor](https://steven-giesel.com/blogPost/f6be6a72-1497-4ad5-8197-343966761b77/requiredif-extend-the-validation-in-blazor.md): Just imagine you have your beautiful model in a form. And Blazor is very kind and does validation for you. It is really straight forward because you can annotate your model with some attributes like RequiredAttribute to tell Blazor: "Hey this property has to be set, otherwise the form will not be submitted." But what if you want to have that easy setup with attributes but also want to say to Blazor: "Hey this property has to be set, if the other property is true.\* Well, that does not work out of the box. So let's make it together!
- [Directory.Build.props - Centralize your builds](https://steven-giesel.com/blogPost/f3f46814-06c9-41b7-84fa-09ebb3305ed0/directorybuildprops-centralize-your-builds.md): MSBuild has several extensibility hooks to customize your build and today we discover one which let you centralized repeating aspects of your C# projects. Directory.Build.props
- [DebuggerTypeProxy - Displaying complex states in the debugger](https://steven-giesel.com/blogPost/031f4ec1-1c55-43af-84fe-e987b31b7e0e/debuggertypeproxy-displaying-complex-states-in-the-debugger.md): With the DebuggerTypeProxy we have the possibility to show more complex states. This can be helpful in certain cases where an object for example has a lot of properties.
- [Blazor Performance Tuning - Good practices and advanced use cases](https://steven-giesel.com/blogPost/a8772410-847d-4fe7-ba93-3e03ab7748c0/blazor-performance-tuning-good-practices-and-advanced-use-cases.md): Blazor is a beautiful framework for building SPA's. One advantage is that those SPA's feel like native applications. We do not feel that stuff is necessarily loading. But for that we have to keep our code performant. This guide will highlight some of the techniques to keep your Blazor app running smoothly. We will also cover some more advanced use cases.
- [Heap, Stack, Boxing and Unboxing, Performance ... let's order things!](https://steven-giesel.com/blogPost/9a40d278-9a9f-49fe-bbfd-2d813a58e73e/heap-stack-boxing-and-unboxing-performance-lets-order-things.md): In this article I will shade some lights on some of the most used terms which seems very confusing especially for beginners: heap, stack and boxing and unboxing. Furthermore we will also encounter internet wisdom like: Value types get stored on the stack. Reference types on the heap We discuss why this is wrong and what the hell performance has to do with it?
- [Prerendering Blazor Apps - How does it work / tips and tricks](https://steven-giesel.com/blogPost/aa5a6a5c-7f73-4262-9acb-14b645f79417/prerendering-blazor-apps-how-does-it-work-tips-and-tricks.md): Blazor comes with the option to prerender your webpage on the server. This works for the client-side version as well as the server side version of Blazor. Let's have a look how does it work and what might be some pitfalls and how can we come around those.
- [Enum.Equals - Performance analysis](https://steven-giesel.com/blogPost/0a8eec1a-84a2-4c2e-a083-8c7ccb372a41/enumequals-performance-analysis.md): Did you know that you can spend 100x times longer depending how you compare your enums? Of course we are speaking here in terms of nanoseconds but this story is much more then just numbers. We'll also talk about boxing and unboxing. So let's dive right into it.
- [Lazy load components with Blazor -  Virtualize in Action](https://steven-giesel.com/blogPost/15053589-4dd7-4049-b531-37c02aaccfca/lazy-load-components-with-blazor-virtualize-in-action.md): Since .NET5 we have the ability to "virtualize" a component. But what exactly is that and how do we use it? This blog post will show you a lot of details about the \<Virtualize\> tag.
- [Generator-Function in C# - What does yield do?](https://steven-giesel.com/blogPost/994467f6-2429-4534-ad43-c0777076ab22/generatorfunction-in-c-what-does-yield-do.md): Since the introduction of C# 2.0 we have the yield keyword with in combination with the IEnumerable\<T\> type works as a generator function. We can return elements one by one. But how does that thing work internally? And what does it have to do with async / await?
- [Task vs ValueTask - The what's, when's and how's](https://steven-giesel.com/blogPost/28ed9a4d-c390-46f1-ad83-8fda4747ed1f/task-vs-valuetask-the-whats-whens-and-hows.md): Since .NET Core 2.0 the Type ValueTask. It seems that there is a lot of overlap between Task and ValueTask. So let's have a deeper look into ValueTask. Where should we use it and how should we use it properly? And also: where we should not use is.
- [Lifetime Scope in Blazor Client and Server Apps ](https://steven-giesel.com/blogPost/1548e20a-211b-419b-8a9e-ded05b59a179/lifetime-scope-in-blazor-client-and-server-apps-.md): You probably are well aware of the Lifetime Scope for ASP.NET Core website. There are basically 3 scopes: Transient, Scoped and Singleton. Let's have a look how they differ in Blazor Client and Server.
- [Branch Prediction - How much does an if cost?](https://steven-giesel.com/blogPost/0c84f371-08e3-4a57-bdd7-8b08cb308232/branch-prediction-how-much-does-an-if-cost.md): In the blog post we will look a bit into branch prediction. What is it and how can it impact our code? To explore this we will be Thomas the Signalman, which works at a very busy railroad.
- [ILGPU - Processing Data on your GPU (CUDA / OpenCL in C#)](https://steven-giesel.com/blogPost/9e6b1539-7885-4288-ad39-4ba860f9e8fb/ilgpu-processing-data-on-your-gpu-cuda-opencl-in-c.md): If you ever needed a massive amount of data processed in parallel you might had a look at OpenCL or CUDA. Both are based on a subset of C to describe the program your GPU has to execute. So let's have a look how we can achieve this in the .NET way. Furthermore I'll give you some insights about GPGPU (General-purpose computing on graphics processing units) in general. Also some limitations and big differences to conventional "CPU"-Programming.
- [static abstract interfaces and generic math](https://steven-giesel.com/blogPost/f3de9085-aa03-46c3-99d6-e857bb9ceb6c/static-abstract-interfaces-and-generic-math.md): Besides the big announcements of .NET 6 there are also some smaller features. I want to show case a special one: static abstract interfaces. With this you have ability to extend the contract in that sense, that an implementing class has to provide also static methods. This feature is right now flagged as preview, but you can use it if you want. This also enables generic math operations on an interface level.
- [A better enumeration - Type safe from start to end](https://steven-giesel.com/blogPost/74c47c63-ebf0-44d9-85af-d4e4803a63b4/a-better-enumeration-type-safe-from-start-to-end.md): Enumerations are one of the fundamental value types in C#. enum's are handy if you have a constrained set of allowed values. But the enum type also has a lot of drawbacks. Personally, one major issue for me is that you can't define methods inside the enum. Plus, you can just pass them invalid values and it just works (Todd Howard I'm looking at you). So why not make a lightweight alternative which removes a lot of the shortcomings of an enum?
- [git hook - prefix your commit message with your JIRA ticket](https://steven-giesel.com/blogPost/b104e1f0-f5c5-4be7-9ad4-9eb923bb6603/git-hook-prefix-your-commit-message-with-your-jira-ticket.md): In this short blog post I'll show you how you can automatically prefix your commit messages with the JIRA ticket derived from your branch name.
- [API Versioning in ASP.NET Core made easy](https://steven-giesel.com/blogPost/1cfd1d5b-4980-4c60-9dad-538f5684cafd/api-versioning-in-aspnet-core-made-easy.md): How can we have versioning with a public facing REST API in ASP.NET Core? This blog post will show you the foundation how to setup and configure versioning. Furthermore I will give you some ideas how to structure your code and what kinds of versioning you can do. In the end you should be able to have the same endpoints with multiple versions.
- [git - useful aliases](https://steven-giesel.com/blogPost/467ebf34-df88-4c32-b5e9-a624e3cf8c6f/git-useful-aliases.md): In this article I'll show you some of my most used git aliases which make my everyday work easier and more productive.
- [IEnumerable vs IQueryable - What's the difference](https://steven-giesel.com/blogPost/606cb702-e391-4a26-9ae5-523eeb6196ed/ienumerable-vs-iqueryable-whats-the-difference.md): .NET brings two types which seem very similiar IEnumerable IQueryable What is the difference? Most are familiar with using IQueryable when we want to go to the database and back. But why not using IEnumerable?
- [How to hunt down bugs with git bisect](https://steven-giesel.com/blogPost/c5cc16bd-ece0-4058-b7e7-09e498caae76/how-to-hunt-down-bugs-with-git-bisect.md): This article will show how you can identify the commit a bug was introduced. Sometimes it is hard to track down a bug. Your only chance is to exploratory test your code until you find the code in question. I will show you a way how to do this with git. More specific how to use git bisect
- [How to rebase onto a different branch with git](https://steven-giesel.com/blogPost/ed80f949-d42b-4b30-836d-1867a82a6dc4/how-to-rebase-onto-a-different-branch-with-git.md): We're all been there. You worked on a feature or bug on your branch and after some commits you noticed "Oops, I should have branched from xyz instead of abc". I'll show you an easy way of simply moving your stuff from branch abc to xyz.
- [Tactical Design Patterns in C# - Part 1: Creational](https://steven-giesel.com/blogPost/cd21a3f7-11fc-4d57-9278-3e21b34d030c/tactical-design-patterns-in-c-part-1-creational.md): This guide will give an overview of common design patterns in C#. We'll also have a look what is there advantage and how can we implement them. Let's start with creational design patterns.
- [struct Performance](https://steven-giesel.com/blogPost/073f2a14-ea0f-4241-9729-41ee0f30f90c/struct-performance.md): Let's have a small look into structs and how they work when using Equals and GetHashCode. Plus have a brief look into a new C# 10 feature: readonly record struct.
- [Shorts: foreach on type without IEnumerable](https://steven-giesel.com/blogPost/2685c525-efd4-4621-bf95-259411334f74/shorts-foreach-on-type-without-ienumerable.md): Is it possible to have a foreach loop over a type which does not implement IEnumerable? Yes it is.
- [Task.WhenAny - How to cancel other tasks](https://steven-giesel.com/blogPost/8d80e37d-7329-4d7c-8950-5c943ca0d96e/taskwhenany-how-to-cancel-other-tasks.md): This short post will give an overview how to cancel all remaining tasks once Task.WhenAny finishes. Plus how Task.WhenAny behaves in different circumstances.
- [A story about boxing / unboxing and string interpolation in C#](https://steven-giesel.com/blogPost/94d8b54b-c30d-4bdb-ab95-96769b418e6d/a-story-about-boxing-unboxing-and-string-interpolation-in-c.md): A story about boxing / unboxing and string interpolation in C#. What has string interpolation to do with boxing / unboxing and what's the impact?
- [EF Core 6 - New Features](https://steven-giesel.com/blogPost/1a5d039b-d85c-4a16-a64a-cce5281ff1f8/ef-core-6-new-features.md): EF Core 6 is right in front of our door and it looks very promising. In this blog post I will show what new features are to come.
- [Tutorial Unit and E2E Testing in Blazor - Part 2 Playwright Introduction](https://steven-giesel.com/blogPost/fa2b1601-c724-4d37-915c-a6033e194e7e/tutorial-unit-and-e2e-testing-in-blazor-part-2-playwright-introduction.md): This time we will have a look at end to end testing. For this we are using the Playwright C# library from Microsoft. This is the second part of the series. Go here for Part 1
- [Quickly asked: Should I use unsigned integers (uint, uint8, ...) in C#?](https://steven-giesel.com/blogPost/549c74d3-4589-4237-9919-1ff079c029bb/quickly-asked-should-i-use-unsigned-integers-uint-uint8-in-c.md): Should I use uint as a type in my library / website / program? For example when iterating through an array? I mean that thing can't be smaller than 0!? So let's have a look.
- [Async Await Pitfalls / Guidelines - .NET User Group Zurich Presentation](https://steven-giesel.com/blogPost/e0eec540-24db-471c-b8fb-1df8530911d6/async-await-pitfalls-guidelines-net-user-group-zurich-presentation.md): On 6th of July I had the honor to present some topics about async/await. Mainly: What is asynchronous programming Deadlocks and ConfigureAwait How does the state machine work Pitfalls and general Guidelines ValueTask You'll find all the slides and the whole talk in the blog.
- [Tutorial Unit and E2E Testing in Blazor - Part 1](https://steven-giesel.com/blogPost/a0790df4-ba49-4346-83e7-5c3c651d594e/tutorial-unit-and-e2e-testing-in-blazor-part-1.md): This blog post should give you an easy and good introduction how to unit and end-to-end test your Blazor Application. Furthermore it does not matter if we are running server side or client side aka WebAssembly. The main two libraries we are using is first bUnit for unit-testing and Playwright for end-to-end testing. So let's dive in!
- [Blazor Improvements in .NET 6](https://steven-giesel.com/blogPost/ea0a1a81-5af4-4130-8597-ffe3506f7562/blazor-improvements-in-net-6.md): With .NET6 there is a lot to come what makes ASP.NET Core and especially Blazor better and more usable. In this article I will show some things which will definitely come (like AoT Compilation) and some things which might come (native Drag'n Drop support). Overall I feel .NET6 will be a big release which polishes the .NET Environment. Very looking forward.
- [Upcoming .NET User Forum Zurich / 6th July 2021](https://steven-giesel.com/blogPost/34bb68db-f846-409b-b144-05dd5e4eff54/upcoming-net-user-forum-zurich-6th-july-2021.md): I am looking forward to give a talk about some insights and pitfalls of async / await. I will talk about the differences between asynchronous and parallel programming. Also a brief outlook how the state machine internally works. Feel free to join here: https://www.meetup.com/dotnet-zurich/events/278916769/
- [My first Post](https://steven-giesel.com/blogPost/956f5ca7-fa88-40b5-bfe7-cc53b8e81742/my-first-post.md): Welcome to my blog and my first post In this article I will show you why I created my own blog-software from scratch and why I have a blog in the first place. Short answer: I like to know how to create a blog and I like blazor. Long answer you will find in the post.