Forem: Engincan VESKE

Most Popular .NET Domain-Driven Design (DDD) Resources: Top 5 GitHub Repositories, Frameworks & Templates in 2025

Engincan VESKE — Wed, 04 Jun 2025 06:20:04 +0000

Domain-Driven Design (DDD) is a software development approach that focuses on creating software that closely models complex business domains. Introduced by Eric Evans, DDD emphasizes collaboration between technical and domain experts to create a shared understanding of the problem space through ubiquitous language, bounded contexts, and rich domain models.

The best way to master Domain-Driven Design in .NET is by exploring real-world implementations through popular GitHub repositories, established frameworks, ready-to-use templates, and comprehensive sample projects. These resources provide practical insights into how DDD principles are applied in production-grade applications, making complex concepts tangible and actionable.

Top 10 Most Popular .NET DDD Resources

1. 🏆 ABP Framework - The Complete DDD Ecosystem

⭐ GitHub Stars: 13,500+ | 🍴 Forks: 3,600+

ABP Framework stands out as the most comprehensive Domain-Driven Design resource in the .NET ecosystem, offering everything developers need in one unified platform: a robust framework, extensive sample projects, detailed documentation, ready-to-use templates, and a complete infrastructure for DDD implementation.

What Makes ABP Unique:

Complete DDD Infrastructure: Pre-built implementation of all DDD patterns including aggregates, repositories, domain services, and domain events
Rich Sample Repository: abp-samples contains dozens of real-world examples demonstrating DDD principles
Multiple Templates: Startup templates for various architectures (modular monolith, microservices, layered architecture)
Production-Ready Framework: Used by thousands of enterprise applications worldwide
Learning Resources: Comprehensive tutorials (for modular monolith, microservices, and layered architecture), best practices, and architectural guidance

🔗 Resources:

Main Repository: github.com/abpframework/abp
Sample Projects: github.com/abpframework/abp-samples
Templates: Available via ABP CLI and ABP Studio
eShopOnAbp - A reference DDD project for those who want to build microservice solutions with the ABP Framework.

2. eShopOnContainers - Microsoft's DDD Reference Implementation

⭐ GitHub Stars: 24,500+ | 🍴 Forks: 10,300+

Microsoft's official reference application demonstrating DDD principles in a microservices architecture. This comprehensive sample showcases how to build distributed applications using Domain-Driven Design patterns with .NET and containers.

🔗 Resources:

Main Repository: github.com/dotnet-architecture/eShopOnContainers
Documentation: docs.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns

3. Clean Architecture Solution Template for ASP.NET Core by Jason Taylor

⭐ GitHub Stars: 18,300+ | 🍴 Forks: 3,900+

A popular solution template implementing Clean Architecture principles with DDD patterns. Provides an excellent starting point for new projects with pre-configured layers, CQRS implementation using MediatR, and comprehensive testing strategies.

🔗 Resources:

Project: github.com/jasontaylordev/CleanArchitecture
Documentation: jasontaylor.dev/clean-architecture

4. eShopOnWeb - Simplified DDD Monolith

⭐ GitHub Stars: 10,400+ | 🍴 Forks: 5,700+

Microsoft's monolithic reference application demonstrating DDD implementation in a traditional web application architecture. Perfect for teams transitioning from traditional approaches to Domain-Driven Design principles.

🔗 Resources:

Project: github.com/dotnet-architecture/eShopOnWeb

5. Modular Monolith with DDD

⭐ GitHub Stars: 12,200+ | 🍴 Forks: 1,900+

Shows how to implement DDD in a modular monolithic architecture, bridging the gap between traditional monoliths and microservices while maintaining strong domain boundaries.

🔗 Resources:

Project: modular-monolith-with-ddd

Getting Started with .NET DDD

Begin with ABP Framework for comprehensive understanding and rapid development (also for ecosystem level of understanding)
Study Microsoft's eShopOnContainers for microservices architecture insights
Explore Clean Architecture templates for structural understanding
Examine specialized samples for specific patterns like event sourcing
Join community discussions on GitHub and Stack Overflow

