Use static C# api clients in a regular .NET 8 app

[LiangZugeng]

I created an web app with ABP framework, and I am developing another .NET 8 client app which doesn't use ABP Framework, I would like the client app to use all contracts I defined in the web app so I followed Static C# API Client Proxies.

The doc says

This system can be used by any type of .NET client to consume your HTTP APIs.

But in the doc it requires me to use AbpModule in the client app

[DependsOn(typeof(AbpHttpClientModule))] //add the dependency
public class MyClientAppModule : AbpModule
{
}

I also googled and found all example videos regarding consuming ABP web apis are done by using the HttpApi.Client.ConsoleTestApp which is already an AbpModule.

I'm confused, does it mean the static C# api client proxies generated by ABP can only be consumed in another ABP application? I would prefer to use a regular .NET 8 app to consume the http api and I do not want to handle data serialization/deserialization by myself, I can add Volo.Abp.Http.Client package to this project through.

Could anyone provide me a guidance for me? Thanks.

[maliming]

hi

You can bootstrap an abp module system into your project. It doesn't require many module dependencies.

[LiangZugeng]

Thanks for the direction, it's a right way to do that. I will provide more details as below for future reference.

[LiangZugeng]

For anyone who is new to ABP framework, and is facing the same problem as I did, bootstraping abp module system into the project is the right way to go, here're more details.

1. For console application, it's rather simple, follow the Application Startup official document to add ABP into your current project.

2. For ASP.NET Core Web application, follow the Getting Started with an Empty ASP.NET Core MVC / Razor Pages Application official document to add ABP into your ASP.NET Web application.

3. For .NET Worker application, as ABP doesn't provide extension methods for HostApplicationBuilder (which is new in .NET 6+), if your project is using HostApplicationBuilder you may need to rewrite it to use CreateDefaultBuilder to create a HostBuilder and use existing ABP extension methods to make that happen, the following is a sample Program.cs which has already been configured to use ABP core services.

using MyApp.Services;
using Serilog;
using Volo.Abp;
using Volo.Abp.Threading;

namespace MyApp;

public class Program
{
  public async static Task<int> Main(string[] args)
  {
    try
    {
      var builder = Host.CreateDefaultBuilder(args)
        .UseSerilog((context, _, config) => config
          .ReadFrom.Configuration(context.Configuration)
          .Enrich.FromLogContext())
        .ConfigureLogging((ctx, builder) =>
        {
          builder.ClearProviders();
          builder.AddSerilog();
        })
        .AddAppSettingsSecretsJson()
        .UseAutofac()
        .ConfigureServices((hostContext, services) =>
        {
          services.AddApplication<MyAppModule>(o =>
          {
            o.Services.ReplaceConfiguration(hostContext.Configuration);
            if (o.Environment.IsNullOrWhiteSpace())
            {
              o.Environment = hostContext.HostingEnvironment.EnvironmentName;
            }
          });
        });

      var app = builder.Build();

      var application = app.Services.GetRequiredService<IAbpApplicationWithExternalServiceProvider>();
      var applicationLifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();

      applicationLifetime.ApplicationStopping.Register(() =>
      {
        AsyncHelper.RunSync(() => application.ShutdownAsync());
      });

      applicationLifetime.ApplicationStopped.Register(() =>
      {
        application.Dispose();
      });

      await application.InitializeAsync(app.Services);

      await app.RunAsync();

      return 0;
    }
    catch (Exception ex)
    {
      Log.Fatal(ex, "Host terminated unexpectedly");

      return 1;
    }
    finally
    {
      Log.CloseAndFlush();
    }
  }
}

using Polly;
using Volo.Abp;
using Volo.Abp.BackgroundWorkers;
using Volo.Abp.Http.Client;
using Volo.Abp.Modularity;

namespace MyApp;

[DependsOn(
  typeof(MyAppHttpApiClientModule),
  typeof(AdminHttpApiClientModule),
  typeof(AbpBackgroundWorkersModule))]
public class MyAppModule : AbpModule
{
  public override async Task OnApplicationInitializationAsync(
    ApplicationInitializationContext context)
  {
    await context.AddBackgroundWorkerAsync<YourBackgroundWorkerType>();
    await base.OnApplicationInitializationAsync(context);
  }

  public override Task OnApplicationShutdownAsync(ApplicationShutdownContext context)
  {
    // code to clean up resources before the application stops
    return base.OnApplicationShutdownAsync(context);
  }

  public override void ConfigureServices(ServiceConfigurationContext context)
  {
    var myAppSettings = context.Services.GetConfiguration().GetSection("MyAppSettings");
    context.Services.Configure<MyAppSettings>(myAppSettings);

    context.Services.AddMediatR(cfg =>
    {
      cfg.RegisterServicesFromAssembly(typeof(Program).Assembly);
    });

    // Register HTTP Client for Web API communication
    context.Services.AddHttpClient();

    context.Services.AddMemoryCache();
  }

  public override void PreConfigureServices(ServiceConfigurationContext context)
  {
    PreConfigure<AbpHttpClientBuilderOptions>(options =>
    {
      options.ProxyClientBuildActions.Add((remoteServiceName, clientBuilder) =>
      {
        clientBuilder.AddTransientHttpErrorPolicy(
          policyBuilder => policyBuilder.WaitAndRetryAsync(3, i => TimeSpan.FromSeconds(Math.Pow(2, i)))
        );
      });
    });
  }
}

Specifically for .NET worker application, since ABP also provides BackgroundWorker which is similar to BackgroundService, you may consider updating your existing background services to take advantages of auto trigger for configurable timer interval and also exception handling etc, that's totally up to you and it's totally fine to continue using the BackgroundService.

After adding ABP core system into your project, you may follow Dynamic C# API Client Proxies to inject the app services from another ABP application into your application services.