Keyed Services Dependency Injection in C#

Keyed Services Dependency Injection :- Keyed Services Dependency Injection is a Software Design Pattern introduced in .Net 8 with some enhancements in existing Dependency Injection. Exiting Dependency Injection system has some limitations for services registration and multiple implementation for same Interface. for example if you have a Interface and you want to provide multiple implementation for the Interface then it has few limitations in that case , so implementing the multiple implementation for same interface with a Key is a new concept in Keyed Services dependency injection system. These Keys can be a String, Enum or any integer value or any value that is uniquikly indentified in system.

By using Keyed Services Dependency Injection in application we can make our code more managable and readble and it provides better testability to application components.
With Keyed Services Dependency Injection we can easily enables the future changes and applied it in very easy way without more modifications of existing code.
ASP.Net core has a built-in support for Keyed Serives Dependency Injections in .Net 8.

As its name suggest ,it injects the object of a class to outside that class and used in into a dependent class using three types of dependency techniques that is listed below.

• Constructor Dependency Injection :- In this, depedency object/service objcet injects into the Client Class using the Client Class Constructor.
• Property Dependency Injection :- Using the Public Property of the Client Class we can injcet the Dependency/Service Object into the Client Class.
• Method Dependency Injection :- Using the Public Method of the Client Class we can injcet the Dependency/Service Object into the Client Class.

Below are some Implementation Guidlines for Keyed Services Dependency Injection to use into the application that we need to follow.

• Create a Interface and define a method that you want to use for your application business logic for different purposes.
• Create different Service Classes (based on your requirement , in this example I have created two services) and in these service classes implement the Interface and provides the different implementation for methods that are defined into the Interface.
• Register this Service Class and Interface into the Service Collection with any one service method of AddKeyedSinglton/AddKeyedScoped/AddKeyedtransient inside the Program.cs file with a Key Name.
• Create a Constructor in Client Class or inside the Controller where you want to use the dependent objects and inject the dependencies using the [FromKeyedServices("NameofKey")].

Practical Implementation for Keyed Services Dependency Injection :- For implementing the Keyed Services Dependency Injection in application firstly I have create a Interface in which i have declare a common method FileTransferLocation() and it is returning the string message.So before creation of

As shown in below code I have created a Interface named it IFileTransfer that you can find into below code snippet.

                    
 public interface IFileTransfer
    {
        public string FileTransferLocation();
    }          
                

After creating a Interface now I have created two services inside the Services folder, first service is SFTPTransferClass Class and it implements the IFileTransfer Interface into it and provides the implementation of FileTransferLocation() Method into this class and second service is S3BucketTransferClass and it implements the IFileTransfer Interface into it and provides the implementation of FileTransferLocation() Method into this class.

                    
 public class SFTPTransferClass : IFileTransfer
    {
        public string FileTransferLocation()
        {
            return "SFTP Transfer Class";
        }
    }
                 
                

                    
 public class S3BucketTransferClass : IFileTransfer
    {
        public string FileTransferLocation()
        {
            return "S3 Bucket Transfer Class";
        }
    }
                 
                

After creating the Service Classes and Interface we have to register this services into the Program.cs file with any one of the Service Life time methods(like AddKeyedScoped,AddKeyedSingleton,AddKeyedTransient) with Interface and Service class using Key name as depicted into the below code example.

                    
using KeyedServicesDI.Interfaces;
using KeyedServicesDI.Services;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();
builder.Services.AddKeyedScoped("SFTPClass");
builder.Services.AddKeyedScoped("S3BucketClass");
var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run(); 
                 
                

Now we have to use our dependency object into the Client Class or Controller using the below code.

                    
using System.Diagnostics;

namespace KeyedServicesDI.Controllers
{
    public class HomeController : Controller
    {
        private readonly ILogger _logger;

        public HomeController(ILogger logger)
        {
            _logger = logger;
        }

        public IActionResult Index([FromKeyedServices("SFTPClass")] IFileTransfer fileTransfer)
        {
            string msg = fileTransfer.FileTransferLocation();
            ViewBag.MessageSFTP = msg;
            return View();
        }

        public IActionResult Privacy([FromKeyedServices("S3BucketClass")] IFileTransfer fileTransfer)
        {
            string msg = fileTransfer.FileTransferLocation();
            ViewBag.MessageS3Bucket = msg;
            return View();
        }
    }
                 
                

Below is some screen images that I have attached for your reference and with these images you can easily understand the steps that we required for implementing the Dependency Injection and example code also. Make sure to use .Net 8 only. Below is the image for Solution Explorer after adding the folders and required class files and make sure to choose framework version is .Net 8.

Image of Program.cs file using the AddKeyedScoped services.

Image of Controller Class having Constructor Dependency code.