如何使用自定义特性跳过方法主体？C#字符串参数校验优化

Great question! If you want to replace those repetitive null/whitespace checks with a custom attribute, the key is to leverage AOP (Aspect-Oriented Programming)—because attributes themselves are just metadata markers; you need an interceptor to read the attribute and execute the validation logic. Let’s walk through two practical solutions, from quick-and-easy to fully custom:

方案1：使用PostSharp（快速实现） #

PostSharp is a popular .NET AOP framework that makes this kind of cross-cutting logic trivial. Here's how to set it up:

Step 1: Install PostSharp #

First, add the NuGet package to your project:

Install-Package PostSharp

Step 2: Create the Custom Attribute #

We'll create an aspect that runs before the method executes and checks the parameter:

using PostSharp.Aspects;
using System;
using System.Linq;

[Serializable]
public class StringNotNullOrWhiteSpaceAttribute : OnMethodBoundaryAspect
{
    private readonly string _parameterName;

    // Pass the name of the parameter to validate in the attribute constructor
    public StringNotNullOrWhiteSpaceAttribute(string parameterName)
    {
        _parameterName = parameterName;
    }

    // This method runs right before the target method is called
    public override void OnEntry(MethodExecutionArgs args)
    {
        base.OnEntry(args);
        
        // Find the parameter by name and get its value
        var parameter = args.Method.GetParameters().First(p => p.Name == _parameterName);
        var parameterValue = args.Arguments.GetArgument(parameter.Position);

        // Validate the string
        if (parameterValue is string str && string.IsNullOrWhiteSpace(str))
        {
            // Skip the method body entirely
            args.FlowBehavior = FlowBehavior.Return;
            args.ReturnValue = null;
        }
    }
}

Step 3: Apply the Attribute to Your Method #

Now just decorate your method with the attribute, specifying the parameter name:

public class MyService
{
    [StringNotNullOrWhiteSpace("testString")]
    public void Test(string testString)
    {
        // This code only runs if testString is not null/empty/whitespace
        Console.WriteLine($"Processing input: {testString}");
    }
}

Test It Out #

var service = new MyService();
service.Test(null);       // No output (method skipped)
service.Test("");         // No output
service.Test("   ");      // No output
service.Test("Hello!");   // Output: Processing input: Hello!

方案2：手动实现拦截器（无第三方依赖） #

If you don't want to use a commercial AOP library, you can build your own interceptor using Castle DynamicProxy (a free, open-source library for creating dynamic proxies).

Step 1: Install Castle.Core #

Add the NuGet package:

Install-Package Castle.Core

Step 2: Create the Marker Attribute #

First, a simple attribute to mark which methods need validation:

using System;

[AttributeUsage(AttributeTargets.Method)]
public class StringNotNullOrWhiteSpaceAttribute : Attribute
{
    public string ParameterName { get; }

    public StringNotNullOrWhiteSpaceAttribute(string parameterName)
    {
        ParameterName = parameterName;
    }
}

Step 3: Build the Interceptor #

This class will handle the validation logic when a marked method is called:

using Castle.DynamicProxy;
using System;
using System.Linq;

public class StringValidationInterceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        // Check if the method has our validation attribute
        var validationAttr = invocation.Method
            .GetCustomAttributes(typeof(StringNotNullOrWhiteSpaceAttribute), false)
            .FirstOrDefault() as StringNotNullOrWhiteSpaceAttribute;

        if (validationAttr != null)
        {
            // Find the parameter to validate
            var parameter = invocation.Method.GetParameters()
                .First(p => p.Name == validationAttr.ParameterName);
            var parameterIndex = Array.IndexOf(invocation.Method.GetParameters(), parameter);
            var parameterValue = invocation.Arguments[parameterIndex];

            // Skip the method if the string is invalid
            if (parameterValue is string str && string.IsNullOrWhiteSpace(str))
            {
                return;
            }
        }

        // Execute the original method if validation passes
        invocation.Proceed();
    }
}

Step 4: Create a Proxy for Your Class #

Castle DynamicProxy requires methods to be virtual (or you can use interfaces). Here's how to create a proxy instance:

public class MyService
{
    [StringNotNullOrWhiteSpace("testString")]
    public virtual void Test(string testString)
    {
        Console.WriteLine($"Processing input: {testString}");
    }
}

// Helper method to create proxy instances
public static T CreateValidatingProxy<T>() where T : class
{
    var proxyGenerator = new ProxyGenerator();
    return proxyGenerator.CreateClassProxy<T>(new StringValidationInterceptor());
}

Test the Proxy #

var service = CreateValidatingProxy<MyService>();
service.Test("   ");      // No output
service.Test("Hi there"); // Output: Processing input: Hi there

备选方案：静态辅助类（简单无AOP） #

If AOP feels overkill for your use case, a static guard class is a lightweight alternative that still reduces repetition:

public static class Guard
{
    public static void AgainstNullOrWhiteSpace(string value, string parameterName)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            // You can also throw an exception instead of returning, depending on your needs
            return;
        }
    }
}

// Usage in your method
public void Test(string testString)
{
    Guard.AgainstNullOrWhiteSpace(testString, nameof(testString));
    // Do Stuff...
}

Key Notes #

• Attributes don't execute logic on their own—you always need an interceptor or aspect framework to trigger the validation.
• For Castle DynamicProxy, target methods must be virtual or part of an interface.
• You can extend these examples to support multiple parameters, custom error handling (like throwing ArgumentException), or other validation rules.

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