Let’s go, begin with the STARTER KIT !

The database schema in code first

First of all, we will create the database context. No matter what we put inside, it is just to describe the project.

Import Microsoft.EntityFrameworkCore, Microsoft.EntityFrameworkCore.Tools in version 9.0.9

The Client class

namespace Multitenant;

/// <summary>
/// The client entity
/// </summary>
public class Client
{
    /// <summary>
    /// The identifier
    /// </summary>
    public int Id { get; set; }

    /// <summary>
    /// The name
    /// </summary>
    public string Name { get; set; }

    /// <summary>
    /// The birthdate
    /// </summary>
    public DateTime BirthDate { get; set; }
}

The MultitenantContext class (using SQL Server)

You have to import :

• Microsoft.EntityFrameworkCore.SqlServer in version 9.0.9

• Microsoft.Extensions.Configuration.Abstractions in version 9.0.9

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;

namespace Multitenant
{
    public class MultitenantContext : DbContext
    {
        /// <summary>
        /// The clients DbSet
        /// </summary>
        public DbSet<Client> Clients { get; set; }

        private readonly IConfiguration _configuration;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="options">The database context options instance</param>
        /// <param name="configuration">The configuration instance</param>
        public MultitenantContext(DbContextOptions<MultitenantContext> options, IConfiguration configuration)
         : base(options)
        {
            _configuration = configuration;
        }

        /// <inheritdoc />
        protected override void OnConfiguring(DbContextOptionsBuilder options)
        {
            options.UseSqlServer(_configuration.GetConnectionString("Default"));
        }

        /// <inheritdoc />
        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);

            builder.Entity<Client>(b =>
            {
                b.HasKey(x => x.Id);
                b.Property(x => x.Name).IsRequired().HasMaxLength(256);
                b.Property(x => x.BirthDate).IsRequired();
            });
        }
    }
}

The API project

Next is the API project to request data

The ClientsController class

Remove the WeatherForecastController class and WeatherForecast model

using System.Net;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Multitenant.Api.Models;

namespace Multitenant.Api.Controllers
{
    [ApiController]
    public class ClientsController : ControllerBase
    {
        private readonly MultitenantContext _context;
        private readonly ILogger<ClientsController> _logger;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="context">The database context</param>
        /// <param name="logger">The logger instance</param>
        public ClientsController(MultitenantContext context, ILogger<ClientsController> logger)
        {
            _context = context;
            _logger = logger;
        }

        [HttpGet("clients")]
        [ProducesResponseType(typeof(IEnumerable<ClientResource>), (int)HttpStatusCode.OK)]
        [ProducesResponseType((int)HttpStatusCode.NoContent)]
        public async Task<IActionResult> GetAll()
        {
            await _context.Database.MigrateAsync();
            var response = await _context.Clients.ToListAsync();
            var result = response.ConvertAll(x => new ClientResource { Name = x.Name, BirthDate = x.BirthDate });

            if(result.Count > 0)
                return Ok(result);
            return NoContent();
        }

        [HttpGet("clients/{id:int}")]
        [ProducesResponseType(typeof(ClientResource), (int)HttpStatusCode.OK)]
        [ProducesResponseType((int)HttpStatusCode.NotFound)]
        public async Task<IActionResult> GetById(int id)
        {
            await _context.Database.MigrateAsync();
            var client = await _context.Clients.FindAsync(id);
            if (client == null)
            {
                return NotFound();
            }
            var result = new ClientResource { Name = client.Name, BirthDate = client.BirthDate };
            return Ok(result);
        }
    }
}

The ClientResource model

Create a folder Models in the project

namespace Multitenant.Api.Models
{
    /// <summary>
    /// The client resource
    /// </summary>
    public class ClientResource
    {
        /// <summary>
        /// The name
        /// </summary>
        public string Name { get; set; }

        /// <summary>
        /// The birthdate
        /// </summary>
        public DateTime BirthDate { get; set; }
    }
}

