how to check logic from all existing and future implementation of "ICheck" to get the right content type

I have a interface where I am returning result for a check and this interface has currently 2 implantations but in future it will keeps added.

public interface ICheck
{
    Task<CheckReturn> GetCheckReturn(string fileName);
}

public class ATypeCheck : ICheck
{
    public async Task<CheckReturn> GetCheckReturn(string fileName)
    {
        //logic to check A Type
        //return CheckReturn with right content type
        return await Task.FromResult<CheckReturn>(new CheckReturn { ContentType = "Type A" });
    }
}

public class BTypeCheck : ICheck
{
    public async Task<CheckReturn> GetCheckReturn(string fileName)
    {
        //logic to check A Type
        //return CheckReturn with right content type
        return await Task.FromResult<CheckReturn>(new CheckReturn { ContentType = "Type B" });
    }
}

> // Future CTypeCheck
> // Future DTypeCheck

With below code I am able to do only one check validation, but I need to check all the implementation of ICheck?

static async Task Main(string[] args)
    {
        ATypeCheck check = new ATypeCheck();

        var result = await check.GetCheckReturn("XYZ");
    }

Which design pattern help here & how?

2 Parts to a solution:

Part 1: Code against interfaces

static async Task Main(string[] args)
{
    ICheck checks = new List<ICheck>{ new ATypeCheck(), new BTypeCheck() };
    var results = new List<CheckResult>();
    foreach( var check in checks ) results.Add(await check.GetCheckReturn("XYZ"));

    // TODO handle results 
}

Part 2: Dependency Injection

In production code, you probably will want to detect all implementations of the interface at startup and inject your clients with that list of interface-implementations.

You can do that using reflection.

There are questions regarding this already, so I would consider this part a duplicate. You can refer to for example this question.

The reason I recommend doing this via DI and not just at runtime is that reflection might be slow and you would want that done once at startup and that's it. But you are not locked in to DI.

You could of course as well just construct the list of implementations like in the example of Part 1. But that would mean you'd have to keep track of new implementations and add them there (which is bad and will lead to "forgotten" impls sooner or later).

If you're using DI you could register various implementations and then inject them as IEnumerable<YourInterface>

eg.

public class SomeConsumer() {
  private readonly IEnumerable<IYourInterface> _allServices;

  public SomeConsumer(IEnumerable<IYourInterface> allServices) {
    _allServices = allServices;
    // ...
  }
  
  // use _allServices in code to get all implementations
}

To register various implementations use standard AddScoped, AddTransient etc. methods.

// Program.cs
// ...
builder.Services.AddScoped<IYourInterface, Implementation1>();
builder.Services.AddScoped<IYourInterface, Implementation2>();
//...