The journey to mastering Domain-Driven Design in .NET becomes significantly easier when you have access to these high-quality resources. Whether you're building your first DDD application or architecting complex enterprise systems, these repositories provide the foundation for success.

MySQL with EF Core 9 in ABP: Avoiding Translation Issues

Engincan VESKE — Fri, 31 Jan 2025 18:04:44 +0000

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

Entity Framework Core 9 introduces several improvements, but if you are using MySQL with EF Core 9 (and using the Pomelo.EntityFrameworkCore.MySql), you need to be aware of a critical issue related to query translation.

The Problem

ABP Framework's MySQL provider (Volo.Abp.EntityFrameworkCore.MySQL) relies on Pomelo.EntityFrameworkCore.MySql NuGet package. However, as of now, the stable 9.0.0 version of this package has not been released. (You can follow the upgrade status from https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql/issues/1841, if you want).

When using EF Core 9 with MySQL in ABP-based projects, you may encounter SQL translation issues. One of the key problems is that certain queries involving parameterized collections fail to translate correctly.

The Solution

To workaround this issue, you must explicitly enable the TranslateParameterizedCollectionsToConstants() option in your EF Core configuration. Without this setting, the provider may not correctly translate certain SQL commands.

How to Apply the Fix

Open the module class of the *.EntityFrameworkCore project and configure the AbpDbContextOptions as follows:

//...

public class MyProjectEntityFrameworkCoreModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {

        //...

        Configure<AbpDbContextOptions>(options =>
        {
            options.UseMySQL(builder =>
            {
                //add the following line 👇
                builder.TranslateParameterizedCollectionsToConstants();
            });
        });

    }
}

Using the TranslateParameterizedCollectionsToConstants option ensures that parameterized collections are translated into constants, preventing SQL translation errors.

Future Updates

The good news is that once Pomelo.EntityFrameworkCore.MySql 9.0.0 is officially released, this setting will become the default. Actually, it's going to be the default starting from v9.0.0-preview.3.efcore.9.0.0 as announced here.

Until then, applying this temporary solution should allow you to use MySQL with EF Core 9 smoothly.

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

References

ABP Suite: Best CRUD Page Generation Tool for .NET

Engincan VESKE — Wed, 14 Feb 2024 09:49:27 +0000

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

In this article, I will list some CRUD page generation/code generation tools for .NET and then we will explore the ABP Suite that empowers .NET developers to generate CRUD pages and is distinguished from other tools by its features and user-friendly UI.

Code/CRUD Page Generation Tools

There are some CRUD page generation tools that you may already know as listed below:

ABP Suite (supports plenty of UI options - MVC, Blazor WASM, Blazor Server, Angular, etc. - also supports mobile options)
Radzen (only supports Blazor & Angular)
CodeSmith Generator
Also, there are a bunch of open-source code generation tools with limited options...

Among these code-generation tools, ABP Suite is in a special place in my opinion. It's not just related to working on it, but also its capabilities, and what it's providing is really noteworthy. Therefore, in the following section, I want to mention what ABP Suite is and some of its capabilities.

If you are looking for a code generation tool that's gonna speed up your business, I highly recommend you to check the ABP Commercial, try its demo, and see all of its capabilities.

ABP Suite

ABP Commercial is a complete web development platform built on open-source ABP Framework.

ABP Suite is a complementary tool to ABP Commercial and allows you to build web pages in a matter of minutes.

ABP Suite allows you to easily create CRUD pages. You just need to define your entity and its properties and let the rest go to ABP Suite for you! ABP Suite generates all the necessary code for your CRUD page in a few seconds. It supports Angular, MVC, and Blazor (both Blazor Server and Blazor WASM) UIs.

Creating A New Solution

You can create a new solution from the ABP Suite UI, by selecting one of the startup templates provided by ABP Commercial.

You can select a template type, project name, output folder where the project will be created, UI Framework as your front-end, mobile option (React Native or MAUI), database provider, database management system (if the database provider is Entity Framework Core), connection string, theme and more...

See the documentation for all other options and their descriptions.

Generating CRUD Pages

When you add an existing project or create a new one, the project will be listed in the "Open Recent" section. Then, you can select the project, and start generating CRUD pages.

ABP Suite provides the following features for code generation:

