Use dependency injection (and Scrutor) to register instead of Autofac

[DanElliott]

Use the template dotnet new clean-arch

Make the following changes, also seen here DanElliott/CleanArchitecture

Directory.Packages.props

<Project>
  <ItemGroup>
    <PackageVersion Include="Ardalis.GuardClauses" Version="4.2.0" />
    <PackageVersion Include="Ardalis.HttpClientTestExtensions" Version="4.2.0" />
    <PackageVersion Include="Ardalis.ListStartupServices" Version="1.1.4" />
    <PackageVersion Include="Ardalis.Result" Version="7.2.0" />
    <PackageVersion Include="Ardalis.Result.AspNetCore" Version="7.2.0" />
    <PackageVersion Include="Ardalis.SharedKernel" Version="1.4.0" />
    <PackageVersion Include="Ardalis.SmartEnum" Version="7.0.0" />
    <PackageVersion Include="Ardalis.Specification" Version="8.0.0" />
    <PackageVersion Include="Ardalis.Specification.EntityFrameworkCore" Version="8.0.0" />
-    <PackageVersion Include="Autofac" Version="7.1.0" />
-    <PackageVersion Include="Autofac.Extensions.DependencyInjection" Version="8.0.0" />
    <PackageVersion Include="coverlet.collector" Version="6.0.0" />
    <PackageVersion Include="FastEndpoints" Version="5.20.0" />
    <PackageVersion Include="FastEndpoints.ApiExplorer" Version="2.2.0" />
    <PackageVersion Include="FastEndpoints.Swagger" Version="5.20.0" />
    <PackageVersion Include="FastEndpoints.Swagger.Swashbuckle" Version="2.2.0" />
    <PackageVersion Include="FluentAssertions" Version="6.12.0" />
    <PackageVersion Include="MailKit" Version="4.3.0" />
    <PackageVersion Include="MediatR" Version="12.2.0" />
    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="8.0.0" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.InMemory" Version="8.0.0" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="8.0.0" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="8.0.0" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.0" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.0" />
    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="8.0.0" />
    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
    <PackageVersion Include="Microsoft.VisualStudio.Web.CodeGeneration.Design" Version="8.0.0" />
    <PackageVersion Include="NSubstitute" Version="5.1.0" />
    <PackageVersion Include="ReportGenerator" Version="5.2.0" />
+    <PackageVersion Include="Scrutor" Version="4.2.2" />
    <PackageVersion Include="Serilog.AspNetCore" Version="8.0.0" />
    <PackageVersion Include="SQLite" Version="3.13.0" />
    <PackageVersion Include="Swashbuckle.AspNetCore" Version="6.5.0" />
    <PackageVersion Include="Swashbuckle.AspNetCore.Annotations" Version="6.5.0" />
    <PackageVersion Include="xunit" Version="2.6.2" />
    <PackageVersion Include="xunit.runner.visualstudio" Version="2.5.4" />
  </ItemGroup>
</Project>

src/CleanArchitecture.Core/CleanArchitecture.Core.csproj

<Project Sdk="Microsoft.NET.Sdk">
  <Sdk Name="Microsoft.Build.CentralPackageVersions" Version="2.1.3" />
  <ItemGroup>
    <PackageReference Include="Ardalis.GuardClauses" />
    <PackageReference Include="Ardalis.Result" />
    <PackageReference Include="Ardalis.SharedKernel" />
    <PackageReference Include="Ardalis.SmartEnum" />
    <PackageReference Include="Ardalis.Specification" />
-    <PackageReference Include="Autofac" />
    <PackageReference Include="MediatR" />
    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
  </ItemGroup>
</Project>

src/CleanArchitecture.Core/DependencyInjection.cs

+ using Microsoft.Extensions.DependencyInjection;
+ using CleanArchitecture.Core.Interfaces;
+ using CleanArchitecture.Core.Services;
+
+ namespace CleanArchitecture.Core;
+ public static class DependencyInjection
+ {
+   public static IServiceCollection AddCore(this IServiceCollection services)
+   {
+     services
+       .AddScoped<IDeleteContributorService, DeleteContributorService>();
+
+     return services;
+   }
+ }

src/CleanArchitecture.Infrastructure/CleanArchitecture.Infrastructure.csproj

