Créer un plug-in personnalisé

En un clin d’œil
Objectif: Créer un plug-in proxy de développement personnalisé
Heure : 30 minutes
Plugins: Plug-in personnalisé
Prerequisites :Set up Dev Proxy, .NET 10 SDK

Dans cet article, vous allez apprendre à créer un plug-in personnalisé pour le proxy de développement. En créant des plug-ins pour le proxy de développement, vous pouvez étendre ses fonctionnalités et ajouter des fonctionnalités personnalisées pour répondre à vos besoins.

Plug-ins HTTP et plug-ins stdio

Le proxy de développement prend en charge deux types de plug-ins en fonction du trafic que vous souhaitez intercepter :

Les plug-ins HTTP interceptent les requêtes et réponses HTTP(S) entre votre application et vos API. Ils héritent de classes et redéfinissent des méthodes comme et . Utilisez des plug-ins HTTP lorsque vous souhaitez simuler des erreurs d’API, ajouter des réponses fictives, valider des en-têtes de requête ou inspecter et modifier le trafic HTTP.
Les plug-ins Stdio interceptent les messages envoyés sur les entrées/sorties standard (stdin, stdout, stderr) entre un processus parent et un processus enfant. Ils implémentent l’interface (qui implémente également) et remplacent les méthodes telles que , et . Utilisez des plug-ins stdio lors de l’utilisation d’outils qui communiquent sur stdio, tels que les serveurs MCP (Model Context Protocol).

Une classe de plug-in unique peut gérer à la fois le trafic HTTP et stdio en remplaçant les méthodes des deux ensembles.

Prérequis

Avant de commencer à créer un plug-in personnalisé, vérifiez que vous disposez des conditions préalables suivantes :

.NET v10 Core SDK
La dernière version de la DLL Dev Proxy Abstractions, que vous trouverez dans la page Dev Proxy GitHub versions

Créer un plug-in

Suivez les étapes suivantes pour créer un projet :

Créez un projet de bibliothèque de classes à l’aide de la commande.
```
dotnet new classlib -n MyCustomPlugin
```
Ouvrez le projet nouvellement créé dans Visual Studio Code.
```
code MyCustomPlugin
```
Ajoutez la DLL Dev Proxy Abstractions () au dossier du projet.

Ajoutez la référence à votre fichier projet .

<ItemGroup>
  <Reference Include="DevProxy.Abstractions">
    <HintPath>.\DevProxy.Abstractions.dll</HintPath>
    <Private>false</Private>
    <ExcludeAssets>runtime</ExcludeAssets>
  </Reference>
</ItemGroup>

Ajoutez les packages NuGet requis pour votre projet.

dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Binder
dotnet add package Microsoft.Extensions.Logging.Abstractions
dotnet add package Unobtanium.Web.Proxy

Excluez les bibliothèques de liens dynamiques de dépendance (DLL) de la sortie de build en ajoutant une balise par dans le fichier.
```
<ExcludeAssets>runtime</ExcludeAssets>
```

Créez une classe qui hérite de la classe.

using DevProxy.Abstractions.Plugins;
using DevProxy.Abstractions.Proxy;
using Microsoft.Extensions.Logging;

namespace MyCustomPlugin;

public sealed class CatchApiCallsPlugin(
    ILogger<CatchApiCallsPlugin> logger,
    ISet<UrlToWatch> urlsToWatch) : BasePlugin(logger, urlsToWatch)
{
    public override string Name => nameof(CatchApiCallsPlugin);

    public override Task BeforeRequestAsync(ProxyRequestArgs e, CancellationToken cancellationToken)
    {
        Logger.LogTrace("{Method} called", nameof(BeforeRequestAsync));

        ArgumentNullException.ThrowIfNull(e);

        if (!e.HasRequestUrlMatch(UrlsToWatch))
        {
            Logger.LogRequest("URL not matched", MessageType.Skipped, new(e.Session));
            return Task.CompletedTask;
        }

        var headers = e.Session.HttpClient.Request.Headers;
        var header = headers.Where(h => h.Name == "Authorization").FirstOrDefault();
        if (header is null)
        {
            Logger.LogRequest($"Does not contain the Authorization header", MessageType.Warning, new LoggingContext(e.Session));
            return Task.CompletedTask;
        }

        Logger.LogTrace("Left {Name}", nameof(BeforeRequestAsync));
        return Task.CompletedTask;
    }
}

