NullReferenceException in TransportAddressResolver upon startup about nservicebus HOT 4 CLOSED

public class EventBusBuilder
{
	internal const string EventBusConfigurationKey = "EventBus";

	private readonly List<Action<IServiceCollection>> _components = new();
	private readonly HostBuilderContext _host;
	private readonly IConfigurationSection _persistenceSection;
	private readonly IConfigurationSection _transportSection;

	private string? _appId;
	private bool _sendOnly;
	private bool _enableInstallers;
	private Type? _tenantContextType;
	private Action<EndpointConfiguration>? _persistenceConfiguration;
	private Action<EndpointConfiguration>? _transportConfiguration;
	private List<RegisterStep> _registerSteps = new();

	public IHostEnvironment Environment => _host.HostingEnvironment;

	internal EventBusBuilder(HostBuilderContext context)
	{
		_host = context;

		var eventBusSection = _host.Configuration.GetSection(EventBusConfigurationKey);
		_persistenceSection = eventBusSection.GetSection("Persistence");
		_transportSection = eventBusSection.GetSection("Transport");
	}

	public EventBusBuilder UseAppIdFromConfiguration(string configKey)
	{
		_appId = _host.Configuration.GetRequiredValue<string>(configKey);
		if (_host.HostingEnvironment.IsDevelopment())
		{
			_appId = $"{_host.Configuration.GetDeveloperId()}-local-{_appId}";
		}
		return this;
	}

	public EventBusBuilder SendOnly()
	{
		_sendOnly = true;
		return this;
	}

	public EventBusBuilder EnableInstallers()
	{
		_enableInstallers = true;
		return this;
	}

	public EventBusBuilder UseTenantContext<T>()
		where T : class, ITenantContext
	{
		_tenantContextType = typeof(T);
		return this;
	}

	public EventBusBuilder AddInterceptor<T>(string description)
		where T : EventBusInterceptor
	{
		var registerStep = new DefaultRegisterStep(
			typeof(T).Name,
			typeof(T),
			description,
			s => ActivatorUtilities.CreateInstance<T>(s)
		);
		_registerSteps.Add(registerStep);
		return this;
	}

	internal EndpointConfiguration Build()
	{
		ValidateConfiguration();

		var configuration = new EndpointConfiguration(_appId);
		ConfigureScanner(configuration);
		ConfigureSerialization(configuration);

		foreach (var component in _components)
		{
			configuration.RegisterComponents(component);
		}

		configuration.RegisterComponents(
			s => s.Add(new ServiceDescriptor(typeof(ITenantContext), _tenantContextType, ServiceLifetime.Singleton))
		);

		foreach (var registerStep in _registerSteps)
		{
			configuration.Pipeline.Register(registerStep);
		}

		_transportConfiguration(configuration);
		_persistenceConfiguration(configuration);
		configuration.EnableOutbox();

		if (_sendOnly)
		{
			configuration.SendOnly();
		}

		if (_host.HostingEnvironment.IsDevelopment() || _enableInstallers)
		{
			configuration.EnableInstallers();
		}

		if (_host.HostingEnvironment.IsDevelopment())
		{
			ConfigureDevelopmentLicense(configuration);
		}

		return configuration;
	}

	private static void ConfigureSerialization(EndpointConfiguration configuration)
	{
		// TODO: switch to SystemJsonSerializer when NServiceBus >= 8.1.0
		var jsonSerializerSettings = new JsonSerializerSettings
		{
			DateFormatHandling = DateFormatHandling.IsoDateFormat,
			ContractResolver = new DefaultContractResolver { NamingStrategy = new CamelCaseNamingStrategy() }
		};
		jsonSerializerSettings.Converters.Add(new StringEnumConverter());

		configuration.UseSerialization<NewtonsoftJsonSerializer>().Settings(jsonSerializerSettings);
	}

	private static void ConfigureScanner(EndpointConfiguration configuration)
	{
		var scanner = configuration.AssemblyScanner();
		var nonProjectAssemblies = AppDomain
			.CurrentDomain
			.GetAssemblies()
			.Where(x => x.GetName().Name is not null && !x.GetName().Name!.StartsWith("Namespace."))
			.Select(x => Path.GetFileNameWithoutExtension(x.Location))
			.ToArray();
		scanner.ExcludeAssemblies(nonProjectAssemblies);
		scanner.ExcludeTypes(typeof(IntegrationEvent));
	}

	[MemberNotNull(nameof(_appId))]
	[MemberNotNull(nameof(_transportConfiguration))]
	[MemberNotNull(nameof(_persistenceConfiguration))]
	[MemberNotNull(nameof(_tenantContextType))]
	private void ValidateConfiguration()
	{
		if (_appId.IsNullOrEmpty())
		{
			throw new InvalidOperationException("Missing app id");
		}

		if (_transportConfiguration is null)
		{
			throw new InvalidOperationException("No transport configured");
		}

		if (_persistenceConfiguration is null)
		{
			throw new InvalidOperationException("No persistence configured");
		}

		if (_tenantContextType is null)
		{
			throw new InvalidOperationException("No tenant context configured");
		}
	}

