如何利用NLog自动记录方法传入参数，无需手动编写日志代码？

Absolutely! You don’t have to slog through writing manual log statements for every method’s parameters—NLog offers several clean, automated ways to handle this. Let’s walk through the most practical options:

1. Use NLog's Built-in MethodCallParameters Layout Renderer #

This is the simplest, no-code-change approach. NLog has a built-in layout renderer that automatically captures method parameter names and values, which you can add directly to your logging configuration.

Example NLog.config Setup #

Add the ${methodCallParameters} renderer to your target layout (we’ll use JSON for structured logging, which makes parameter data easy to query later):

<configuration>
  <nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

    <targets>
      <target name="jsonFile" xsi:type="File" fileName="logs/app-${shortdate}.log">
        <layout type="JsonLayout">
          <attribute name="timestamp" layout="${longdate}" />
          <attribute name="level" layout="${level}" />
          <attribute name="method" layout="${method}" />
          <!-- Capture parameters in "name: value" format -->
          <attribute name="parameters" layout="${methodCallParameters:format=name:value}" />
        </layout>
      </target>
    </targets>

    <rules>
      <logger name="*" minlevel="Info" writeTo="jsonFile" />
    </rules>
  </nlog>
</configuration>

Customization Options #

• Adjust the format parameter to control how parameters are displayed:
  • name: Only show parameter names (e.g., id, name)
  • value: Only show values (e.g., 123, "Alice")
  • name:value: Show both (default, e.g., id: 123, name: "Alice")
• Add :excludeTypes to skip logging parameters of specific types (e.g., ${methodCallParameters:excludeTypes=System.String})

Note: This renderer relies on call stack information, so for extremely high-throughput systems, test performance impact—though it’s negligible for most typical applications.

2. AOP Interception (For Full Control) #

If you need more flexibility—like logging only specific methods, customizing parameter serialization, or adding post-execution logging (e.g., return values)—use Aspect-Oriented Programming (AOP) interceptors.

Example with Castle DynamicProxy #

1. First, install the Castle.Core NuGet package.
2. Create an interceptor class that handles logging:

using Castle.DynamicProxy;
using Microsoft.Extensions.Logging;

public class MethodParameterLogger : IInterceptor
{
    private readonly ILogger<MethodParameterLogger> _logger;

    public MethodParameterLogger(ILogger<MethodParameterLogger> logger)
    {
        _logger = logger;
    }

    public void Intercept(IInvocation invocation)
    {
        // Capture parameter names and values before executing the method
        var parameterDetails = invocation.Arguments
            .Select((value, index) => 
                $"{invocation.Method.GetParameters()[index].Name}: {FormatValue(value)}")
            .JoinToString(", ");

        _logger.LogInformation("Executing method: {MethodName} | Parameters: {Parameters}",
            invocation.Method.Name, parameterDetails);

        // Run the actual method
        invocation.Proceed();

        // Optional: Log the return value
        _logger.LogInformation("Method {MethodName} completed | Return value: {ReturnValue}",
            invocation.Method.Name, FormatValue(invocation.ReturnValue));
    }

    private string FormatValue(object value)
    {
        // Add custom serialization logic here (e.g., JSON for complex objects)
        return value?.ToString() ?? "null";
    }
}

3. Register your interceptor with your dependency injection container (e.g., in ASP.NET Core):

services.AddScoped<MethodParameterLogger>();
services.AddTransient(typeof(IService<>), typeof(Service<>));
// Use a proxy generator to wrap services with the interceptor
services.AddSingleton<IProxyGenerator, ProxyGenerator>();

You can also add a custom attribute (e.g., [LogParameters]) to mark which methods should be logged, then modify the interceptor to only process methods with that attribute.

3. Structured Logging Best Practices #

Whichever approach you choose, using structured logging (like JSON) makes it easy to filter, search, and analyze parameter data later. NLog’s JsonLayout automatically serializes parameters into machine-readable format, which is far more useful than plain text logs for debugging.

Pick the method that fits your workflow: the built-in MethodCallParameters renderer is ideal for quick, zero-code setup, while AOP interceptors give you full control over when and how parameters are logged.

内容的提问来源于stack exchange，提问作者chobo2