The appsettings.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "Default": "Data Source=.;Initial Catalog=Multitenant;Integrated Security=SSPI;Persist Security Info=False;TrustServerCertificate=false;"
  }
}

The multi-tenant scenario

To handle the multi-tenant, try to understand the scenario. On each request, we want to identify the tenant calling the API and request its database to restitute their data.

So, to answer to this scenario, we have to do these steps:

1. Be able to identify the tenant

2. Use the tenant to configure the DbContext connection string to target the right database

The multi-tenant implementation

The interface

First of all, we have to define the tenant interface

namespace Multitenant
{
    /// <summary>
    /// The tenant interface
    /// </summary>
    public interface ITenant
    {
        /// <summary>
        /// The tenant identifier
        /// </summary>
        public Guid TenantId { get; set; }
    }
}

The instance

Now, the implementation

namespace Multitenant;

/// <summary>
/// The tenant implementation
/// </summary>
public class Tenant : ITenant
{
    /// <inheritdoc/>
    public Guid TenantId { get; set; }
}

The dependency injection

Next is the dependency injection, add scoped the ITenant implementation.

using Microsoft.EntityFrameworkCore;

namespace Multitenant.Api
{
    public class Program
    {
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);

            builder.Services.AddDbContext<MultitenantContext>();

            //NOTICE: Configure the ITenant service to be resolved from the X-Tenant-Id header
            builder.Services.AddHttpContextAccessor();
            builder.Services.AddScoped<ITenant>(sp =>
            {
                var tenantIdString = sp.GetRequiredService<IHttpContextAccessor>().HttpContext?.Request.Headers["X-Tenant-Id"];
                return (!string.IsNullOrEmpty(tenantIdString) && Guid.TryParse(tenantIdString, out var tenantId) ? new Tenant { TenantId = tenantId } : null)!;
            });

            builder.Services.AddControllers();
            // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
            builder.Services.AddEndpointsApiExplorer();
            builder.Services.AddSwaggerGen();

            var app = builder.Build();

            // Configure the HTTP request pipeline.
            if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI();
            }

            app.UseHttpsRedirection();

            app.UseAuthorization();

            app.MapControllers();

            app.Run();
        }
    }
}

The connection string prefix or suffix

To be able to address a database per tenant, we have to change the database name in the connection string according to the tenant. To do it, we will pattern the connection string in the configuration file.

I choose SUFFIX but you can change if you want to use PREFIX for sure

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "Default": "Data Source=.;Initial Catalog=Multitenant__Suffix__;Integrated Security=SSPI;Persist Security Info=False;TrustServerCertificate=false;"
  }
}

The database context

Now we have defined the bases, we have to change the database context to mutate per tenant. To do it, we will add the ITenant interface to change the connection string dynamically.

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;

namespace Multitenant
{
    public class MultitenantContext : DbContext
    {
        /// <summary>
        /// The clients DbSet
        /// </summary>
        public DbSet<Client> Clients { get; set; }

        private readonly IConfiguration _configuration;
        private readonly ITenant _tenant;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="options">The database context options instance</param>
        /// <param name="tenant">The tenant instance</param>
        /// <param name="configuration">The configuration instance</param>
        public MultitenantContext(DbContextOptions<MultitenantContext> options, ITenant tenant, IConfiguration configuration)
         : base(options)
        {
            _tenant = tenant;
            _configuration = configuration;
        }

        /// <inheritdoc />
        protected override void OnConfiguring(DbContextOptionsBuilder options)
        {
            var connectionString = _configuration.GetConnectionString("Default")?.Replace("__Suffix__", _tenant?.TenantId.ToString() ?? "default");
            options.UseSqlServer(connectionString);
        }

        /// <inheritdoc />
        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);

            builder.Entity<Client>(b =>
            {
                b.HasKey(x => x.Id);
                b.Property(x => x.Name).IsRequired().HasMaxLength(256);
                b.Property(x => x.BirthDate).IsRequired();
            });
        }
    }
}

The default fallback value is used during the EF design-time and let you generate the default database and generate migrations.

The migrations

To generate migrations, we need to use a special nuget package dedicated to this