Let's deep-dive into these features and see them one by one.

Creating One-to-Many & Many-to-Many Relationship

ABP Suite allows you to create one-to-many and many-to-many relationships. You only need to click the Navigations tab and click either the Add navigation connection (n-n) button to establish a many-to-many relationship or the Add navigation property (1-n) button to establish a one-to-many relationship.

When you establish a many-to-many relationship, ABP Suite will do the rest for you and generate a join entity (also join table in the database) and all of the required codes by following DDD principles.

For example, if you establish a many-to-many relationship between the Book and Category entities, then ABP Suite creates the related join table named "BookCategories":

Also, if you selected the Create User Interface option, it creates the related web page for you as in the following figure:

It's the same if you establish a one-to-many relationship. ABP Suite adds the related navigation property to the related entity and generates all related codes for you, including export to excel support, customizable code support, web pages, unit tests, advanced filters, and more according to the enabled options...

Generating CRUD Pages From an Existing Database Table

If you have an existing database table, you can generate the entities using ABP Suite and create a CRUD page based on those entities.

You first need to create an application from ABP Suite or add an existing project. Then, after opening the project in ABP Suite, you can scroll down to the bottom and click the Load Entity From Database button:

A modal will be opened, and then you can specify the connection string for your database, test the connection, and click the Connect button to allow ABP Suite to list all tables for you:

Then, you can uncheck the related properties such as Id, ConcurrencyStamp and others, you can click the "Ok" button.

After that, ABP Suite will auto-fill all related entity metadata for you in the UI, and then you can revise them and by clicking the "Save and generate" button, you can generate the related entity within seconds.

Here is the video that summarizes the process:

Customizable Code Support

ABP Suite allows you to customize the generated code blocks and preserve your custom code changes in the next CRUD Page Generation. It specifies hook points to allow adding custom code blocks. Then, the code written by you to these hook points will be respected and will not be overridden in the next CRUD Page Generation.

To enable custom code support, you should check the Customizable code option in the CRUD Page Generation page (it's selected by default). When you enable the custom code support, you will see some hook points in your application on both the backend and UI side.

On the C# side (backend), you'll be seeing some abstract classes and classes that derive from them (for entities, application services, interfaces, domain services, and so on ...) according to the template that you have created.

You can write your custom code in those classes (with the *.Extended.cs extension) and next time when you need to re-generate the entity, your custom code will not be overridden (only the base abstract classes will be re-generated and your changes on Suite will be respected).

Let me share an example from the documentation:

`IBookRepository.Extended.cs`	`EfCoreBookRepository.Extended.cs`

defining a new method in the `IBookRepository` interface	implementing the method in the `EfCoreBookRepository` class

As can be seen in the example above, if you write your custom code in the *.Extended.cs files, then in the next generation, all of the code written by you, will be preserved and not overridden. Thus, you have an option to customize the generated code, by overriding the related methods and also you can extend the generated codes according to your needs.

For the UI side, ABP Suite provides convenient comment placeholders within pages for MVC, Blazor, and Angular UIs.

For example, in the screenshot above, you can see the example placeholders (hook-points) for MVC/Razor Pages, where you can write your custom code and make customizations on the page.

In addition to these hook points, you can also add new custom hook points and change their places. You can check this documentation to see how it can be done.

For all of the customization tips and directives, please refer to the documentation: https://docs.abp.io/en/commercial/latest/abp-suite/customizing-the-generated-code

Creating Master-Detail (Master/Child) Relationship

ABP Suite allows you to create a master-detail relationship with a few clicks. It generates the necessary code for the master and detail tables, including the foreign key relationship between the two tables.

To establish a master-detail relationship, you can apply the following steps:

Creating the master entity
Creating the child entity and associating it with a master entity

For example, let's assume you want to establish a master/child relationship between the Order and OrderDetail entities, in that case, you first need to create the Order entity and then you can create the OrderDetail entity and specify its entity type as Child like in the following screenshot:

Then, after the code generation, if you run the application, you will see an output as follows:

As you can see, you have a parent data grid and child data-grids for each order record. You can create your orders from this page and add order lines for each order. So, you can manage all of the orders and order lines from a central point and filter them, or export all of the orders to an Excel file and more...

If you want a quick overview of these features (customizable code support, establishing one-to-many and many-to-many relationships, creating master/detail relationships, and more), you can check the ABP Suite Webinar 2024 Demo video from YouTube.

If you are looking for complete instructions and descriptions for ABP Suite, you can check the ABP Suite docs and webinars organized by the core ABP Framework team:

"Take a closer look at the code generation: ABP Suite"

"Explore the potential of code generation: ABP Suite".

Other Features

ABP Suite's features are not limited to the features described in the previous sections. It provides so many features, that it makes it impossible to mention all of them, but here are some of the other features:

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

Conclusion

In conclusion, ABP Suite is a game-changer in the realm of application development. Its modular design (comes from ABP Framework), powerful code generation, and support for modern frontend frameworks make it a go-to choice for developers looking to build scalable and feature-rich applications. Whether you are working on a small project or a large enterprise application, ABP Suite provides the tools you need to succeed in your development endeavors.

Usage of Consul in .NET Core - Configuration Management

Engincan VESKE — Sat, 30 Oct 2021 16:11:31 +0000

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

Hello everyone,

In this article, I would like to talk about the Consul tool, which enables us to change/manage our settings on the .NET Core side from a central point, via the UI. Firstly, let's start by talking about what Consul is and what advantages does it provide for us.

What is Consul?

Before talking about what Consul is and the advantages/conveniences it provides for us, in an application; Let's review the resources where we can keep our application-based settings.

Let's have a look at where we can store/keep application-based settings:

1-) In application settings (appsettings.json, appsettings.development.json, environment variables etc.),
2-) In the database,
3-) In a key-value store (Consul comes into play here)