<Project Sdk="Microsoft.NET.Sdk">
  <Sdk Name="Microsoft.Build.CentralPackageVersions" Version="2.1.3" />
  <ItemGroup>
    <PackageReference Include="Ardalis.SharedKernel" />
    <PackageReference Include="Ardalis.Specification.EntityFrameworkCore" />
-    <PackageReference Include="Autofac" />
-    <PackageReference Include="Autofac.Extensions.DependencyInjection" />
    <PackageReference Include="MailKit" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Tools" PrivateAssets="all" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" />
    <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" />
+    <PackageReference Include="Scrutor" />
    <PackageReference Include="SQLite" />
  </ItemGroup>

  <ItemGroup>
    <ProjectReference Include="..\CleanArchitecture.Core\CleanArchitecture.Core.csproj" />
    <ProjectReference Include="..\CleanArchitecture.UseCases\CleanArchitecture.UseCases.csproj" />
  </ItemGroup>
</Project>

src/CleanArchitecture.Infrastructure/DependencyInjection.cs

+ using System.Reflection;
+ using Ardalis.SharedKernel;
+ using MediatR;
+ using MediatR.Pipeline;
+ using Microsoft.Extensions.DependencyInjection;
+ using CleanArchitecture.Core.ContributorAggregate;
+ using CleanArchitecture.Core.Interfaces;
+ using CleanArchitecture.Infrastructure.Data;
+ using CleanArchitecture.Infrastructure.Data.Queries;
+ using CleanArchitecture.Infrastructure.Email;
+ using CleanArchitecture.UseCases.Contributors.Create;
+ using CleanArchitecture.UseCases.Contributors.List;
+
+ namespace CleanArchitecture.Infrastructure;
+ public static class DependencyInjection
+ {
+   private static bool _isDevelopment;
+   private static readonly List<Assembly> _assemblies = [];
+
+   public static IServiceCollection AddInfrastructure(this IServiceCollection services, bool isDevelopment, Assembly? callingAssembly = null)
+   {
+     _isDevelopment = isDevelopment;
+     AddToAssembliesIfNotNull(callingAssembly);
+
+     LoadAssemblies();
+
+     if (isDevelopment)
+     {
+       services.RegisterDevelopmentOnlyDependencies();
+     }
+     else
+     {
+       services.RegisterProductionOnlyDependencies();
+     }
+
+     services
+       .RegisterEF()
+       .RegisterQueries()
+       .RegisterMediatR();
+
+     return services;
+   }
+
+   private static void AddToAssembliesIfNotNull(Assembly? assembly)
+   {
+     if (assembly != null)
+     {
+       _assemblies.Add(assembly);
+     }
+   }
+
+   private static void LoadAssemblies()
+   {
+     // TODO: Replace these types with any type in the appropriate assembly/project
+     var coreAssembly = Assembly.GetAssembly(typeof(Contributor));
+     var infrastructureAssembly = Assembly.GetAssembly(typeof(DependencyInjection));
+     var useCasesAssembly = Assembly.GetAssembly(typeof(CreateContributorCommand));
+
+     AddToAssembliesIfNotNull(coreAssembly);
+     AddToAssembliesIfNotNull(infrastructureAssembly);
+     AddToAssembliesIfNotNull(useCasesAssembly);
+   }
+
+   private static IServiceCollection RegisterEF(this IServiceCollection services)
+   {
+     services
+       .AddScoped(typeof(IRepository<>), typeof(EfRepository<>));
+
+     services
+       .AddScoped(typeof(IReadRepository<>), typeof(EfRepository<>));
+
+     return services;
+   }
+
+   private static IServiceCollection RegisterQueries(this IServiceCollection services)
+   {
+     services
+       .AddScoped<IListContributorsQueryService, ListContributorsQueryService>();
+
+     return services;
+   }
+
+   private static IServiceCollection RegisterMediatR(this IServiceCollection services)
+   {
+     services
+       .AddMediatR(config =>
+       {
+         config.RegisterServicesFromAssembly(typeof(DependencyInjection).Assembly);
+         config.AddOpenBehavior(typeof(LoggingBehavior<,>));
+       });
+
+     services.AddTransient<IDomainEventDispatcher, MediatRDomainEventDispatcher>();
+
+     var mediatrOpenTypes = new[]
+     {
+       typeof(IRequestHandler<,>),
+       typeof(IRequestExceptionHandler<,,>),
+       typeof(IRequestExceptionAction<,>),
+       typeof(INotificationHandler<>),
+     };
+
+     foreach (var mediatrOpenType in mediatrOpenTypes)
+     {
+       // register all the open types (concrete types) that implement the interfaces above using Scrutor
+       services
+         .Scan(selector => selector
+         .FromAssemblies(_assemblies)
+         .AddClasses(classes => classes.AssignableTo(mediatrOpenType))
+         .AsImplementedInterfaces()
+         .WithScopedLifetime());
+     }
+
+     return services;
+   }
+
+   private static IServiceCollection RegisterDevelopmentOnlyDependencies(this IServiceCollection services)
+   {
+     // NOTE: Add any development only services here
+     services
+       .AddScoped<IEmailSender, FakeEmailSender>();
+
+     //services
+     //  .AddScoped<IListContributorsQueryService, FakeListContributorsQueryService>();
+
+     return services;
+   }
+
+   private static IServiceCollection RegisterProductionOnlyDependencies(this IServiceCollection services)
+   {
+     // NOTE: Add any production only (real) services here
+     services
+       .AddScoped<IEmailSender, FakeEmailSender>();
+ 
+     return services;
+   }
+ }