• Microsoft.EntityFrameworkCore.Design in version 9.0.9

Import this package in the API project and set it at Startup project

Now, open Package Manager Console, and type :

Add-Migration Init -context MultitenantContext

You will have a new folder Migrations containing the scripts to migrate the database.

The POSTMAN collection

There are multi ways to do the test, I will illustrate one of them with POSTMAN but you can choose what you prefer.

1. Create a new collection by clicking on the New button and choose in the popup Collection

2. Click on Add a request

3. Set the URI and keep the verb on GET. The host can be determined in the Properties/launchSettings.json. Search in profiles, the https. Take the first part of applicationUrl and add /clients

For me, I will have https://localhost:7208/clients

4. Add a header X-tenant-id with the GUID b9af52c6-0edd-4301-91fe-08dd10851075

   

5. Launch the API project

   

Launch the query in Postman by clicking on Send button. Show the result 204 No Content and a new database created

Conclusion

Thanks for reading. Now you know how to create a multi-tenant system with one database per tenant. Enjoy !

Let's Connect!

Hi, I'm Yoann. I work as a full-stack developer, solution architect.

If you enjoyed this article, you might enjoy my other content, too.

Github: yblossier

LinkedIn: /in/yoannblossier

Buy Me A Coffee: A special thank you for your support 🍵

Thank you for joining me today.

Yoann

To solve this situation, you just have to use the Microsoft.AspNetCore.Http.Abstractions package

That’s all folks™ !

Let's Connect!

Hi, I'm Yoann. I work as a full-stack developer, solution architect.

If you enjoyed this article, you might enjoy my other content, too.

Github: yblossier

LinkedIn: /in/yoannblossier

Buy Me A Coffee: A special thank you for your support 🍵

Thank you for joining me today.

Yoann

If you share the library with your favorites colleagues and the haven't the documentation, it is better to include the magic part : INTELLISENSE.

I will show you how to realize the trick.

First, the schema

First of all, we have to create the XML schema which describe our custom configuration section structure. It is preferable to name the schema like ClassnameOfSectionSchema.xsd. In our case, PartnerConfigSectionSchema.xsd.

1. Open the previous project in Visual Studio

2. In the library, add a new XML Schema

1. Press F7 to edit the xml code of the schema

2. Copy/Paste the code below and replace the original code in the newly created schema

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="PartnerConfigSectionSchema" targetNamespace="http://tempuri.org/PartnerConfigSectionSchema.xsd" elementFormDefault="qualified" xmlns="http://tempuri.org/PartnerConfigSectionSchema.xsd" xmlns:mstns="http://tempuri.org/PartnerConfigSectionSchema.xsd"     xmlns:xs="http://www.w3.org/2001/XMLSchema">     
    <xs:complexType name="partnerConfig_T">     
        <xs:choice minOccurs="0" maxOccurs="unbounded">       
            <xs:element minOccurs="0" name="partner">
                <xs:complexType>
                    <xs:choice minOccurs="0" maxOccurs="unbounded">
                        <xs:element name="add">
                            <xs:complexType>
                                <xs:attribute name="key" type="xs:string" use="optional"/>
                                <xs:attribute name="value" type="xs:string" use="optional"/>
                                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
                               </xs:complexType>            
                        </xs:element>
                        <xs:element name="remove">
                            <xs:complexType>                 
                                <xs:attribute name="key" type="xs:string" use="optional"/>      
                                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>       
                             </xs:complexType>
                        </xs:element>
                        <xs:element name="clear">
                            <xs:complexType>
                                <!--tag is empty-->                 
                                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>               
                            </xs:complexType>
                        </xs:element>
                    </xs:choice>
                    <xs:attribute name="Name" use="required" type="xs:string">
                        <xs:annotation>               
                            <xs:documentation>The unique name of the partner</xs:documentation>
                        </xs:annotation>
                    </xs:attribute>
                    <xs:attribute name="Enabled" use="optional" default="false">
                        <xs:annotation>
                            <xs:documentation>Set to true to enabled the partner</xs:documentation>
                        </xs:annotation>
                    </xs:attribute>
                    <xs:attribute name="ClientId" use="optional" type="xs:string">
                        <xs:annotation>
                            <xs:documentation>The client ID of the account to use for the partner's service(s)</xs:documentation>
                        </xs:annotation>
                    </xs:attribute>
                    <xs:attribute name="ClientSecret" use="optional" type="xs:string">
                        <xs:annotation>               <xs:documentation>The client secret of the account to use for the partner's service(s)</xs:documentation>
                        </xs:annotation>
                    </xs:attribute>
                    <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
                </xs:complexType>
            </xs:element>
        </xs:choice>
        <xs:attribute name="configSource" type="xs:string" use="optional"/>
        <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
    </xs:complexType>
    <xs:element name="partnerConfig" type="partnerConfig_T"/>