Keeping our relevant data in a file like appsettings.json will not cause any performance disadvantage for us. By simply storing the relevant settings as key-values in the relevant file, we can then perform the operations on the basis of the relevant settings. However, if this is the case, we will not be able to simply manage these settings via the UI. In addition, each developer will have to commit this in the relevant setting change.
When we look at the database option, there is a loss of performance since the relevant setting will be fetched from the database each time and an action will be taken accordingly. Of course, at this point, this performance problem can be improved by using the cache mechanism, but we can say that the effort we spend will increase because if a setting is changed, the cache invalidation situation will come into play.
If we consider the option of keeping our settings in a key-value store, which is another method, we can use the pub/sub pattern to load the relevant changes in the application runtime, and in this way, we can dynamically access the relevant settings for each change without having to deal with cache invalidation.

When we evaluate our options here, we can see that keeping our settings in the key-value store makes our work easier and allows us to provide a centralized settings management. At this point, we can use Consul as the key-value store option.

Consul acts as a distributed key-value store for us, a choice where we can keep our application settings in a central place and use them easily within the application.

Usage of Consul in .NET Core Application

After talking about what Consul is and what advantages it provides for us, we can now create a simple .NET Core Web API project and move on to its use.

You can find the source code of the application at https://github.com/EngincanV/Asp.Net-Core-Consul-Demo.

Firstly, let's run our Consul application on Docker. We can use the following command for this.

docker run -d -p 8500:8500 -p 8600:8600/udp --name=my-consul consul agent -server -ui -node=server-1 -bootstrap-expect=1 -client=0.0.0.0

After running this command, if you navigate to http://localhost:8500, you should see an image similar to the photo below.

Now that we are running our Consul application via Docker, we can create a simple Web API project. If you want to create it via CLI, you can create a Web API project with the following command.

dotnet new webapi --name Consul.Demo --output .

After creating our application, we need to install the Consul package on our application via Nuget. You can add the relevant package to the Web API project with the following command via the CLI.

dotnet add package Consul --version 1.6.10.3

After adding the relevant package, we now need to make the necessary configurations so that we can use the settings we defined on Consul (which we will define in the next step) in our application.

Firstly, let's create a folder named Extensions and add the following codes by creating a class named ServiceCollectionExtensions.cs in this folder.

