Início / coding / Perguntas / 79585291
Accepted
RotundChinchilla
Asked: 2025-04-22 04:30:54 +0800 CST

No C# 7.3, é possível escrever um atributo de parâmetro de método que modifica o argumento antes da execução do corpo do método?

  • 772

Descobri que estou regularmente Trim()inserindo espaços em branco nos valores de string passados ​​para minhas funções. Isso geralmente se parece com:

public void MyFunction(string param) {
    if (param != null) { // Null check is necessary since we are in C# 7.3.
        param = param.Trim();
    }

    // ...now we can work with "param" safely.
}

Sei que esta verificação de nulos e corte poderia ser resumida em uma única linha, mas acho que seria possível simplificar ainda mais usando um atributo de parâmetro. É possível decorar um parâmetro com um atributo para lidar com essa verificação e corte de nulos fora do conteúdo do método?

Exemplo:

public void MyFunction([Trim] string param) {
    // ...[Trim] replaces "param" with a trimmed version, if "param" is not null.

    // ...now we can work with "param" safely.
}

public void MyOtherFunction(string paramOne, [Trim] string paramTwo) {
    // "paramOne" remains untrimmed, "paramTwo" is trimmed.
}

// How would one write this hypothetical TrimAttribute in C# 7.3? Is it even possible?

Observações:

  • Estou começando a suspeitar que isso pode não ser possível, pelo menos não sem algumas dependências externas. Por exemplo, sei que o ASP.NET MVC oferece ActionFilterAttributeacesso aos parâmetros de métodos dentro de uma ActionExecutingContextclasse. Mas ActionFilterAttributeele só pode decorar uma classe ou método, não um parâmetro. Além disso, poder modificar livremente um argumento com um atributo pode abrir muitas oportunidades para abusos por parte dos desenvolvedores, então é compreensível que tal coisa não seja possível.
c#

1 respostas

  1. Best Answer

    Como sugerido acima, a maneira mais limpa seria usar um interceptador de métodos. Acho que algo como https://www.postsharp.net/metalama resolveria o problema.

    O que se segue não é o ideal, mas pode ajudar. TrimmedString aceita nulos, pois você tinha uma verificação de nulos no seu exemplo.

    internal class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Start");

        Foo("  Space at start and end  ");
        Foo("  Space at start");
        Foo("Space at end  ");
        Foo("No space");
        Foo((string?)null);

        Console.WriteLine("Done");
    }

    static void Foo(TrimmedString trimmedString)
    {
        // This method accepts a TrimmedString parameter
        Console.WriteLine($"Received trimmed string: '{trimmedString}'");
    }
}

public readonly struct TrimmedString
{
    public string? Value { get; }

    public TrimmedString(string? value)
    {
        Value = value?.Trim();
    }

    public static implicit operator string?(TrimmedString trimmedString)
    {
        return trimmedString.Value;
    }

    public static implicit operator TrimmedString(string? value)
    {
        return new TrimmedString(value);
    }

    public override readonly string? ToString()
    {
        return Value;
    }

    // can add Equals, GetHashCode, etc. as needed
}
    • 2

relate perguntas