</xs:schema>

Ok sir ! Copy/paste is magic, but can you explain more ?

Yes, I can ! Let me explain each part of the schema to let you understand well the role of each one.

Explanations

Header

<?xml version="1.0" encoding="utf-8"?>
<xs:schema id="PartnerConfigSectionSchema" targetNamespace="http://tempuri.org/PartnerConfigSectionSchema.xsd" elementFormDefault="qualified" xmlns="http://tempuri.org/PartnerConfigSectionSchema.xsd" xmlns:mstns="http://tempuri.org/PartnerConfigSectionSchema.xsd" xmlns:xs="http://www.w3.org/2001/XMLSchema">

This part is the header of the schema where you can found the identifier in the property id.

The collection

<xs:complexType name="partnerConfig_T">     
    <xs:choice minOccurs="0" maxOccurs="unbounded">       
        <xs:element minOccurs="0" name="partner">
            <xs:complexType>
                <xs:choice minOccurs="0" maxOccurs="unbounded">
                    <xs:element name="add">
                        <xs:complexType>
                            <xs:attribute name="key" type="xs:string" use="optional"/>
                            <xs:attribute name="value" type="xs:string" use="optional"/>
                            <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
                               </xs:complexType>            
                        </xs:element>
                    <xs:element name="remove">
                        <xs:complexType>                 
                                <xs:attribute name="key" type="xs:string" use="optional"/>      
                                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>       
                             </xs:complexType>
                    </xs:element>
                    <xs:element name="clear">
                        <xs:complexType>
                            <!--tag is empty-->                 
                                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>               
                            </xs:complexType>
                    </xs:element>
                </xs:choice>
                <xs:attribute name="Name" use="required" type="xs:string">
                    <xs:annotation>               
                            <xs:documentation>The unique name of the partner</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="Enabled" use="optional" default="false">
                    <xs:annotation>
                        <xs:documentation>Set to true to enabled the partner</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="ClientId" use="optional" type="xs:string">
                    <xs:annotation>
                        <xs:documentation>The client ID of the account to use for the partner's service(s)</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="ClientSecret" use="optional" type="xs:string">
                    <xs:annotation>               <xs:documentation>The client secret of the account to use for the partner's service(s)</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
            </xs:complexType>
        </xs:element>
    </xs:choice>
    <xs:attribute name="configSource" type="xs:string" use="optional"/>
    <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
</xs:complexType>

The big piece of the schema which detailed the structure of our custom section.

A. Let's start with the condensed view of the section :

<xs:complexType name="partnerConfig_T">     
    <xs:choice minOccurs="0" maxOccurs="unbounded">       
        ...
    </xs:choice>
    <xs:attribute name="configSource" type="xs:string" use="optional"/>
    <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
</xs:complexType>

We retrieve here :

• xs:choice which details the content of the section

• An attribute called configSource. It is a native attribute let use an external configuration source file instead writing into the web.config

• xs:anyAttribute to indicate many other undeclared attribute can exists on the section element.

B. Continue with the content part :