namespace Consul.Demo.Extensions
{
    public static class ServiceCollectionExtensions
    {
        public static IServiceCollection AddConsulConfig(this IServiceCollection services, string configKey)
        {
            if(services == null)
            {
                throw new ArgumentNullException(nameof(services));
            }

            services.AddSingleton<IConsulClient>(consul => new ConsulClient(consulConfig =>
            {
                consulConfig.Address = new Uri(configKey);
            }));

            return services;
        }
    }
}

Then, Startup.cs or Program.cs (Since I created the project with .NET 6, there is no Startup.cs class and all settings are provided through this class, if you have created a .NET 6 project, you can add the following codes to this class), let's open our file and provide the relevant configurations.

using Consul.Demo.Extensions;

var builder = WebApplication.CreateBuilder(args);

var consulHost = "http://localhost:8500";
builder.Services.AddConsulConfig(configKey: consulHost);
builder.Services.AddControllers();

//...

After completing the relevant configuration, let's create a simple provider class and write a method that returns the type of value we want according to the key value we passed to the method. For this, let's create a folder named Helpers, add a class called ConsulKeyValueProvider and fill this class with the following codes.

using System.Text;
using System.Text.Json;

namespace Consul.Demo.Helpers
{
    public static class ConsulKeyValueProvider
    {
        public static async Task<T?> GetValueAsync<T>(string key)
        {
            using (var client = new ConsulClient())
            {
                var getPair = await client.KV.Get(key);

                if (getPair?.Response == null)
                {
                    return default(T);
                }

                var value = Encoding.UTF8.GetString(getPair.Response.Value, 0, getPair.Response.Value.Length);

                return JsonSerializer.Deserialize<T>(value);
            }
        }
    }
}

