asp.net core - What is meant by the word "request" in the context of a transient service?

Question

Suppose a service meant to be dependency injected (DI) is as follows.

    public interface IWorkService
    {
        Task<JobResult> DoWorkAsync(string JobId, 
            JobPostParameters jobParameters,
            CancellationToken cancellationToken);
    }
    public sealed class WorkService : IWorkService
    {
        private readonly IJobService jobService;
        private readonly IHttpClientFactory httpClientFactory;

        public WorkService(
            IJobService jobService,
            IHttpClientFactory httpClientFactory)
        {
            this.jobService = jobService;
            this.httpClientFactory = httpClientFactory;
        }

        public async Task<JobResult> DoWorkAsync(string jobId, 
            JobPostParameters jobParameters,
            CancellationToken cancellationToken)
        {
            // omissions...
        }
    }

Suppose I intend to register the service as transient.

Transient lifetime services are created each time they're requested from the service container.

That quote comes from this reference. In this situation does the "request" constitute construction followed by exactly one method call followed by destruction? In other words the service object should not contain any private data that survives from one method call to the next?

Edit

I am asking about IWorkService (not the IJobService).

question from:https://stackoverflow.com/questions/65546818/what-is-meant-by-the-word-request-in-the-context-of-a-transient-service

Answer 1

The effective lifetime depends on how IWorkService is created / requested from the dependency injection container.

If there is, for example, a singleton CallerService which gets a IWorkService constructor-injected, that service will use the same IWorkService for each call.

On the other hand, if the CallerService uses an IServiceProvider (for example via an IServiceScopeFactory) - each time GetService is used to get the IWorkService - a new instance will be created.

If the CallerService itself is transient-scoped, the question is shifted to who creates that service at which time.

To sum up, the word "request" describes the act of calling the service provider's GetService method (directly or via some helper method). For each such call, a new instance will be created, if the desired service is transient-scoped.