<xs:complexType name="partnerConfig_T">     
    <xs:choice minOccurs="0" maxOccurs="unbounded">       
        <xs:element minOccurs="0" name="partner">
            <xs:complexType>
                <xs:choice minOccurs="0" maxOccurs="unbounded">
                    <xs:element name="add">
                        <xs:complexType>
                            <xs:attribute name="key" type="xs:string" use="optional"/>
                            <xs:attribute name="value" type="xs:string" use="optional"/>
                            <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
                               </xs:complexType>            
                        </xs:element>
                    <xs:element name="remove">
                        <xs:complexType>                 
                                <xs:attribute name="key" type="xs:string" use="optional"/>      
                                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>       
                             </xs:complexType>
                    </xs:element>
                    <xs:element name="clear">
                        <xs:complexType>
                            <!--tag is empty-->                 
                                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>               
                            </xs:complexType>
                    </xs:element>
                </xs:choice>
                <xs:attribute name="Name" use="required" type="xs:string">
                    <xs:annotation>               
                            <xs:documentation>The unique name of the partner</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="Enabled" use="optional" default="false">
                    <xs:annotation>
                        <xs:documentation>Set to true to enabled the partner</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="ClientId" use="optional" type="xs:string">
                    <xs:annotation>
                        <xs:documentation>The client ID of the account to use for the partner's service(s)</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:attribute name="ClientSecret" use="optional" type="xs:string">
                    <xs:annotation>               <xs:documentation>The client secret of the account to use for the partner's service(s)</xs:documentation>
                    </xs:annotation>
                </xs:attribute>
                <xs:anyAttribute namespace="http://schemas.microsoft.com/XML-Document-Transform" processContents="strict"/>
            </xs:complexType>
        </xs:element>
    </xs:choice>
    ...
</xs:complexType>

We retrieve here an element partner which is defined by a complex type

<xs:complexType name="partnerConfig_T">     
    <xs:choice minOccurs="0" maxOccurs="unbounded">       
        <xs:element minOccurs="0" name="partner">
            <xs:complexType>
                ...
            </xs:complexType>
        </xs:element>
    </xs:choice>
    ...
</xs:complexType>

The complex contains multiple parts I will detailed below :

1. The collection verbs to manipulate parameters :

   • add: To add a new element

   • remove: To remove a new element

   • clean: To remove all the element

2. The attributes you can retrieve on the partner element :

   • Name: The name of the partner, marked as required

   • Enabled: The flag indicating if the partner element is enabled or not

   • ClientId: The client identifier for the partner API

   • ClientSecret: The client secret for the partner API

Usage

Now we have the schema defined. I will show you how to use it to add intellisense in the web.config.

1. Open the ASP.Net WebForms website with Visual Studio

2. Open the web.config file

3. On the Properties panel, expand the property Schemas by clicking on the ...

1. Click on Add and retrieve your .xsd file to add it in the list

2. Now you have the intellisense for the partner section directly when you type.

Now, no excuse to help your colleagues, go for it 😎.

Resources

Please find the project illustrating this article on my Github, here.

Let's Connect!

Hi, I'm Yoann. I work as a full-stack developer, solution architect.

If you enjoyed this article, you might enjoy my other content, too.

Github:yblossier

LinkedIn:/in/yoannblossier

Buy Me A Coffee:A special thank you for your support🍵

Thank you for joining me today.

Yoann

Having a custom configuration section in a configuration file is the best approach when that configuration involves a business need, a connection to a partner, a service, or something similar. But how exactly do you go about creating your own configuration section with its own properties?

As you'll see, it's actually pretty straightforward, and it's surprising we haven't done it before 😉.

The simple section

The most simple configuration section is certainly the one you already use through the existing one AppSettings. Now lets see how to create a similar one.

1. Create a new library project in Visual Studio here called MyLibrary

2. Create a new class here called MyCustomSection

using System.Configuration;

namespace MyLibrary
{
    public class MyCustomSection : ConfigurationSection 
    { 
        public static MyCustomSection GetConfig()
        {
            return (MyCustomSection)ConfigurationManager.GetSection(SectionName) ?? new MyCustomSection();
        }

