How can I scan for generic interfaces?

I am managing different types of products and I am getting their information from different manufacturers' APIs. They share some common properties, so I decided to make the type be generic:

public class Product<T> where T : class, new() {
  public string Name { get; set; } = string.Empty;
  public T ProductInfo { get; set; } = new T();
}

My application will be getting a list of productDTOs whose details I will need to retrieve from different places. I decided to create an interface that each ProductRetriever will implement. I will ask each ProductRetriever if they can retrieve the information. If it can, I will call its Retrieve method.

Since each ProductRetriever will be returning the specific ProductInfo for the Product<T>, I decided to make it a generic interface:

public interface IProductRetriever<TProductInfo> where T : class, new() {
  Task<bool> CanRetrieve(ProductCategoryEnum productCategory);
  Task<Product<TProductInfo>?> Retrieve(ProductDto dto);
}

I've implemented several ProductRetrievers which I've manually called one at a time and they work fine. For example:

var manufacturerOneRetriever = new ManufacturerOneRetriever<Product1>();
if(manufacturerOneRetriever.CanRetrieve(ProductCategoryEnum.Automotive)) {
   var product = manufacturerOneRetriever.Retrieve(productDto);
}

Now, I would like to scan the assembly searching for the classes that implement the IProductRetriever<TProductInfo> and call them.

Before I had the generic interface, I was able to scan the assembly and register the ProductRetrievers with the container:

using IHost host = Host.CreateDefaultBuilder(args)
  .ConfigureServices(services => {
    var iProductRetrievers = typeof(IProductRetriever).Assembly.GetTypes()
      .Where(x => x is { IsAbstract: false, IsClass: true } && x.GetInterface(nameof(IProductRetriever)) == typeof(IProductRetriever));

    foreach (var rule in iProductRetrievers) {
      services.Add(new ServiceDescriptor(typeof(IProductRetriever), rule, ServiceLifetime.Transient));
    }
  })
  .Build();

Now that I have it as a generic interface, I am getting an error in the generic portion of x.GetInterface(nameof(IProductRetriever<>)) in:

.Where(x => x is { IsAbstract: false, IsClass: true } && x.GetInterface(nameof(IProductRetriever<>)) == typeof(IProductRetriever<>))

From the documentation of GetInterface

> Note
>
> For generic interfaces, the name parameter is the mangled name, ending
> with a grave accent (<code>`</code>) and the number of type
> parameters. This is true for both generic interface definitions and
> constructed generic interfaces. For example, to find IExample<T> or
> IExample<string>, search for <code>"IExample`1"</code>.

Unlike typeof, nameof cannot be used with an open generic type like IProductRetriever<>. Even if you pass in a constructed type, it will only evaluate to the simple name of the generic type, without the <code>`1</code> part.

You can either use a string literal, or typeof(IProductRetriever<>).Name instead.

Also note that GetInterface returns a constructed type, with the type parameters filled in, so you can't directly compare it to typeof(IProductRetriever<>). You should get its generic type definition first:

x.GetInterface("IProductRetriever`1").GetGenericTypeDefinition() == typeof(IProductRetriever)

I'm not sure how ServiceDescriptor works, but if it needs a constructed generic type too, you would need to use the return value of GetInterface again. You would pass in

rule.GetType().GetInterface("IProductRetriever`1")