	private void ConfigureDevelopmentLicense(EndpointConfiguration configuration)
	{
		var licenseText = typeof(EventBusBuilder)
			.Assembly
			.GetManifestResourceString($"{nameof(Namespace)}.License.xml");
		configuration.License(licenseText);
	}

	#region Persistence

	public EventBusBuilder UseCosmosPersistence()
	{
		var configSection = _persistenceSection.GetRequiredSection("Cosmos");

		_components.Add(services =>
		{
			services
				.AddTransient<IProvideCosmosClient, CosmosClientProvider>()
				.AddTransient<ISessionOptionsProvider, CosmosSessionOptionsProvider>()
				.AddAzureClients(c =>
				{
					c.AddClient<CosmosClient, CosmosClientOptions>(
							(o, cred, _) =>
							{
								var endpoint = configSection.GetValue<string>("Endpoint");
								var connectionString = configSection.GetValue<string>("ConnectionString");

								if (!connectionString.IsNullOrEmpty())
								{
									return new CosmosClient(connectionString, o);
								}

								if (!endpoint.IsNullOrEmpty())
								{
									return new CosmosClient(endpoint, cred, o);
								}

								throw new InvalidOperationException(
									"Cosmos persistence needs either connection string or endpoint to be configured"
								);
							}
						)
						.WithCredential(new DefaultAzureCredential())
						.WithName(CosmosClientProvider.ClientName);
				});
		});

		_persistenceConfiguration = c =>
		{
			const string pkPath = $"/{IntegrationEvent.TenantIdPropertyName}";
			var database = configSection.GetValue("Database", "event-bus");

			if (_host.HostingEnvironment.IsDevelopment())
			{
				database = $"{database}-local";
			}

			var persistence = c.UsePersistence<CosmosPersistence>().DatabaseName(database);

			var container = configSection.GetValue("Container", _appId)!;
			persistence.DefaultContainer(container, pkPath);

			persistence.EnableTransactionalSession();
			var transactionInformation = persistence.TransactionInformation();
			transactionInformation.ExtractPartitionKeyFromMessages(new CosmosPartitionKeyExtractor());
		};

		return this;
	}

	#endregion

	#region Transport

	public EventBusBuilder UseServiceBusTransport()
	{
		_transportConfiguration = c =>
		{
			var configSection = _transportSection.GetRequiredSection("ServiceBus");
			var connectionString = configSection.GetValue<string>("ConnectionString");
			var fqdn = configSection.GetValue<string>("Fqdn");
			var topicName = configSection.GetValue<string>("Topic", "event-bus");
			var errorQueueName = configSection.GetValue<string>("ErrorQueue", "event-bus-error");

			AzureServiceBusTransport transport;
			if (!connectionString.IsNullOrEmpty())
			{
				transport = new AzureServiceBusTransport(connectionString);
			}
			else
			{
				if (fqdn.IsNullOrEmpty())
				{
					throw new InvalidOperationException("Service bus needs either connection string or fqdn");
				}

				transport = new AzureServiceBusTransport(fqdn, new DefaultAzureCredential());
			}

			if (_host.HostingEnvironment.IsDevelopment())
			{
				topicName = $"{_host.Configuration.GetDeveloperId()}-local-{topicName}";
				errorQueueName = $"{_host.Configuration.GetDeveloperId()}-local-{errorQueueName}";
			}

			transport.EntityMaximumSize = 5;
			transport.EnablePartitioning = true;
			transport.Topology = TopicTopology.Single(topicName);
			transport.TransportTransactionMode = TransportTransactionMode.ReceiveOnly;

			c.SendFailedMessagesTo(errorQueueName);
			c.UseTransport(transport);
		};
		return this;
	}

	#endregion
}

public static class HostBuilderExtensions
{
	public static IHostBuilder UseEventBus(this IHostBuilder hostBuilder, Action<EventBusBuilder> configureBuilder)
	{
		hostBuilder
			.UseNServiceBus(c =>
			{
				var builder = new EventBusBuilder(c);
				configureBuilder(builder);
				return builder.Build();
			})
			.ConfigureServices(
				(c, s) =>
				{
					var isEnabled = c.Configuration
						.GetSection(EventBusBuilder.EventBusConfigurationKey)
						.GetValue("IsEnabled", true);
					if (isEnabled)
					{
						s.AddTransient<IIntegrationEventPublisher, DefaultIntegrationEventPublisher>()
							.AddTransient<IIntegrationEventTransactionHandler, DefaultTransactionHandler>();
					}
					else
					{
						s.AddTransient<IIntegrationEventPublisher, DisabledIntegrationEventPublisher>()
							.AddTransient<IIntegrationEventTransactionHandler, DisabledTransactionHandler>();
					}
				}
			);

		return hostBuilder;
	}
}

public static class Program
{
	public static void Main(string[] args) => CreateHostBuilder(args).Build().Run();

	public static IHostBuilder CreateHostBuilder(string[] args) =>
		Host.CreateDefaultBuilder(args)
			.UseEventBus(
				c =>
					c.UseAppIdFromConfiguration("AppId")
						.UseTenantContext<EventBusTenantContext>()
						.UseCosmosPersistence()
						.UseServiceBusTransport()
						.EnableInstallers()
			)
                        // Rest of init code
}