在Azure函数中使用类

Question

I would like to create a class for external logging which is set up by initializing through the constructor. I then want to be able to use this class multiple times throughout the Function lifetime.

eg

using System.Net;

private static Logger logger;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, 
TraceWriter log, ExecutionContext executionContext)
{
    log.Info("C# HTTP trigger function processed a request.");

    string invocationId = executionContext.InvocationId.ToString();
    logger = new Logger(invocationId);

    logger.Log("Start"); 

    // parse query parameter
    string name = req.GetQueryNameValuePairs()
    .FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
    .Value;

    // Get request body
    dynamic data = await req.Content.ReadAsAsync<object>();

    // Set name to query string or body data
    name = name ?? data?.name;

    logger.Log("Finish");

    return name == null
    ? req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a name on the query string or in the request body")
    : req.CreateResponse(HttpStatusCode.OK, "Hello " + name);
}

public class Logger
{
    private string _invocationId;

    public Logger(string invocationId) 
    {
        _invocationId = invocationId;
    }

    public void Log(string message)
    {   
        message = $"{_invocationId} | {message}";
        // log to Splunk
    }
}

Is this the correct way to use my Logger class "globally" throughout the function?

private static Logger logger;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, 
TraceWriter log, ExecutionContext executionContext)
{
    log.Info("C# HTTP trigger function processed a request.");

    string invocationId = executionContext.InvocationId.ToString();
    logger = new Logger(invocationId);

Are there any implications of new'ing up classes?

This is a simplified version of what I am trying to achieve.

Answer 1

Your code doesn't make much sense: you have a static field, but you assign it on every invocation. Second invocation may override the value created by the first one, so you might get unpredictable results.

You should choose: either your field is static, you create it once and then use the instance on every subsequent invocation; or you just make a local variable and use it the way you do now.

The second option is preferred unless you really need to share something across requests. Avoid shared state if possible.

UPDATE:

Based on the question from your comment, here is what you could do:

public static Task<HttpResponseMessage> Run(
    HttpRequestMessage req, ExecutionContext executionContext)
{
    string invocationId = executionContext.InvocationId.ToString();
    var processor = new Processor(invocationId);
    return processor.Process(req);
}

public class Processor
{
    private Logger logger;

    public Processor(string invocationId)
    {
        this.logger = new Logger(invocationId);
    }

    public async Task<HttpResponseMessage> Process(HttpRequestMessage req)
    {
        await this.logger.Log("Start");
        await this.DoStep1();
        await this.DoStep2();
        await this.logger.Log("Finish"); 
    }

    private async Task DoStep1()
    {
        await this.logger.Log("Step 1");
        // ...
    }

    private async Task DoStep2()
    {
        await this.logger.Log("Step 2");
        // ...
    }
}

I'm not a particular fan of this style, but if that's what you want, it will work fine.