# General Translation Knowledge Base: Comment traduire les fichiers .resx dans une application .NET ?
URL: https://generaltranslation.com/fr/kb/translate-resx-files.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Créez pour chaque fichier .resx neutre une copie nommée d’après la culture, par exemple Resources.fr.resx, et traduisez uniquement la valeur de chaque entrée, sans modifier les noms, les commentaires ni les espaces réservés comme {0}. .NET compile chaque culture dans un assembly satellite et se rabat de fr-CA sur fr, puis sur le fichier neutre. La CLI de General Translation génère ces fichiers de culture à partir de la source neutre.
Category: Traduction
Last updated: 2026-10-28
Authors: General Translation Team
Published: 2026-10-28

Un fichier .resx est une liste XML de ressources nommées. Le fichier neutre, par exemple `Resources.resx`, contient votre langue par défaut. Chaque traduction est un fichier placé à côté, dont le nom inclut la culture (par exemple `Resources.fr.resx`) et qui reprend les mêmes noms avec des valeurs traduites. À l’exécution, `ResourceManager` choisit le fichier correspondant à la culture d’IU actuelle et se rabat sur les cultures parentes pour tout élément manquant.

## Contenu d'un fichier .resx

Chaque ressource est un élément `<data>`. Son attribut `name` correspond à la clé que votre code recherche, `<value>` contient le texte, et un `<comment>` facultatif indique au traducteur à quoi sert ce texte. Voici un extrait (un fichier réel commence également par un bloc de schéma et des entrées `<resheader>` que Visual Studio génère pour vous) :

```xml title="Resources/SharedResource.resx"
<data name="Checkout" xml:space="preserve">
  <value>Checkout</value>
  <comment>Button that starts payment for the items in the cart.</comment>
</data>
<data name="ItemsInCart" xml:space="preserve">
  <value>You have {0} items in your cart.</value>
  <comment>{0} is the number of items.</comment>
</data>
```

Le fichier français reprend les mêmes attributs `name`, avec des valeurs en français. Seules les valeurs de type chaîne de caractères changent. Les noms servent de clés de recherche, et les ressources autres que des chaînes de caractères, comme les images (qui portent un attribut `type` et souvent un attribut `mimetype`), restent généralement inchangées. Microsoft recommande de modifier les fichiers .resx dans Visual Studio plutôt qu&#39;à la main, car le XML doit rester bien formé et conforme à son format prédéfini ([Microsoft : Create resource files](https://learn.microsoft.com/en-us/dotnet/core/extensions/create-resource-files)).

## Comment .NET trouve la bonne traduction

Donnez à chaque traduction le même nom racine que le fichier neutre, en plaçant la culture avant l&#39;extension : `Resources.fr.resx`, `Resources.fr-CA.resx`. Lors de la compilation, les ressources neutres sont incorporées dans l&#39;assembly principal, et chaque culture est compilée dans un assembly satellite placé dans un dossier portant le nom de la culture, par exemple `fr/MyApp.resources.dll`.

Lorsque l&#39;application demande une chaîne de caractères, .NET cherche d&#39;abord dans l&#39;assembly satellite de la culture demandée, puis dans celui de sa culture parente, et ainsi de suite, avant de se rabattre sur les ressources neutres. Pour une requête `fr-CA`, l&#39;ordre est donc `fr-CA`, puis `fr`, puis le fichier neutre. Si aucun fichier de ressources n&#39;existe, pas même pour la culture par défaut, .NET lève une exception `MissingManifestResourceException` ou `MissingSatelliteAssemblyException`. Sous Linux et macOS, le nom du dossier de culture doit correspondre exactement à `CultureInfo.Name`, casse comprise ([Microsoft : Package and deploy resources](https://learn.microsoft.com/en-us/dotnet/core/extensions/package-and-deploy-resources)).

Ce mécanisme de repli vous permet de traduire une seule fois pour toute une famille de régions. Microsoft recommande un fichier `de` unique pour les utilisateurs en `de-DE`, `de-AT` et `de-CH`, les fichiers régionaux ne contenant que les chaînes qui diffèrent. En contrepartie, une traduction manquante ne lève jamais d&#39;exception : l&#39;utilisateur voit la langue neutre, et rien ne vous le signale lors de la compilation. (Voir [Que sont les codes de paramètres régionaux ?](/kb/locale-codes).)

## Utiliser les fichiers .resx dans ASP.NET Core, Windows Forms et WPF