        /// <summary>
        /// The string name of the section in the configuration file as defined in its XML schema
        /// </summary>
        public const string SectionName = "mySection";

        [System.Configuration.ConfigurationProperty("", IsDefaultCollection = true, IsRequired = false)]
        [ConfigurationCollection(typeof(KeyValueConfigurationCollection), AddItemName = "add")]
        public KeyValueConfigurationCollection Settings { 
            get { 
                var o = this[""];
                return o as KeyValueConfigurationCollection;
            } 
        }
    }
}

This class lets us use a new configuration section after previously declared in the head of the web.config.

1. Create a new ASP.Net WebForms project in Visual Studio

2. Add your library in references

3. Edit the web.config as below

<configuration>
    <configSections>
        <section name="mySection" type="MyLibrary.MyCustomSection, MyLibrary" requirePermission="false"/>
    </configSections>
    <mySection>
        <add key="param1" value="value1"/>
        <add key="param2" value="value2"/>
    </mySection>
</configuration>

The complex section

Now, since the definition of "complex" really depends on you and what you need, I'll cover a bit of everything here. Of course, it might not cover your specific case, but hey, everyone needs to put in some effort, right? 😎

I want to create a new section to handle the multiple parameter we can have to use to connect to an API provider as Google, Facebook, Twitter or our proper business partner.

Please find the class I wrote to illustrate. I will detail just after.

using System.Configuration;

namespace MyLibrary
{
    /// <summary>    
    /// The configuration section class determines the partners configuration elements
    /// </summary>
    public class PartnerConfigSection : ConfigurationSection
    {
        public static PartnerConfigSection GetConfig()
        {
            return (PartnerConfigSection)ConfigurationManager.GetSection(SectionName) ?? new PartnerConfigSection();
        }

        /// <summary>
        /// The string name of the section in the configuration file as defined in its XML schema
        /// </summary>
        public const string SectionName = "partnerConfig";

        /// <summary>
        /// The XML namespace. Used to solve live compilation issue
        /// </summary>
        [ConfigurationProperty("xmlns", IsRequired = false)]
        public string XmlNamespace
        {
            get { return (string)this["xmlns"]; }
            set { this["xmlns"] = value; }
        }

        /// <summary>
        /// The name of partners group
        /// </summary>
        [ConfigurationProperty("name", IsRequired = false)]
        public string Name
        {
            get { return (string)this["name"]; }
            set { this["name"] = value; }
        }

        /// <summary>
        /// The partner configuration to use it(s) service(s)
        /// </summary>
        [ConfigurationProperty("", IsDefaultCollection = true, IsRequired = false)]
        [ConfigurationCollection(typeof(PartnerConfigurationElement), AddItemName = "partner")]
        public PartnerConfigurationCollection Partners
        {
            get { return (PartnerConfigurationCollection)this[""]; }
        }
    }
}

In this class, you'll notice it has a Name property and Partners property as a collection.

There's also something interesting about the XmlNamespace property—it's only there to enable live compilation of the web.config when you use it. If you want proof rather than taking my word for it (which you should always do 😊), try removing it and see what happens 😉.

Now, please found the PartnerConfigurationCollection class that I used for Partners property

using System.Configuration;

namespace MyLibrary
{
    /// <summary>
    /// The configuration element collection contains all definitions
    /// </summary>
    public class PartnerConfigurationCollection : ConfigurationElementCollection
    {
        /// <summary>
        /// Manage the element described by the <paramref name="name"/>
        /// </summary>
        /// <param name="name">The key value of the element to retrieve in the collection</param>
        /// <returns>The configuration element found in the collection</returns>
        public new PartnerConfigurationElement this[string name]
        {
            get { return (PartnerConfigurationElement)this.BaseGet((object)name); }
            set { int index = -1; PartnerConfigurationElement configurationElement = (PartnerConfigurationElement)this.BaseGet((object)name); if (configurationElement != null) { index = this.BaseIndexOf(configurationElement); this.BaseRemoveAt(index); } this.BaseAdd(index, value); }
        }
        /// <summary>
        /// Create a new element in the collection
        /// </summary>
        /// <returns>The newly created element</returns>
        protected override ConfigurationElement CreateNewElement() { return new PartnerConfigurationElement(); }

