.NET C# Factory Pattern Using Reflection

// class implements IModelFactory -> IFactoryModel CreateInstance(string modelName)

private Dictionary<string, Type> _availableTypes;

public ModelFactory() {
    LoadTypes();
}

public IFactoryModel CreateInstance(string modelName)
{
    Type t = GetTypeToCreate(modelName);
    //NOTE: handle null here
    return Activator.CreateInstance(t) as IFactoryModel;
}

private void LoadTypes() 
{
    _availableTypes = new Dictionary<string, Type>();
    Type[] assemblyTypes = Assembly.GetExecutingAssembly().GetTypes();

    assemblyTypes.Where(x => x.GetInterface(typeof(IFactoryModel).ToString()) != null).ToList()
        .ForEach(y => _availableTypes.add(y.Name.ToLower(), y));
}

private IFactoryModel GetTypeToCreate(string name)
{
    _availableTypes.TryGetValue(name, out Type t);
    return t ?? null;
}

source:
https://app.pluralsight.com/library/courses/patterns-library/table-of-contents

Dependency Injection With Multiple Implementations Of The Same Interface

public void ConfigureServices(IServiceCollection services)
{
  services.AddTransient<AddOperationRepository>();
  services.AddTransient<SubtractOperationRepository>();
  services.AddTransient<MultiplyOperationRepository>();
  services.AddTransient<DivideOperationRepository>();
  services.AddTransient<Func<MathOperationType, IMathOperationRepository>>(serviceProvider => key =>
  {
    switch (key)
    {
      case MathOperationType.Add:
        return serviceProvider.GetService<AddOperationRepository>();
      case MathOperationType.Subtract:
        return serviceProvider.GetService<SubtractOperationRepository>();
      case MathOperationType.Multiply:
        return serviceProvider.GetService<MultiplyOperationRepository>();
      case MathOperationType.Divide:
        return serviceProvider.GetService<DivideOperationRepository>();
      default:
        throw new KeyNotFoundException();
    }
  });
  . . .
}

...
public class ValuesController : ControllerBase  
{  
  private Func<MathOperationType, IMathOperationRepository> _mathRepositoryDelegate;  
  public ValuesController(Func<MathOperationType, IMathOperationRepository> mathRepositoryDelegate)  
  {  
    _mathRepositoryDelegate = mathRepositoryDelegate;  
  }  
  [HttpPost]  
  public ActionResult<OperationResult> Post([FromBody] OperationRequest opRequest)  
  {  
    IMathOperationRepository mathRepository = _mathRepositoryDelegate(opRequest.OperationType);  
    OperationResult opResult = mathRepository.PerformOperation(opRequest);  
    return new ObjectResult(opResult);  
  }  
} 

Source:
https://www.c-sharpcorner.com/article/dependency-injection-with-multiple-implementations-of-the-same-interface/

Enable CORS in .NET Core Web API

// Startup.cs

public void ConfigureServices(IServiceCollection services)
{
        // ...
        CorsConfig(services);
        // ...
}

public void Configure(IApplicationBuilder app, IApiVersionDescriptionProvider provider)
{
        // ...
        CorsConfig(app);        
        // ...
}

readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";
private void CorsConfig(IApplicationBuilder app)
{
    app.UseCors(MyAllowSpecificOrigins);
}
private void CorsConfig(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy(MyAllowSpecificOrigins,
        builder =>
        {
            builder.WithOrigins("http://localhost.com");
        });
    });
}