src/CleanArchitecture.Web/Program.cs

using Ardalis.GuardClauses;
using Ardalis.ListStartupServices;
using Autofac;
using Autofac.Extensions.DependencyInjection;
using CleanArchitecture.Core;
using CleanArchitecture.Infrastructure;
using CleanArchitecture.Infrastructure.Data;
using FastEndpoints;
using FastEndpoints.Swagger;
using Serilog;

var builder = WebApplication.CreateBuilder(args);

- builder.Host.UseServiceProviderFactory(new AutofacServiceProviderFactory());

builder.Host.UseSerilog((_, config) => config.ReadFrom.Configuration(builder.Configuration));

builder.Services.Configure<CookiePolicyOptions>(options =>
{
  options.CheckConsentNeeded = context => true;
  options.MinimumSameSitePolicy = SameSiteMode.None;
});
string? connectionString = builder.Configuration.GetConnectionString("SqliteConnection");
Guard.Against.Null(connectionString);
builder.Services.AddApplicationDbContext(connectionString);
builder.Services.AddFastEndpoints();
builder.Services.SwaggerDocument(o =>
{
  o.ShortSchemaNames = true;
});
// add list services for diagnostic purposes - see https://github.com/ardalis/AspNetCoreStartupServices
builder.Services.Configure<ServiceConfig>(config =>
{
  config.Services = new List<ServiceDescriptor>(builder.Services);
  // optional - default path to view services is /listallservices - recommended to choose your own path
  config.Path = "/listservices";
});


- builder.Host.ConfigureContainer<ContainerBuilder>(containerBuilder =>
- {
-   containerBuilder.RegisterModule(new DefaultCoreModule());
-   containerBuilder.RegisterModule(new AutofacInfrastructureModule(builder.Environment.IsDevelopment()));
- });
+ builder.Services
+   .AddCore()
+   .AddInfrastructure(builder.Environment.IsDevelopment());

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
  app.UseDeveloperExceptionPage();
  app.UseShowAllServicesMiddleware(); // see https://github.com/ardalis/AspNetCoreStartupServices
}
else
{
  app.UseDefaultExceptionHandler(); // from FastEndpoints
  app.UseHsts();
}
app.UseFastEndpoints();
app.UseSwaggerGen(); // FastEndpoints middleware
app.UseHttpsRedirection();
SeedDatabase(app);
app.Run();
static void SeedDatabase(WebApplication app)
{
  using var scope = app.Services.CreateScope();
  var services = scope.ServiceProvider;
  try
  {
    var context = services.GetRequiredService<AppDbContext>();
    //                    context.Database.Migrate();
    context.Database.EnsureCreated();
    SeedData.Initialize(services);
  }
  catch (Exception ex)
  {
    var logger = services.GetRequiredService<ILogger<Program>>();
    logger.LogError(ex, "An error occurred seeding the DB. {exceptionMessage}", ex.Message);
  }
}
// Make the implicit Program.cs class public, so integration tests can reference the correct assembly for host building
public partial class Program
{
}