Générez votre projet.
```
dotnet build
```

Utiliser votre plug-in personnalisé

Pour utiliser votre plug-in personnalisé, vous devez l’ajouter au fichier de configuration du proxy de développement :

Ajoutez la nouvelle configuration du plug-in dans le fichier.

Fichier : devproxyrc.json

{
  "plugins": [{
    "name": "CatchApiCallsPlugin",
    "enabled": true,
    "pluginPath": "./bin/Debug/net10.0/MyCustomPlugin.dll",
  }]
}

Exécutez le proxy de développement.
```
devproxy
```

L’exemple de plug-in vérifie toutes les URL correspondantes pour l’en-tête requis . Si l’en-tête n’est pas présent, il affiche un message d’avertissement.

Ajout d’une configuration personnalisée à votre plug-in (facultatif)

Vous pouvez étendre la logique de votre plug-in en ajoutant une configuration personnalisée :

Héritez de la classe . Le proxy de développement expose au moment de l’exécution la configuration analysée du plug-in via la propriété .

using DevProxy.Abstractions.Plugins;
using DevProxy.Abstractions.Proxy;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;

namespace MyCustomPlugin;

public sealed class CatchApiCallsConfiguration
{
    public string? RequiredHeader { get; set; }
}

public sealed class CatchApiCallsPlugin(
    HttpClient httpClient,
    ILogger<CatchApiCallsPlugin> logger,
    ISet<UrlToWatch> urlsToWatch,
    IProxyConfiguration proxyConfiguration,
    IConfigurationSection pluginConfigurationSection) :
    BasePlugin<CatchApiCallsConfiguration>(
        httpClient,
        logger,
        urlsToWatch,
        proxyConfiguration,
        pluginConfigurationSection)
{
    public override string Name => nameof(CatchApiCallsPlugin);

    public override Task BeforeRequestAsync(ProxyRequestArgs e, CancellationToken cancellationToken)
    {
        Logger.LogTrace("{Method} called", nameof(BeforeRequestAsync));

        ArgumentNullException.ThrowIfNull(e);

        if (!e.HasRequestUrlMatch(UrlsToWatch))
        {
            Logger.LogRequest("URL not matched", MessageType.Skipped, new(e.Session));
            return Task.CompletedTask;
        }

        // Start using your custom configuration
        var requiredHeader = Configuration.RequiredHeader ?? string.Empty;
        if (string.IsNullOrEmpty(requiredHeader))
        {
            // Required header is not set, so we don't need to do anything
            Logger.LogRequest("Required header not set", MessageType.Skipped, new LoggingContext(e.Session));
            return Task.CompletedTask;
        }

        var headers = e.Session.HttpClient.Request.Headers;
        var header = headers.Where(h => h.Name == requiredHeader).FirstOrDefault();
        if (header is null)
        {
            Logger.LogRequest($"Does not contain the {requiredHeader} header", MessageType.Warning, new LoggingContext(e.Session));
            return Task.CompletedTask;
        }

        Logger.LogTrace("Left {Name}", nameof(BeforeRequestAsync));
        return Task.CompletedTask;
    }
}

Générez votre projet.
```
dotnet build
```

Mettez à jour votre fichier pour inclure la nouvelle configuration.

Fichier : devproxyrc.json

{
  "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v2.2.0/rc.schema.json",
  "plugins": [{
    "name": "CatchApiCallsPlugin",
    "enabled": true,
    "pluginPath": "./bin/Debug/net10.0/MyCustomPlugin.dll",
    "configSection": "catchApiCalls"
  }],
  "catchApiCalls": {
    "requiredHeader": "Authorization"
  }
}

Exécutez le proxy de développement.
```
devproxy
```

Voir aussi

Architecture du plug-in
Utiliser des configurations prédéfinies
Configurer le proxy de développement

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-06