        /// <summary>
        /// Get the key of the configuration element
        /// </summary>
        /// <param name="element">The configuration element</param>
        /// <returns>The configuration element key</returns>
        protected override object GetElementKey(ConfigurationElement element) { return ((PartnerConfigurationElement)element).Name; }
    }
}

And now, the class of the collection element use above.

using System.Configuration;

namespace MyLibrary
{
    /// <summary>
    /// The configuration element contains the configuration values of partner
    /// </summary>
    public class PartnerConfigurationElement : ConfigurationElement
    {
        /// <summary>
        /// Get or set the name of partner use as unique key
        /// </summary>
        [ConfigurationProperty("Name", IsRequired = true)]
        public string Name
        {
            get { return (string)this["Name"]; }
            set { this["Name"] = value; }
        }

        /// <summary>
        /// Get or set the status of availability of the identity provider
        /// </summary>
        [ConfigurationProperty("Enabled", DefaultValue = "false", IsRequired = false)]
        public bool Enabled
        {
            get { return (bool)this["Enabled"]; }
            set { this["Enabled"] = value; }
        }

        /// <summary>
        /// Get or set the identifier of customer for the partner usage
        /// </summary>
        [ConfigurationProperty("ClientId", IsRequired = false)]
        public string ClientId
        {
            get { return (string)this["ClientId"]; }
            set { this["ClientId"] = value; }
        }

        /// <summary>
        /// Get or set the secret key of customer for the partner usage
        /// </summary>
        [ConfigurationProperty("ClientSecret", IsRequired = false)]
        public string ClientSecret
        {
            get { return (string)this["ClientSecret"]; }
            set { this["ClientSecret"] = value; }
        }

        /// <summary>
        /// Get or set the parameters collection
        /// </summary>
        [ConfigurationProperty("", IsDefaultCollection = true, IsRequired = false)]
        [ConfigurationCollection(typeof(KeyValueConfigurationCollection), AddItemName = "add")]
        public KeyValueConfigurationCollection Parameters
        {
            get { return (KeyValueConfigurationCollection)this[""]; }
            set { this[""] = value; }
        }
    }
}

Now we have the entire definition of the custom configuration section and we can declare in the web.config to use it afterwards.

1. Create a new ASP.Net WebForms project in Visual Studio

2. Add your library in references

3. Edit the web.config as below

<configuration>   
    <configSections>     
        <section name="partnerConfig" type="MyLibrary.PartnerConfigSection, MyLibrary" requirePermission="false"/>
    </configSections>
    <partnerConfig>
        <Partners>
            <partner Name="Partner1" Enabled="true">
                <add key="param1" value="2"/>
                <add key="url" value="https://api.test.com/"/>
            </partner>
            <partner Name="Partner2" ClientId="12345" ClientSecret="azerty" Enabled="true">
                <add key="url" value="https://api.test.com/"/>
            </partner>
        </Partners>
    </partnerConfig>
</configuration>

We have seen the complex view of custom configuration section where we have mixed properties and collection elements in the same definition.

Now, you know how to do it, go for it.

Resources

Please find the project illustrating this article on my Github, here.

Let's Connect!

Hi, I'm Yoann. I work as a full-stack developer, solution architect.

If you enjoyed this article, you might enjoy my other content, too.

Github:yblossier

LinkedIn:/in/yoannblossier

Buy Me A Coffee:A special thank you for your support🍵

Thank you for joining me today.

Yoann

The answer for this question comes with EF Core but Entity Framework in general.

Create the API project

1. Open Visual Studio 2022

2. Create a new project (File / New / Project...)

3. Choose ASP.Net Core Web API (native AOT) to create a minimal API project

1. I let you named and store it wherever you want

2. The project is now created. Now go on the endpoint creation.

Create the list of records

1. Add the nuget package Swashbuckle.AspNetCore to the project.