Here, thanks to the ConsulClient class, we have created a simple method by communicating with the Consul (working at http://localhost:8500) where we can get the value we want according to the key.
Let's navigate to http://localhost:8500, select the Key/Value section, and then create a key-value from there and test our method.

Here I created a key named ConsulDemoKey and assigned several values (IsEnabled, ShowMessage and Message) as in the photo above. Now, in my .NET Core application, I need to be able to reach these values by giving the ConsulDemoKey key to the helper method that we've created in the previous step. To test this in practice, let's open the WeatherForecastController class under the Controllers folder and update the Get method as follows.

using Consul.Demo.Helpers;
using Consul.Demo.Models;
using Microsoft.AspNetCore.Mvc;

namespace Consul.Demo.Controllers;

[ApiController]
[Route("[controller]")]
public class WeatherForecastController : ControllerBase
{
    [HttpGet(Name = "GetWeatherForecast")]
    public async Task<ActionResult> Get()
    {
        var consulDemoKey = await ConsulKeyValueProvider.GetValueAsync<ConsulDemoKey>(key: "ConsulDemoKey");

        if(consulDemoKey != null && consulDemoKey.IsEnabled)
        {
            return Ok(consulDemoKey);
        }

        return Ok("ConsulDemoKey is null");
    }
}

If we examine the code here, we can see that there is a class named ConsulDemoKey. While assigning a value in terms of key-value on the Consul, we can create a class to match (map) the relevant values, since we define value as json.
We can define the ConsulDemoKey class under the Models folder as follows.

namespace Consul.Demo.Models
{
    public class ConsulDemoKey
    {
        public bool IsEnabled { get; set; }

        public bool ShowMessage { get; set; }

        public string Message { get; set; }
    }
}

Now that we have completed everything we want to do, we can now run the application and see the result.

When we run our application and send a request to the /WeatherForecast route, the relevant values are read from Consul and printed on the screen as we expected.

Here, without closing our application, if we change a relevant value via Consul (For example: We can change the Message to "Dynamic Configuration with Consul"), we can see that the relevant change is reflected on the screen dynamically.

Thank you for reading my article. See you in my next post.

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

What are OAuth 2.0 and OIDC (OpenID Connect)? Step By Step Authorization Code Flow With Endpoints

Engincan VESKE — Sat, 11 Sep 2021 14:20:24 +0000

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

Hello everyone,

In this article, I would like to talk about OAuth 2.0, which is used as a protocol (industry standard) for Authorization and OIDC (OpenID Connect) which is a top layer of the OAuth 2.0 and used for Authentication.

What are OAuth 2.0 and OIDC? What are they used for?

OAuth 2.0 and OIDC are industry standards used for Authorization and Authentication.

Every day we use mobile or web applications for our works. Defining username and password for each application, getting harder at some point. Some "password management" applications come into place etc.

History

In 2005 Brad Fitzpatrick developed an authentication protocol to remove these difficulties.

The main purpose of this protocol was to enable users to define user credentials to a central system/application (for example, Google) and to enable other applications using this protocol to perform relevant transactions using only the necessary information of the users. And this was done through certificates.

This developed protocol was not an open protocol, and at the same time, it was making the related transactions through certificates. OAuth Discussion Group which was created in 2007, started to create an open authorization protocol. In December 2007, the OAuth protocol was openly made available as v1.0 and in October 2012 it was finalized as OAuth 2.0.

In this way, OAuth 2.0 was filled the missing Authorization part of the OpenID protocol with a token based structure. Instead of certificates, identity-related transactions started to do with tokens.

Then, in 2004 an identity layer called OIDC (OpenID Connect) developed on the OAuth 2.0 Framework was added and thus Authentication processes were defined within a standard.

OAuth 2.0 Structure

In the above picture, you can see the base structure of OAuth 2.0.

In the most basic sense, when we as a user (Resource Owner) want to access our own data, we enter the relevant website (Client) and send a request to the relevant URL. The relevant website communicates with the Authorization Server to query whether we have access to that resource. As a result, the relevant server indicates that we have authorization. We reach the information we want to access as a result that returned by the Resource Server.

The Resource Owner, Client, Authorization Server, and Resource Server are defined as Roles in OAuth 2.0 protocol.

OAuth 2.0 offers different types of Authorization Flows according to different usage conditions and these flows are named as follows.
- Authorization Code Flow
- Implicit Flow
- Resource Owner Password Credential Flow
- Client Credential Flow

Authorization Code Flow is used in Server Side applications and Implicit Flow is used in Browser Based (SPA's) applications.

In these flows, although the basic logic is the same (authorization, token exchange, etc.), the number of steps and methods applied are different. As an example, let's examine the frequently used Authorization Code Flow together with the related endpoints.

Example: OAuth 2.0 - Authorization Code Flow

We can examine this flow in 4 steps:

1-) Authorization Request

If we examine the related request, we can see that we passed a query parameter named "client_id". This "client_id" represents our application defined within the OAuth 2.0 protocol. In other word, it's a value that identifies the relevant application. The "scope" parameter specifies the scope of the relevant authorization. In other words, the user is only allowed to see the relevant information in the resource and profile scope above. User can't access any other part of the application (e.g. delete contact) by using the generated token.
"Redirect_uri" represents the URL where the application we are using will get and use the relevant token.
The most important parameter here, the "response_type" parameter, shows which flow the request will be made with. (“code” for Authorization Code Flow)

2-) Authorization Response

After the Authorization Server ensure that the relevant request is valid and in the correct format as well, it sends a GET request with the Authorization Code to the relevant callback url (redirect_uri) specified in the request.

3-) Token Request

After obtaining the Authorization Code, a token request is made by using the relevant Authorization Code to obtain a Access Token. (Token exchange => Authorization Code ↔ Access Token)

As can be seen in this request, Authorization Code is specified as the grant_type and if this request is successful Authorization Server redirects us to the route specified in the "redirect_uri" parameter.

4-) Token Response

If the "Token Request" we made in the third step is successful, a similar response returns as below and can be used by the Client (the application we want to use).

Now, with this "access_token" the user can access its own data from Resource Server through the Client.
Here, if the "refresh_token" is also returned as a result of the request, when the "access_token" expires, a request can be made to renew the related "access_token" with this token.

OIDC (OpenID Connect) Structure

Simple identity layer on top of the OAuth 2.0 protocol.

OpenID Connect can be thought of as an identity layer added on top of the OAuth 2.0 protocol to enable the OAuth 2.0 protocol to be used for Authentication.

OpenID Connect contains a meta-data document (.well-known/openid-configuration) that defines the information required to login through an application. (Which urls should be used, which scopes it contains, etc.)

If you want to view the relevant metadata document as an example, you can access the Microsoft's OIDC metadata document by navigating to https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration.

