> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/fr/plateforme/plugins/c-api-endpoints.md).

# Points de terminaison API C\#

**Identifier:** `PowerShellUniversal.Language.CSharp`

Cette extension crée un environnement basé sur C# qui peut être utilisé pour créer des points de terminaison API avec du code C#. Les API créées avec C# sont beaucoup plus rapides que les points de terminaison basés sur PowerShell. Les points de terminaison s'exécutent directement dans le service PowerShell Universal. Toute exception levée depuis votre point de terminaison sera gérée et un code de statut valide sera retourné à l'appelant.

Vous devez créer des points de terminaison avec le paramètre -Path et spécifier l'environnement `C#` pour que le point de terminaison fonctionne correctement.

```powershell
New-PSUEndpoint -Url /csharp -Path csharp.cs -Environment 'C#'
```

**Définir un point de terminaison**

Dans le point de terminaison C#, deux classes présentent un intérêt. La première est la variable `request` qui est transmise au point de terminaison. Il s'agit d'un objet `ApiRequest`.

```csharp
public class ApiRequest
{
    public long Id { get; set; }
    public ICollection<KeyValue> Variables { get; set; } = new List<KeyValue>();
    public IEnumerable<ApiFile> Files { get; set; } = new List<ApiFile>();
    public string Url { get; set; }
    public ICollection<KeyValue> Headers { get; set; } = new List<KeyValue>();
    public byte[] Data { get; set; }
    public int ErrorAction { get; set; }
    public ICollection<KeyValue> Parameters { get; set; } = new List<KeyValue>();
    public string Method { get; set; }
    public ICollection<KeyValue> Cookies { get; set; } = new List<KeyValue>();
    public string ClaimsPrincipal { get; set; }
    public string ContentType { get; set; }
    public string[] Roles { get; set; }
}
```

Dans votre point de terminaison, vous pouvez accéder à cette variable automatiquement.

```csharp
if (request.ContentType == "application/json")
{
     // Do some stuff with JSON
}
```

Le point de terminaison doit retourner un objet `ApiResponse`. Cet objet possède la définition suivante.

```csharp
public class ApiResponse
{
    public int StatusCode { get; set; } = 200;
    public string Body { get; set; }
    public List<KeyValue> Cookies { get; set; } = new List<KeyValue>();
    public byte[] Data { get; set; } = Array.Empty<byte>();
    public string ContentType { get; set; } = "text/plain";
    public List<KeyValue> Headers { get; set; } = new List<KeyValue>();
    public ApiFile File { get; set; }
}
```

Vous pouvez retourner une réponse en créant un nouvel objet et en le retournant depuis votre point de terminaison.

```csharp
return new ApiResponse {
    StatusCode = 401
};
```

Lors de la définition du contenu d'un point de terminaison, sachez que le code est ajouté à une classe nommée dynamiquement avec une unique fonction Execute. Votre code doit être une syntaxe valide pour un tel fichier source.

```csharp
using PowerShellUniversal;

public class c{id} : ExecutionClass {{ 
    public static ApiResponse Execute(ApiRequest request) 
    {{ 
        {fileContents} 

        return new ApiResponse();
    }} 
}}";
```

Vous pouvez accéder au conteneur de services PowerShell Universal dans votre point de terminaison en accédant à la propriété `ServiceProvider`. Nous ne documentons pas actuellement les services internes de PowerShell Universal.

```csharp
var database = ServiceProvider.GetService(typeof(IDatabase));
```

### Références

Vous pouvez contrôler les assemblages référencés en utilisant le mot-clé `#ref`. La valeur peut être un fichier DLL dans le répertoire d'installation de PowerShell Universal, ou le chemin complet vers un autre assemblage.

```csharp
#ref PowerShellUniversal.Apis.dll
#ref C:\assemblies\markdiag.dll
```

### Utilisation des espaces de noms

Vous pouvez référencer un espace de noms en utilisant le mot-clé `#using`.

```csharp
#using System.Management.Automation
```

### Variables

Vous pouvez accéder aux variables dans les points de terminaison C# avec les méthodes `GetVariable`, `GetSecretString` et `GetSecretCredential`.

```csharp
return new ApiResponse {
    StatusCode = 200
    Body = GetVariable("MyVar").ToString()
};
```

Pour accéder à un `PSCredential`, vous pouvez procéder comme suit.

```csharp
#ref System  
#ref System.Management.Automation

return new ApiResponse { 
    StatusCode = 200, 
    Body = GetSecretCredential("MyCred").UserName.ToString() 
};
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/fr/plateforme/plugins/c-api-endpoints.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.