2. Change the Program method by this one below

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateSlimBuilder(args);

        builder.Services.AddEndpointsApiExplorer();
        builder.Services.AddSwaggerGen();

        builder.Services.ConfigureHttpJsonOptions(options =>
        {
            options.SerializerOptions.TypeInfoResolverChain.Insert(0, AppJsonSerializerContext.Default);
        });

        var app = builder.Build();
        app.UseSwagger();
        app.UseSwaggerUI();

        var sampleTodos = new Todo[] {
            new(1, "Walk the dog"),
            new(2, "Do the dishes", DateOnly.FromDateTime(DateTime.Now)),
            new(3, "Do the laundry", DateOnly.FromDateTime(DateTime.Now.AddDays(1))),
            new(4, "Clean the bathroom"),
            new(5, "Clean the car", DateOnly.FromDateTime(DateTime.Now.AddDays(2))),
            new(6, "Buy vegetables to the grocery", DateOnly.FromDateTime(DateTime.Now.AddDays(1))),
            new(7, "Buy clothes for the wedding", DateOnly.FromDateTime(DateTime.Now.AddDays(15))),
            new(8, "Clean the bedroom"),
            new(9, "Mooing the lawn", DateOnly.FromDateTime(DateTime.Now.AddDays(2))),
            new(10, "Cut the rose bushes", DateOnly.FromDateTime(DateTime.Now.AddDays(2))),
            new(11, "Cut the wood to prepare the winter"),
        };

        var todosApi = app.MapGroup("/todos");
        todosApi.MapGet("/", () => sampleTodos);
        todosApi.MapGet("/{id}", (int id) => sampleTodos.FirstOrDefault(a => a.Id == id) is { } todo ? Results.Ok(todo) : Results.NotFound());

        app.Run();
    }
}

1. Now we have a little collection of records with a Swagger user-interface to display the API

2. In the .csproj, add the JsonSerializerIsReflectionEnabledByDefault tag to let Swagger auto-discover and serialize the objects

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    ...
    <PublishAot>true</PublishAot>
    <JsonSerializerIsReflectionEnabledByDefault>true</JsonSerializerIsReflectionEnabledByDefault>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
  </ItemGroup>

</Project>

1. Open the launchSettings.json file in the Properties folder and change the launchUrl to swagger

   

{
  "$schema": "http://json.schemastore.org/launchsettings.json",
  "profiles": {
    "http": {
      "commandName": "Project",
      "dotnetRunMessages": true,
      "launchBrowser": true,
      "launchUrl": "swagger",
      "applicationUrl": "http://localhost:5241",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    }
  }
}

1. Launch the application

Create the endpoint for paged list of records

In the Program method, under the declared endpoints, add this line.

todosApi.MapGet("/page/{page}", (int page) => sampleTodos.Skip((page - 1) * 5).Take(5).ToArray() is  { } todos ? Results.Ok(todos) : Results.NotFound() );

Wow, only this code !

Yes, let me detailed what we have done here !

1. We add a new endpoint answering to the URL https://<hosturl:port>/todos/page/<pageid>

2. We declare a new function with only the parameter page and where is role is to return the records of the requested page identifier

3. The body of the function, the real subject here :

sampleTodos.Skip((page - 1) * 5).Take(5).ToArray()

Here, we will consider a page will contain only 5 records

Thanks to Entity Framework we can call the function Skip() on the collection sampleTodos to avoid the selection of the X first records of the collection. X is the number of records of the previous page we want to skip.

And just after skipping the first records, we call the function Take() on the result to only get the 5 records of the page. This function will take 5 records at maximum so even a page have less records it will works.

Thank you Entity Framework 😊

1. Launch the application and try yourself with the new endpoint.

Let's Connect!

Hi, I'm Yoann. I work as a full-stack developer, solution architect.

If you enjoyed this article, you might enjoy my other content, too.

Github: yblossier

LinkedIn: /in/yoannblossier

Buy Me A Coffee: A special thank you for your support 🍵

Thank you for joining me today.

Yoann