As in OAuth 2.0, transactions are performed using flows in OIDC. As an example, let's examine the endpoints of Authorization Code Flow for OIDC as in OAuth 2.0.

Example: OAuth 2.0 - Authorization Code Flow

We can examine this flow in 6 steps:

1-) Authentication Request

If we examine the related endpoint, we can see that a value called openid is passed in the scope section. We can actually think of this as the equivalent of the identity layer concept we used when defining OIDC. With this scope added to the OAuth 2.0 protocol, Authorization Server now handles the relevant request within the scope of OIDC.

2-) Authentication Response

Here, as in OAuth 2.0, a GET request is sent to the callback-url (redirect-uri) with the Authorization Code. In this way, the Client becomes aware of the relevant authorization code.

3-) Token Request

Then, the relevant Client requests a token from the Authorization Server with the "authorization_code" it has obtained. (Token exchange => Authorization Code ↔ Access Token)

4-) Token Response

If we examine the response we can see the "id_token" section.

ID_Token: It can be thought of as an identity card. Contains information about the end user. It is in JWT format. It can be thought of as the add-on that OIDC brings to OAuth 2.0. In this way, the Authentication process can happen.

5-) UserInfo Request - Obtaining End User's Information

The UserInfo endpoint returns information about the logged in user (name, surname, etc.). When the client needs the information of the relevant user, he can obtain the necessary information by using this endpoint. (Note that the relevant user is now authenticated and a request is made to the endpoint using the Bearer Authorization.)

6-) UserInfo Response

If the request that we made in the previous step is successful, the user's information receives.
As another method, the user's relevant information can be accessed by decoding the previously generated "Id_Token" value.

Thanks for reading this article, I hope you've enjoyed it. See you in the next article...

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

Asp.Net Core - Deferred Option Pattern

Engincan VESKE — Tue, 07 Sep 2021 16:57:18 +0000

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com

Hello to everyone,
In this article, I will try to explain how we can define the settings in our applications in a deferred way by using the IConfigureOptions<TOptions> interface.

In an application I am developing, I decided to add the sitemap.xml file, thinking that adding the sitemap.xml file would give good results so that the links of the relevant website would be better indexed and produce more efficient SEO scores. Later on, while I was browsing whether there were packages that I could easily configure the sitemap.xml and robots.txt files to add to the application, I came across a package named Winton.AspNetCore.Seo. Thanks to this package, I was able to add the sitemap.xml file to my application simply by specifying the relevant urls.

Then, by examining the documents of the relevant package, I could simply view the URLs of the relevant website statically on the /sitemap.xml route. While performing this operation,

I created a simple web application and then I started to make the necessary settings by installing the Winton.AspNetCore.Seo package on the relevant web project. First, I defined the appsettings.json file with the links I wanted to appear on the /sitemap.xml route. Likewise, it is possible to make settings in the robots.txt file too.

{
  //...
  "Seo": {
    "Sitemap": {
      "Urls": [
        {
          "Priority": 1,
          "RelativeUrl": "/article/what-is-new-in-csharp"
        },
        {
          "Priority": 1,
          "RelativeUrl": "/article/dotnet-5"
        }
      ]
    },
    "RobotsTxt": {
      "AddSitemapUrl": true
    }
  },
  //...
}

Then I updated the ConfigureServices method in the Startup.cs file as follows. In this way, I applied the process of defining the dependencies (dependency registration) required to be able to use the relevant package.

public class Startup {
  //...
  private IConfiguration Configuration { get; }

  public void ConfigureServices(IServiceCollection services)
  {
    services.AddSeo(Configuration);

    services.AddSeoWithDefaultRobots(options =>
    {
      options.Urls = new List<SitemapUrlOptions>
      {
        new SitemapUrlOptions { Priority = 1, RelativeUrl = "/article/what-is-new-in-csharp" },
        new SitemapUrlOptions { Priority = 1, RelativeUrl = "/article/dotnet-5" }
      };
    });
  }

  //...
}

Later, when I ran the application and navigates to the /sitemap.xml and /robots.txt routes, I saw that the relevant links were listed as defined in appsettings.json.

