How to Register Open Generic in .NET Core Dependency Injection

In this post, we’ll explore how to use open generics with dependency injection (DI) in a .NET console application. Open generics are a powerful feature that allows you to create reusable, type-safe services that can work with different types of entities. We’ll walk through a step-by-step example to demonstrate how to set this up.

Step-by-Step Implementation

1. Create a Console Application Project

First, create a new console application project in .NET. You can use the .NET CLI to do this:

dotnet new console -n OpenGenericsExample
cd OpenGenericsExample

2. Install Required Package

To use dependency injection, you’ll need to install the Microsoft.Extensions.DependencyInjection package:

dotnet add package Microsoft.Extensions.DependencyInjection

3. Define the Generic Repository Interface

Create an interface for the generic repository. This will define the contract for our repository operations:

// IRepository.cs
public interface IRepository<T>
    void Add(T entity);
    T GetById(int id);
    IEnumerable<T> GetAll();

4. Implement the Generic Repository

Create a class that implements the generic repository interface. This class will manage a list of entities in memory:

// Repository.cs
using System.Collections.Generic;

public class Repository<T> : IRepository<T>
    private readonly List<T> _storage = new List<T>();

    public void Add(T entity)

    public T GetById(int id)
        // Simplistic implementation for demonstration
        return _storage[id];

    public IEnumerable<T> GetAll()
        return _storage;

5. Define Some Entities

Create a couple of entity classes to use with the repository. These classes represent the data that will be managed by the repository:

// Customer.cs
public class Customer
    public int Id { get; set; }
    public string Name { get; set; }

// Order.cs
public class Order
    public int Id { get; set; }
    public string Product { get; set; }

6. Register Services in the DI Container

Set up the DI container in the Program.cs file. This involves registering the generic repository with the DI container:

// Program.cs
using System;
using Microsoft.Extensions.DependencyInjection;

class Program
    static void Main(string[] args)
        // Set up the DI container
        var serviceProvider = new ServiceCollection()
            .AddScoped(typeof(IRepository<>), typeof(Repository<>))

        // Resolve the repositories
        var customerRepository = serviceProvider.GetService<IRepository<Customer>>();
        var orderRepository = serviceProvider.GetService<IRepository<Order>>();

        // Use the repositories
        var customer = new Customer { Id = 0, Name = "John Doe" };
        var order = new Order { Id = 0, Product = "Laptop" };


        foreach (var cust in customerRepository.GetAll())
            Console.WriteLine($"Id: {cust.Id}, Name: {cust.Name}");

        foreach (var ord in orderRepository.GetAll())
            Console.WriteLine($"Id: {ord.Id}, Product: {ord.Product}");


  1. Generic Repository Interface: The IRepository<T> interface defines the contract for the repository, including methods for adding and retrieving entities.
  2. Generic Repository Implementation: The Repository<T> class implements the repository interface using a list to store entities in memory.
  3. Entities: Customer and Order are example entities that the repository will manage.
  4. Dependency Injection Setup:
    • ServiceCollection is used to set up the DI container.
    • AddScoped(typeof(IRepository<>), typeof(Repository<>)) registers the open generic IRepository<> to resolve to Repository<>.
  5. Using the Repositories:
    • The repositories are resolved from the service provider and used to add and retrieve entities.

Running the Application

Compile and run the application using:

dotnet run

The output should display the added customers and orders, demonstrating that the generic repository works for different entity types.


By following these steps, you’ve learned how to set up and use open generics with dependency injection in a .NET console application. This approach allows you to create flexible and reusable services that can handle different types of entities, making your code more modular and maintainable.

Open generics and dependency injection are powerful tools in the .NET ecosystem, and mastering them will help you write cleaner and more efficient code. Happy coding!

Next Post Previous Post
No Comment
Add Comment
comment url