ServiceCollection.AddScoped Method does not work as expected on AWS.

[Edulopez]

Issue

When running the lambda function deployed on AWS the resources added as a scope ServiceCollection.AddScoped<...> are not being disposed when the execution ends. It is basically working as a AddSingleton and the resource is being reused.

If you run the service locally on visual studio you do not find this issue.

Scenario

In my scenario I made a one transaction per request using DI on my Startup.cs.

serviceCollection.AddScoped<DbConnection>((serviceProvider) =>
            {
                var dbConnection = new SqlConnection(connectionString);
                dbConnection.Open();
                return dbConnection;
            });

serviceCollection.AddScoped<DbTransaction>((serviceProvider) =>
            {
                var dbConnection = serviceProvider
                    .GetService<DbConnection>();

                return dbConnection.BeginTransaction(level);
            });
...

At the end of my execution the resources Added as scoped should be disposed automatically. Also, I'm commiting my transaction.

If you run the lambda function again instead of create a new scope, it will reuse the ones your created. In this case I'm getting Transaction has already being commited. If I close and dispose the connection manually, then I get Connection is closed.

Expected Result

Resources in AddScoped should be disposed when the execution ends. That way, every new execution will create a new connection and transaction.

[Edulopez]

I Manage to solve the Issue.

The key thing to know is that on the local enviroment the Function class is created every time you run it. On the contrary, on AWS this class get instantiated once per lambda lifespan.

In order to fix this issue you need to create all the resources within a manually managed scope per function call. I was creating resources when the App goes up, but since this "scope" is never closed, resources will never dispose as expected.

This is the solution

public class Sync
    {
        private readonly ServiceCollection _services;
        public Sync()
        {
            _services = new ServiceCollection(); // Create empty service collection here in the constructor.
        }

        [LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
        public async Task Handle(ILambdaContext context)
        {
// Key solution here.  Manually create a scope, so at the end of the `using` your disposable resource will be disposed as expected.
            using (var provider = StartUp.ConfigureServices(_services).BuildServiceProvider())
            {
                var mediator = provider.GetService<IMediator>();
                var executionReporter = provider.GetService<...>();
                executionReporter.Start();
                try
                {
                    await mediator.Send(new SyncRequest());
                    executionReporter.Successful(); // Commit transaction
                }
                catch (Exception)
                {
                    executionReporter.Error(); // Rollback
                    throw;
                }
            }
        }
    }

With this I can Run my lambda many times on AWS with no issues.

[genisbarrera]

Hi @Edulopez, I have the same issue. Your solution is a nice workaround, but I think that with this solution Singleton services work as Scoped. Definitelly AWS should fix this behavior. @NGL321 could we reopen the issue?

[ganeshnj]

@genisbarrera we have preview of Lambda Annotation library out which makes easier to inject dependencies and control the lifespan.

https://aws.amazon.com/blogs/developer/introducing-net-annotations-lambda-framework-preview/

Please check this out. If this has not been addressed, feel free to open an issue.

[genisbarrera]

Hi @ganeshnj, it seems that it's what I was looking for. Looks amazing, thanks for building new fantastic Lambda features for dotnet