After performing these operations with a simple configuration, I can address the scenario I want to realize.
What I want to achieve at this point is to get the relevant links by calling the service that returns the relevant links in my application, and to list the relevant links in the /sitemap.xml file thanks to the "Option Pattern" so that search engines can better index the relevant links.
The first thing that comes to my mind is: I need to call the relevant service in the ConfigureServices method, access the IServiceProvider somehow, and call the methods of that service by resolving the relevant service (to use the services), and finally (services.AddSeoWithDefaultRobots(options => { … })) I needed to specify these links as options where I defined the method.

public class Startup {
  public void ConfigureServices(IServiceCollection services)
    {
        //...

        services.AddSeoWithDefaultRobots(  
            options =>
            {
                var scopeFactory = services
                    .BuildServiceProvider()
                    .GetRequiredService<IServiceScopeFactory>();

                using (var scope = scopeFactory.CreateScope())
                {
                    var provider = scope.ServiceProvider;
                    using (var myService = provider.GetRequiredService<MyArticleService>())
                    {
                        options.Urls = myService.GetBlogPostLinksAsync().Result;
                    }
                }
            });

        //...
    }
}

In this case, when we examine the related method, we can see that the ConfigureServices method, whose main purpose is to register the related dependencies to the container, is out of its definition, and also that unnecessary code crowds are formed. At this point, I came to the idea that I should find another solution and perform the relevant Options after Dependency Registration processes are finished (in other words, delayed configuration (referred configuration)).
Later, while researching on this subject, I came across an article from Andrew Lock. When I examined the article in detail, I saw that we encountered the same situation (we came to the same conclusion) even if the scenario we wanted to realize was different, and I encountered the IConfigureOptions interface. When I examined this interface, I saw that it provided the situation I wanted to realize, that is, by injecting the services I wanted, I could simply define the results I obtained for the Options I specified. And I started to the related refactoring business.
For this, I first defined a class called SeoConfiguration and implemented the IConfigureOptions<SeoOptions> interface as follows.


public class SeoConfiguration : IConfigureOptions<SeoOptions>
{
  private readonly IArticleAppService _articleAppService;

  public SeoConfiguration(IArticleAppService articleAppService)
  {
    _articleAppService = articleAppService;
  }

  public void Configure(SeoOptions options)
  {
    var articleUrls = _articleAppService.GetArticleLinksAsync().Result;
    var urls = articleUrls.Select(url => new SitemapUrlOptions
    {
      Priority = 1, 
      RelativeUrl = url
    }).ToList();

    //ilgili değerlerin SeoOptions sınıfına aktarılması
    options.Sitemap.Urls = urls;
    options.RobotsTxt.AddSitemapUrl = true;
  }
}

If you pay attention here, we do not deal with the IServiceProvider interface and resolve the related dependencies. We simply do Constructor Injection and the framework takes care of the rest. When we examine the Configure method, we see that it takes the relevant option (SeoOptions) as a parameter. In this method, we received the relevant urls from our service and assign a value to this option. In this way, we configure the relevant settings.
The last thing we need to do is to inform our application that the value of an Options as deferred configuration of the SeoConfiguration class we have created should be done after the relevant dependency registration processes. For this, we can update our Startup.cs file as follows.

public class Startup {
  //...

  public void ConfigureServices(IServiceCollection services) {
    //...

    services.AddSingleton<IConfigureOptions<SeoOptions>, SeoConfiguration>();           
    services.AddSeoWithDefaultRobots();
  }

  //...
}

Here, we are saying, "Defer the relevant configurations until the SeoOptions class needs to be used, and perform the relevant configurations according to the operations performed in the Configure method on the class I have defined (here SeoConfiguration) when it should be used". Now we can run our application and see the result by navigating to the /sitemap.xml and /robots.txt routes.

As you can see, we are now freed from a great burden by dynamically defining the relevant urls. In addition, thanks to the IConfigureOptions interface, we get rid of the code snippets that we need to define in the ConfigureServices method (first solution).

Thanks for reading this article, I hope you've enjoyed it. See you in the next article...

🛠 Liked this post? I now share all my content on Substack — real-world .NET, AI, and scalable software design.
👉 Subscribe here → engincanveske.substack.com