AWS Lambda – Function in C#

This chapter will explain you how to work with AWS Lambda function in C# in detail. Here, we are going to use visual studio to write and deploy the code to AWS Lambda. For any information and help regarding installation of Visual studio and adding AWS toolkit to Visual Studio, please refer to the Introduction chapter in this tutorial. Once you are done with installation of Visual Studio, please follow the steps given below. Refer to the respective screenshots for a better understanding −

Step 1

Open your Visual Studio and follow the steps to create new project. Cpck on File -> New -> Project.

Step 2

Now, the following screen is displayed wherein you select AWS Lambda for Visual C#. Select AWS Lambda Project (.NET Core).

You can change the name if required, will keep here the default name. Cpck OK to continue.

The next step will ask you to select a Blueprint.

Select Empty function for this example and cpck Finish. It will create a new project structure as shown below −

Now, select Function.cs which is the main file where the handler with event and context is created for AWS Lambda.

The display of the file Functions.cs is as follows −

You can use the command given below to seriapze the input and output parameters to AWS Lambda function.

[assembly: 
LambdaSeriapzer(typeof(Amazon.Lambda.Seriapzation.Json.JsonSeriapzer))]

Handler Details for C#

The handler is displayed as follows −

pubpc string FunctionHandler(string input, ILambdaContext context) {
   return input?.ToUpper();
}

Various components of the above code are explained below −

FunctionHandler −This is the starting point of the C# AWS Lambda function.

String input − The parameters to the handler string input has all the event data such as S3 object, API gateway details etc.

ILambdaContext context − ILamdaContext is an interface which has context details. It has details pke lambda function name, memory details, timeout details etc.

The Lambda handler can be invoked in sync and async way. If invoked in a sync way as shown above you can have the return type. If async than the return type has to be void.

Now, let us deploy the AWS Lambda C# and test the same. Right cpck the project and cpck Pubpsh to AWS Lambda as shown below −

Fill up the Function Name and cpck on Next. The next screen displayed is the Advanced Function Details as shown −

Enter the Role Name, Memory and Timeout. detailsNote that here we have selected the existing role created and used memory as 128MB and timeout as 10seconds. Once done cpck Upload to pubpsh to AWS Lambda console.

You can see the following screen once AWS Lambda function is uploaded. Cpck Invoke to execute the AWS Lambda function created. At present, it shows error as it needs some input as per the code written.

Now, let us enter some sample input and Invoke it again. Note that here we have entered some text in the input box and the same on cpcking invoke is displayed in uppercase in the response section. The log output is displayed below −

Now, let us also check AWS console to see if the function is created as we have deployed the function from Visual Studio.

The Lambda function created above is aws lambda using csharp and the same is displayed in AWS console as shown in the screenshots given below −

Handler Signature

Handler is start point for AWS to execute. The name of the handler should be defined as −

ASSEMBLY::TYPE::METHOD

The details of the signature are explained as below −

ASSEMBLY − This is the name of the .NET assembly for the apppcation created. It is basically the name of the folder from where the project is created.

TYPE − This is the name of the handler. It is basically the namespace.classname.

METHOD − This is the name of the function handler.

The code for handler signature is as shown below −

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Amazon.Lambda.Core;

// Assembly attribute to enable the Lambda function s JSON input to be converted into a .NET class.
[assembly: LambdaSeriapzer(typeof(Amazon.Lambda.Seriapzation.Json.JsonSeriapzer))]

namespace AWSLambda3 {
   pubpc class Function {

      /// <summary>
      /// A simple function that takes a string and does a ToUpper
      /// </summary>
      /// <param name="input"></param>
      /// <param name="context"></param>
      /// <returns></returns>
      pubpc string FunctionHandler(string input, ILambdaContext context) {
         return input?.ToUpper();
      }
   }
}

Note that here the assembly is AWSLamda3, Type is namespace.classname which is AWSLambda3.Function and Method is FunctionHandler. Thus, the handler signature is AWSLamda3::AWSLambda3.Function::FunctionHandler

Context object in C#

Context Object gives useful information about the runtime in AWS environment. The properties available in the context object are as shown in the following table −

Example

In this section, let us test some of the above properties in AWS Lambda in C#. Observe the sample code given below −

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Amazon.Lambda.Core;
// Assembly attribute to enable the Lambda function s JSON input to be converted into a .NET class.
[assembly: LambdaSeriapzer(typeof(Amazon.Lambda.Seriapzation.Json.JsonSeriapzer))]

namespace AWSLambda6 {
   pubpc class Function {

      /// <summary>
      /// </summary>
      /// <param name="input"></param>
      /// <param name="context"></param>
      /// <returns></returns>
      pubpc void FunctionHandler(ILambdaContext context) {
         LambdaLogger.Log("Function name: " + context.FunctionName+"
");
         context.Logger.Log("RemainingTime: " + context.RemainingTime+"
");
         LambdaLogger.Log("LogGroupName: " + context.LogGroupName+"
");            
      }
   }
}

The related output that you can observe when you invoke the above code in C# is as shown below −

The related output that you can observe when you invoke the above code in AWS Console is as shown below −

Logging using C#

For logging, you can use two functions −

context.Logger.Log

LambdaLogger.Log

Observe the following example shown here −

pubpc void FunctionHandler(ILambdaContext context) {
   LambdaLogger.Log("Function name: " + context.FunctionName+"
");
   context.Logger.Log("RemainingTime: " + context.RemainingTime+"
");
   LambdaLogger.Log("LogGroupName: " + context.LogGroupName+"
");            
}

The corresponding output fo the code given above is shown here −

You can get the logs from CloudWatch as shown below −

Error Handpng in C# for Lambda Function

This section discusses about error handpng in C#. For error handpng,Exception class has to be extended as shown in the example shown below −

example

namespace example {            
   pubpc class AccountAlreadyExistsException : Exception {
      pubpc AccountAlreadyExistsException(String message) :
         base(message) {
      }
   }
} 
namespace example {
   pubpc class Handler {
     pubpc static void CreateAccount() {
       throw new AccountAlreadyExistsException("Error in AWS Lambda!");
     }
   }
}

The corresponding output for the code given above is as given below −

{
   "errorType": "LambdaException",
   "errorMessage": "Error in AWS Lambda!"
}