Cómo usar la inyección de dependencia en la implementación de AWS Lambda C#

Siéntete libre de compartir nuestra página y códigos en tus redes sociales, ayúdanos a ampliar nuestra comunidad.

Solución:

Sé que llegué tarde al juego, pero agrego esto porque creo que hay algunos ejemplos malos o que faltan en Internet. @Erndob tiene razón sobre la respuesta aceptada. Solo estarás creando más instancias.

Dependiendo de los registros que esté realizando en su contenedor DI, debe tener en cuenta:

1. ¿Qué registros estás haciendo que implementan IDisposable?
2. ¿Cuánto tiempo mantiene AWS la instancia de su objeto? No he podido encontrar ninguna documentación al respecto.

Terminé yendo con algo como esto:

public class Function

    private ServiceCollection _serviceCollection;

    public Function()
    
        ConfigureServices();
    

    public string FunctionHandler(string input, ILambdaContext context)
    
        using (ServiceProvider serviceProvider = _serviceCollection.BuildServiceProvider())
        
            // entry to run app.
            return serviceProvider.GetService().Run(input);
        
    

    private void ConfigureServices()
    
        // add dependencies here
        _serviceCollection = new ServiceCollection();
        _serviceCollection.AddTransient();
    

Con este patrón, cada invocación de lambda obtendrá una nueva ServiceProvider y deséchelo cuando haya terminado.

Si bien FunctionHandler es de hecho su punto de entrada a su aplicación, en realidad conectaría su DI en un constructor sin parámetros. El constructor solo se llama una vez, por lo que este código puramente de “configuración” solo debería llamarse una vez. Solo queremos aprovechar su uso en cada invocación posterior que se enruta al mismo contenedor.

public class Function

    private static ServiceProvider ServiceProvider  get; set; 

    /// 

    /// The parameterless constructor is what Lambda uses to construct your instance the first time.
    /// It will only ever be called once for the lifetime of the container that it's running on.
    /// We want to build our ServiceProvider once, and then use the same provider in all subsequent 
    /// Lambda invocations. This makes things like using local MemoryCache techniques viable (Just 
    /// remember that you can never count on a locally cached item to be there!)
    /// 
    public Function()
    
        var services = new ServiceCollection();
        ConfigureServices(services);
        ServiceProvider = services.BuildServiceProvider();
    

    public async Task FunctionHandler(SQSEvent evnt, ILambdaContext context)
    
        await ServiceProvider.GetService().Run(evnt);
    

    /// 

    /// Configure whatever dependency injection you like here
    /// 
    /// 
    private static void ConfigureServices(IServiceCollection services)
    
        // add dependencies here ex: Logging, IMemoryCache, Interface mapping to concrete class, etc...

        // add a hook to your class that will actually do the application logic
        services.AddTransient();
    

    /// 

    /// Since we don't want to dispose of the ServiceProvider in the FunctionHandler, we will
    /// at least try to clean up after ourselves in the destructor for the class.
    /// 
    ~Function()
    
        ServiceProvider.Dispose();
    


public class App

    public async Task Run(SQSEvent evnt)
    
        // actual business logic goes here
        await Task.CompletedTask;
    

Puedes hacerlo. Su FunctionHandler es su punto de entrada a su aplicación… por lo que debe conectar la colección de servicios desde allí.

public class Function

    public string FunctionHandler(string input, ILambdaContext context)
    
        var serviceCollection = new ServiceCollection();
        ConfigureServices(serviceCollection);

        // create service provider
        var serviceProvider = serviceCollection.BuildServiceProvider();

        // entry to run app.
        return serviceProvider.GetService().Run(input);
    

    private static void ConfigureServices(IServiceCollection serviceCollection)
    
        // add dependencies here

        // here is where you're adding the actual application logic to the collection
        serviceCollection.AddTransient();
    


public class App

    // if you put a constructor here with arguments that are wired up in your services collection, they will be injected.

    public string Run(string input)
    
        return "This is a test";
    

Si desea conectar el registro, eche un vistazo aquí: https://github.com/aws/aws-lambda-dotnet/tree/master/Libraries/src/Amazon.Lambda.Logging.AspNetCore

valoraciones y comentarios

---

---

Utiliza Nuestro Buscador