### ASP.NET Core

Enregistrez la localisation, choisissez les cultures prises en charge et ajoutez le middleware ([Microsoft : Select language and culture](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/localization/select-language-culture)) :

```csharp title="Program.cs"
builder.Services.AddLocalization(options => options.ResourcesPath = "Resources");

builder.Services.Configure<RequestLocalizationOptions>(options =>
{
    var supportedCultures = new[] { "en-US", "fr" };
    options.SetDefaultCulture(supportedCultures[0])
        .AddSupportedCultures(supportedCultures)
        .AddSupportedUICultures(supportedCultures);
});

var app = builder.Build();

// Détermine la culture à partir de la chaîne de requête, d'un cookie ou de l'en-tête Accept-Language, dans cet ordre.
app.UseRequestLocalization();
```

Injectez ensuite `IStringLocalizer<T>` et recherchez les chaînes par leur nom, en passant les arguments de formatage à la suite : `localizer["ItemsInCart", count]`. Les fichiers de ressources sont nommés d&#39;après le nom de type complet de la classe, sans le nom de l&#39;assembly : `Controllers.HomeController` lit donc `Controllers.HomeController.fr.resx` dans le dossier `Resources` (ou `HomeController.fr.resx` dans `Resources/Controllers`), et une classe marqueur vide `SharedResource` regroupe les chaînes partagées dans toute l&#39;application. `SupportedUICultures` détermine les fichiers .resx lus ; `SupportedCultures` détermine le formatage des dates et des nombres ([Microsoft : Provide localized resources](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/localization/provide-resources)).

`IStringLocalizer` renvoie la clé elle-même en l&#39;absence de traduction ; Microsoft documente donc un workflow sans aucun fichier .resx neutre : `localizer["About Title"]` affiche « About Title » en anglais ([Microsoft : Make content localizable](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/localization/make-content-localizable)). Cela suffit pour l&#39;affichage, mais ne laisse aucun fichier source exploitable par un traducteur ou un outil. Si vous souhaitez générer des traductions à partir d&#39;un fichier, utilisez des clés nommées avec un fichier .resx neutre dont les valeurs contiennent le texte anglais : c&#39;est l&#39;approche traditionnelle, également documentée par Microsoft.

### Windows Forms et WPF

Dans Windows Forms, définissez la propriété **Localizable** d&#39;un formulaire sur `true`, puis choisissez une culture dans sa propriété **Language** ; lorsque vous modifiez du texte dans le concepteur, Visual Studio l&#39;enregistre dans un fichier propre à la culture, par exemple `Form1.es-ES.resx` ([Microsoft : Localizing a hybrid application](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/walkthrough-localizing-a-hybrid-application)). Les fichiers générés par le concepteur contiennent aussi des entrées qui ne correspondent pas à du texte, comme les noms commençant par `>>`. Les applications WPF peuvent charger des chaînes .resx via `ResourceManager` ; la procédure pas à pas de Microsoft consacrée à la localisation XAML s&#39;appuie sur l&#39;outil LocBaml, que Microsoft présente comme un exemple qui « is not a production-ready application » ([Microsoft : Localize a WPF app](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/how-to-localize-an-application)).

### Les modifier dans Visual Studio

