Comment intercepter les appels de méthode en C# sans utiliser les bibliothèques AOP ?

Intercepter les appels de méthode C# sans bibliothèques AOP externes : solutions de contournement et limitations

Le manque inhérent de C# de fonctionnalités AOP intégrées présente des défis lorsqu'il s'agit d'intercepter des appels de méthode sans s'appuyer sur des bibliothèques tierces. Cependant, plusieurs stratégies peuvent se rapprocher de cette fonctionnalité, chacune avec ses propres compromis :

Approches de l'interception des appels de méthode :

• Attributs personnalisés et MarshalByRefObject : Cette technique exploite les attributs personnalisés (par exemple, [Log]) héritant de IMessageSink. Cependant, cela nécessite d'hériter de MarshalByRefObject, ce qui peut introduire une surcharge de performances.

• Injection de code dynamique (réflexion) : La réflexion à l'exécution permet l'injection de code dans les méthodes, permettant ainsi l'interception. Cette approche est nettement plus complexe, exigeant une compréhension approfondie de la réflexion et ayant potentiellement un impact sur la maintenabilité.

• Exploiter un conteneur IoC : Les conteneurs d'injection de dépendance (DI) offrent un mécanisme pour intercepter les appels de méthode, mais pas de manière exhaustive pour toutes les méthodes. Son adéquation dépend des exigences spécifiques d'interception.

• Modification de la méthode de l'appelant : La solution la plus simple, si possible, implique de modifier directement la méthode de l'appelant pour inclure la journalisation ou une autre logique d'interception avant et après l'appel de la méthode cible. C'est simple mais nécessite de modifier le code existant.

Exemple illustratif : modification de la méthode de l'appelant

L'exemple suivant illustre une interception simple utilisant la modification de la méthode de l'appelant :

<code class="language-csharp">public class Caller
{
    public static void Call()
    {
        Traced traced = new Traced();

        Logger.LogMethodStart(typeof(Traced).GetMethod(nameof(Traced.Method1)), new object[] { "name", 5 });
        traced.Method1("name", 5);
        Logger.LogMethodEnd(typeof(Traced).GetMethod(nameof(Traced.Method1)));

        Logger.LogMethodStart(typeof(Traced).GetMethod(nameof(Traced.Method2)), new object[] { new object() });
        traced.Method2(new object());
        Logger.LogMethodEnd(typeof(Traced).GetMethod(nameof(Traced.Method2)));
    }
}</code>

Cette approche ajoute directement les appels de journalisation autour des invocations de la méthode cible. Notez qu'une classe Logger devrait être implémentée séparément pour gérer les détails de la journalisation. Cette méthode est la moins intrusive si la modification de l'appelant est acceptable. Les autres options proposent des solutions plus générales mais au prix d'une complexité accrue.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!