Prototype pattern best practices in C#: code organization, maintainability tips, shallow vs deep copy strategies, and professional implementation guidelines.
Strategy pattern best practices in C#: code organization, maintainability tips, dependency injection, testing strategies, and professional implementation guidelines.
Prototype design pattern in C#: complete guide with code examples, implementation, and best practices for object cloning and creational design patterns.
Strategy design pattern in C#: complete guide with code examples, implementation, and best practices for flexible algorithm selection.
![Weekly Recap: Microsoft Agent Framework, Semantic Kernel, and Builder Patterns in C# [Feb 2026]](https://devleader-d2f9ggbjfpdqcka7.z01.azurefd.net/media/SquareBanner.webp)
This week covers the Microsoft Agent Framework in C# -- from core AIAgent abstractions to AgentSessions and function tools -- plus Semantic Kernel agents and plugins, Builder pattern deep dives, and GitHub Copilot SDK development. Also included: new videos on software engineering planning and hiring insights.
Master the Factory Method design pattern in C# with code examples, real-world scenarios, and practical guidance for flexible object creation.
Understand the differences between Builder and Fluent Interface patterns in C# with code examples, use cases, and guidance on when to use each pattern.
Master Semantic Kernel in C# with this complete guide. Learn plugins, agents, RAG, and vector stores to build production AI applications with .NET.
Master Builder pattern best practices in C#. Learn code organization strategies, interface design principles, dependency injection integration, and maintainability tips.
Master the Builder design pattern in C# with code examples, real-world scenarios, and implementation guidance for constructing complex objects step by step.
Master Abstract Factory pattern best practices in C#. Learn code organization strategies, interface design principles, dependency injection integration, and maintainability tips.
Learn how to build modular .NET applications using Needlr's plugin system, including IServiceCollectionPlugin, IWebApplicationPlugin, and automatic plugin discovery.
Master the Abstract Factory design pattern in C# with complete code examples, real-world scenarios, and practical implementation guidance for creating families of related objects.
Learn how to use Autofac ComponentRegistryBuilder in ASP.NET Core! We'll see how we can move closer to getting the C# plugin architecture support we want!
Learn how to use Autofac ContainerBuilder in ASP.NET Core to wire up dependency injection. I'll explore what we can and cannot do with this approach!
Learn how to use AutofacServiceProviderFactory in ASP.NET Core for dependency injection! This article explains how to set it up along with the pros and cons.
Want to add API key authentication middleware into your ASP.NET Core application? Check out this article for a simple code example that shows you how!
Check these examples of composition in C#! Learn about composition in object-oriented programming with these simple code examples in C# - perfect for beginners!
See examples of inheritance in C# in this introductory guide to object oriented programming. Learn about when to use inheritance in C# and... when not to!
Learn about plugin architecture in C# to create extensible apps! This article provides examples with code snippets to explain how to start with C# plugins.
See how to use the Extract Method refactoring technique to get started on your journey to being more skilled at refactoring! Check out this C# code example!
Learn how to use Polly in C# to handle faults and retries with ease! Check these 3 code examples showcasing different use cases of Polly in C#!
Learn about efficiently refactoring C# code with these 4 simple techniques! Follow along with code examples that show you how to approach refactoring.
Learn about the CQRS pattern in C# and Clean Architecture for better software development. Get code examples and best practices to improve your skills today!
Explore the integration of C# Clean Architecture with MediatR for maintainable, scalable code! Learn how these work together with C# code examples!
Integrate the Unit of Work Pattern in C# with Clean Architecture for efficient programming. Learn benefits and check out C# code examples to avoid mistakes.
Learn when should code be refactored and the risks and benefits involved in doing so. Discover situations that call for refactoring and ways to minimize risks!
We're done with excuses! No more claims that when dealing with legacy code your changes can't be tested! Check out this strategy to make anything more testable.
Check out this example vertical slice architecture in ASP.NET core! Together we'll look at building a flight booking app using vertical slice architecture.
Learn how code refactoring can simplify code, improve maintainability and readability, enhance efficiency, reduce complexity, and prevent bugs.
So exactly what does refactoring code mean? In this article, we'll walk through what it means to refactor code along with risks and best practices to refactor.
In this article, I'll review the best practices for refactoring legacy code to reduce technical debt, overcome challenges, and how to prioritize refactoring.
Let's analyze pros and cons of rewriting vs refactoring code! Balancing project timelines, resources, and requirements is key for successful execution!
Learn when to refactor code! Discover indicators that code needs refactoring, techniques for refactoring, and best practices for achieving long-term benefits.
What is refactoring? Learn about the art of refactoring and the benefits it can bring to your code. Discover what makes effective refactoring in this article.
Let's explore examples of the Mediator Pattern in C#! See how the Mediator Pattern in C# can promote loose coupling, and increase scalability.
Simplify your code with the remove control flag refactoring technique in C#. See the benefits of removing control flags in this guide to applying the technique.
Check our these examples of the observer pattern in C#! Learn how the observer pattern in C# can simplify the usage of events in your next project!
Discover these top 10 refactoring techniques used by software engineers. Learn to refactor with confidence and make your code cleaner and more maintainable.
Looking for a kickstart to your vertical slice architecture in your next ASP.NET project? Check our this vertical slice project template to get started!
Understand the ideas behind managing technical debt and learn techniques to effectively track and prioritize it. Don't keep ignoring technical debt!
Check this out to learn how to balance technical debt through helpful strategies and best practices for product development. Align with your stakeholders today!
Explore examples of Vertical Slice architecture in C#. Weigh the pros and cons of using Vertical Slice Architecture in C# by following along with some examples.
Vertical slice development can unlock your team's ability to deliver value to customers faster. Read this article for how to incorporate vertical slicing!
Learn how to organize code for vertical slices and use Autofac modules effectively. Discover how this improves code maintainability and enhances collaboration!
Let's implement a vertical slice architecture in C#! We start by defining vertical slice architecture & dive into a C# vertical slice example. Let's dive in!
In this article, we'll see how we can use an ASP.NET Core Blazor RenderFragment alongside plugins to dynamically load HTML into our applications!
Want to have a plugin architecture that supports dynamic loading for Blazor? Follow this tutorial for a Blazor plugin architecture that leverages Autofac!
Like building ASP.NET web applications and want to maximize extensibility? This guide is a how-to on using a plugin architecture in Blazor. Check it out!
While I promote interfaces in C#, it felt necessary to cover the drawbacks of using interfaces in C#. Let's explore the drawbacks to using interfaces in C#!
Learning about Object Oriented Programming? We'll cover what are classes in C# and look at OOP and interfaces in C# to learn about when we should use them!
If you like the sound of flexibility, modularity, and extensibility then the plugin architecture design pattern is something you're going to want to check out!
Want to know how you can deliver value to your end users rapidly? Let's dive into vertical slices and see what high performing engineering teams are using!
Want more flexible, extensible, and testable code? We'll use Autofac net core! What is Autofac? It's a powerful Dependency Injection framework in dotnet!
Let's dive into the plugin architecture design pattern, exploring how it can be leveraged in ASP.NET Core to create more flexible and maintainable applications.
The facade pattern is useful for hiding complexity by moving dependencies behind an API. Let's dive into the facade design pattern in C# in this article!
Modern role playing games (RPGs) can have incredibly complex loot systems. This article introduced a video stream on how to structure cross domain information.
Organizing code into Autofac modules can make maintaining code much easier and improve extensibility! It all starts with the Autofac module class. Check it out!
Looking to get started using dependency injection with Autofac in your projects? Here's a quick primer on what it is and how to get going for your next project.
Are you interested in learning about interfaces in C#? This article explains the idea behind a C# interface by showing examples of interfaces in code.
Code smells are hints that code is taking a potentially nasty turn. What are some common code smells that we should all be looking out for as we're coding?
Code smells are hints that code is taking a potentially nasty turn. What are some common code smells that we should all be looking out for as we're coding?
An example in C# about how to create a singleton with support for dependency injection or inversion of control (IOC).
Leverage interfaces when creating an application to create a clean and robust API. Practice decoupling your code from concrete classes by using interfaces!