Depuis la version 17.11 de Visual Studio 2022, le Resource Explorer affiche côte à côte toutes les cultures de chaque fichier .resx. Faites un clic droit sur un fichier .resx et choisissez **Open With &gt; Resource Explorer** (ou appuyez sur **Ctrl+Alt+R**). Il signale les traductions manquantes (« No value ») ainsi que les espaces réservés qui diffèrent de ceux de la culture neutre, par exemple `Hello, {name}!` comparé à `Hola, {nombre}!` ([Microsoft : Manage application resources](https://learn.microsoft.com/en-us/visualstudio/ide/managing-application-resources-dotnet)).

## Ce qui casse lorsque vous traduisez des fichiers .resx

* **Espaces réservés.** Les éléments de format composite .NET se présentent sous la forme `{index[,width][:formatString]}`, par exemple `{0}`, `{1,-10}` ou `{0:N2}`. Une traduction peut les réordonner ou en utiliser un deux fois, mais un élément de format qui pointe au-delà des arguments lève une exception `FormatException` à l&#39;exécution, et un élément supprimé fait disparaître la valeur sans le moindre avertissement. Les accolades littérales s&#39;écrivent `{{` et `}}` ([Microsoft : Mise en forme composite](https://learn.microsoft.com/en-us/dotnet/standard/base-types/composite-formatting)).
* **Noms.** Si l&#39;attribut `name` est traduit, la recherche ne trouve rien et la chaîne de caractères se rabat sur la langue neutre.
* **XML.** Une valeur contenant `&` ou `<` doit rester échappée sous la forme `&amp;` et `&lt;`, faute de quoi le fichier ne compilera pas.
* **Touches d&#39;accès.** Dans Windows Forms, `&File` souligne le F. La traduction doit contenir exactement un `&` placé devant une lettre appropriée.
* **Commentaires.** Les commentaires servent de contexte aux traducteurs et ne sont pas du texte à traduire. Le guide du Windows App SDK de Microsoft précise que les traducteurs n&#39;ont pas besoin de les traduire ([Microsoft : Localiser des chaînes](https://learn.microsoft.com/en-us/windows/apps/windows-app-sdk/mrtcore/localize-strings)).
* **Désynchronisation.** Lorsqu&#39;un développeur ajoute un nom au fichier neutre, chaque fichier de culture doit également le contenir. Le mécanisme de repli masque cet écart : vérifiez donc l&#39;absence de valeurs manquantes avant chaque livraison.

## Méthodes pour traduire les fichiers .resx

| Approche                                                    | Conserve les noms et les ressources non textuelles                                                                                   | Vérification des espaces réservés                                                                                              | Synchronisation des cultures                                                                                                            | Adaptée lorsque                                                                         |
| ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
| Resource Explorer de Visual Studio, à la main               | Oui                                                                                                                                  | Avertit en cas d’incohérence                                                                                                   | Affiche les valeurs manquantes par culture                                                                                              | Une ou deux langues parlées par un membre de l’équipe                                   |
| Traducteurs ou système de gestion de la traduction (TMS)    | Oui, si le TMS sait analyser les fichiers .resx                                                                                      | Dépend de ses contrôles d’assurance qualité                                                                                    | Via la synchronisation du dépôt par le TMS                                                                                              | Des traducteurs professionnels ou un prestataire prennent en charge le travail          |
| Script appelant une API de traduction automatique ou un LLM | Uniquement si votre script analyse le XML et n’envoie que les valeurs                                                                | À vous de les écrire                                                                                                           | Vous relancez le script et comparez le diff                                                                                             | Vous assumerez la maintenance du script et de sa validation                             |
| Coller le fichier dans un assistant conversationnel         | Rien ne le garantit                                                                                                                  | Aucune                                                                                                                         | Manuelle                                                                                                                                | Un fichier ponctuel que vous vérifierez ligne par ligne                                 |
| CLI de General Translation                                  | Ne traduit que les valeurs de type chaîne de caractères ; les noms, les commentaires et les ressources non textuelles sont conservés | Une traduction qui modifie ou supprime un espace réservé est écartée : .NET utilise alors la valeur de repli pour cette entrée | Réutilise les traductions des entrées inchangées ; exécutez [`gt translate`](/docs/cli/reference/commands/translate) à chaque livraison | Les fichiers de ressources sont versionnés dans le dépôt et évoluent à chaque livraison |

Utilisez le Resource Explorer pour une ou deux langues qu’un collègue peut relire. Optez pour un [TMS](/kb/what-is-a-translation-management-system) lorsque des traducteurs professionnels travaillent en dehors de la base de code. Choisissez General Translation lorsque les fichiers .resx évoluent à chaque livraison et que les fichiers traduits doivent être commités avec le code. (Voir [General Translation ou un TMS](/kb/general-translation-vs-tms).)

## Comment traduire des fichiers .resx avec General Translation

La CLI de General Translation, `gt`, traduit les fichiers .resx, ainsi que les fichiers `.resw` qui partagent le même schéma, via la clé de fichier `resx` (`gt` 2.23.1 ou version ultérieure). Le nom du fichier neutre ne comporte aucune culture : faites donc pointer `include` vers ce fichier, excluez les fichiers traduits qui l&#39;accompagnent et utilisez `transform` pour insérer la culture avant l&#39;extension :

```json title="gt.config.json"
{
  "defaultLocale": "en",
  "locales": ["fr", "es-MX"],
  "files": {
    "resx": {
      "include": ["Resources/*.resx"],
      "exclude": ["Resources/*.[locales].resx"],
      "transform": {
        "match": "\\.resx$",
        "replace": ".{locale}.resx"
      }
    }
  }
}
```

Dans le dossier `Resources`, cette configuration lit `Controllers.HomeController.resx` et écrit `Controllers.HomeController.fr.resx` et `Controllers.HomeController.es-MX.resx`, en conservant intacts les noms à points d&#39;ASP.NET Core. Indiquez dans `locales` toutes les cultures que vous livrez déjà : l&#39;exclusion `[locales]` n&#39;ignore les fichiers traduits que pour les paramètres régionaux configurés, si bien qu&#39;un fichier `Resources.de.resx` absent de la liste serait lu comme un fichier source. Pour les projets UWP et WinUI qui rangent les fichiers `.resw` dans un dossier par langue, utilisez `"include": ["Strings/[locale]/Resources.resw"]` sans `transform`.

La CLI nécessite Node.js 20 ou une version ultérieure, même dans un dépôt .NET ; installez-la comme indiqué dans le [Démarrage rapide de la CLI](/docs/cli/quickstart), connectez-vous avec [`npx gt login`](/docs/cli/reference/commands/login) et définissez `GT_PROJECT_ID` ([informations d’authentification de la CLI](/docs/cli/guides/configuring#credentials)). Si votre application contient déjà des traductions, importez-les d&#39;abord avec [`npx gt upload`](/docs/cli/reference/commands/upload). Exécutez ensuite [`npx gt translate`](/docs/cli/reference/commands/translate). En CI, stockez dans `GT_API_KEY` une clé API de projet disposant des autorisations **Files &gt; Write** et **Translation queue &gt; Enabled**.

Le fichier traduit est une copie du fichier source dont seules les valeurs de type chaîne de caractères sont remplacées : les noms, l&#39;ordre des entrées, le schéma et les blocs `<resheader>`, les commentaires et les ressources non textuelles restent inchangés. Les entrées comportant un `mimetype`, un type autre que `System.String`, un nom de concepteur `>>` ou une valeur vide ne sont pas envoyées en traduction. Chaque `<comment>` est transmis comme contexte, et les instructions de localisation Microsoft telles que `{Locked}` figurant dans un commentaire sont respectées. Les espaces réservés tels que `{0}`, `{0:N2}`, `{1,-10}`, `{count}` et les accolades doublées sont conservés, une touche d&#39;accès `&` unique reste placée devant une lettre appropriée, et le fichier téléchargé conserve l&#39;encodage et la marque d&#39;ordre des octets (BOM) du fichier source. (Consultez la [référence .resx](/docs/cli/reference/formats/resx-files).)

Relisez les traductions dans le [tableau de bord](/docs/platform/dashboard/guides/reviewing-translations) ou dans Visual Studio, et exécutez [`npx gt save-local`](/docs/cli/reference/commands/save-local) après avoir modifié des fichiers localement afin que les exécutions suivantes conservent vos modifications. Un [groupe de contexte](/docs/platform/dashboard/guides/defining-context-for-translations) applique à vos ressources .NET le même glossaire et les mêmes instructions personnalisées qu&#39;aux [fichiers JSON](/kb/translate-json-files) de votre application web : un nom de produit est ainsi traduit de la même façon des deux côtés.

## Questions fréquentes

### Quelle est la différence entre .resx et .resw ?

Ils utilisent le même schéma. Les applications UWP et WinUI placent leurs fichiers `.resw` dans un dossier par langue, par exemple `Strings/en-US/Resources.resw` et `Strings/de-DE/Resources.resw`, au lieu d&#39;indiquer la culture dans le nom du fichier ([Microsoft : Localize strings](https://learn.microsoft.com/en-us/windows/apps/windows-app-sdk/mrtcore/localize-strings)).

### Faut-il un fichier distinct pour fr-CA si j&#39;ai déjà fr ?

Non. Une requête `fr-CA` se replie sur `fr` pour tout nom manquant : il suffit donc d&#39;ajouter un fichier `fr-CA` contenant uniquement les chaînes qui diffèrent.

### Pourquoi mon application ASP.NET Core s&#39;affiche-t-elle toujours en anglais après l&#39;ajout d&#39;un fichier en français ?

Vérifiez que `fr` figure bien dans `SupportedUICultures`, que le nom du fichier correspond au nom de type de la classe et, sous Linux ou macOS, que le dossier de culture dans les artefacts de compilation (par exemple `fr`) correspond exactement à `CultureInfo.Name`, casse comprise.

## Points clés

* Chaque traduction est un fichier .resx placé à côté de l&#39;original, avec la culture dans son nom, par exemple `Resources.fr.resx`. Traduisez les valeurs, jamais les attributs `name`.
* .NET se rabat de `fr-CA` sur `fr`, puis sur les ressources neutres : en cas de traduction manquante, c&#39;est la langue neutre qui s&#39;affiche, sans erreur.
* Un élément de format qui pointe au-delà des arguments fournis lève une exception `FormatException`. Vérifiez les espaces réservés de type `{0}` dans chaque traduction.
* Le Resource Explorer de Visual Studio 2022 17.11 signale les valeurs manquantes et les espaces réservés incohérents d&#39;une culture à l&#39;autre.
* La CLI de General Translation traduit les fichiers .resx et .resw grâce à la clé `resx` (2.23.1+). Elle conserve les noms, les commentaires et les ressources qui ne sont pas des chaînes de caractères, et écarte toute traduction qui casse un espace réservé.

## Related questions

- [Comment traduire des fichiers JSON i18n ?](https://generaltranslation.com/fr/kb/translate-json-files.mdx): Traduisez uniquement les valeurs de type chaîne de caractères d’un fichier JSON de paramètres régionaux. Conservez telles quelles les clés non plurielles, les espaces réservés comme {{name}} et les balises, mais attendez-vous à ce que les clés de pluriel varient selon la langue : le polonais exige inbox_few et inbox_many. Utilisez un outil ou une API qui prend en charge le format, puis analysez et validez le résultat avant la relecture.
- [Comment traduire des fichiers PO et POT ?](https://generaltranslation.com/fr/kb/translate-po-files.mdx): Remplissez chaque msgstr, y compris chaque forme du pluriel exigée par l’en-tête Plural-Forms, et laissez msgid, msgctxt et les espaces réservés inchangés. Exécutez msgfmt --check pour contrôler les en-têtes, le nombre de formes du pluriel et les espaces réservés des entrées dotées d’une option de format, puis vérifiez séparément qu’aucun msgstr n’est vide. La CLI de General Translation génère un fichier PO traduit pour chaque langue à partir de votre modèle POT.
- [Qu’est-ce qu’un système de gestion de la traduction (TMS) ?](https://generaltranslation.com/fr/kb/what-is-a-translation-management-system.mdx): Un système de gestion de la traduction (TMS) est un logiciel qui stocke votre contenu source et ses traductions, et qui pilote le workflow de traduction : mémoire de traduction, glossaires, relecture, traduction automatique et intégrations. Sa mémoire de traduction réutilise les traductions existantes par correspondance exacte ou approximative (fuzzy match). Crowdin, Lokalise, Phrase, Smartling et Transifex en sont des exemples courants.
- [General Translation ou un TMS (Crowdin, Lokalise, Phrase)](https://generaltranslation.com/fr/kb/general-translation-vs-tms.mdx): Choisissez General Translation lorsque les développeurs veulent que la génération des traductions, le contexte tiré du code et la relecture soient liés aux livraisons du produit. Conservez vos catalogues et votre bibliothèque de rendu existants, ou rédigez du JSX intégré sans clés de traduction. Un TMS convient aux programmes centrés sur les prestataires linguistiques, les outils de TAO et l’échange XLIFF ; ses intégrations peuvent automatiser les transferts de fichiers.
- [Comment maintenir les traductions à jour à chaque déploiement ?](https://generaltranslation.com/fr/kb/translations-in-ci.mdx): Exécutez la traduction comme une étape du pipeline avant chaque compilation de production, afin que les nouveaux textes soient livrés traduits avec le déploiement qui les ajoute. Le CLI gt de General Translation s’en charge avec npx gt translate, à l’aide d’une clé API de projet et d’un identifiant de projet stockés comme secrets CI.

## Previous and next questions

- Previous question: [Comment traduire du contenu dans Payload CMS ?](https://generaltranslation.com/fr/kb/translate-payload-content.mdx)
- Next question: [Comment traduire les titres SEO et les méta-descriptions ?](https://generaltranslation.com/fr/kb/translate-seo-metadata.mdx)

## Sitemap

See the [Knowledge Base sitemap](https://generaltranslation.com/fr/kb/sitemap.md) for every article.