# General Translation Knowledge Base: Come si traducono i file .resx in un'app .NET?
URL: https://generaltranslation.com/it/kb/translate-resx-files.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Crea una copia di ogni file .resx neutro con il nome della cultura, ad esempio Resources.fr.resx, e traduci solo il valore di ogni voce, lasciando invariati nomi, commenti e segnaposto come {0}. .NET compila ogni cultura in un assembly satellite ed esegue il fallback da fr-CA a fr e infine al file neutro. La CLI di General Translation genera questi file di cultura a partire dal file sorgente neutro.
Category: Traduzione
Last updated: 2026-10-28
Authors: General Translation Team
Published: 2026-10-28

Un file .resx è un elenco XML di risorse denominate. Il file neutro, ad esempio `Resources.resx`, contiene la lingua predefinita, mentre ogni traduzione è un file nella stessa cartella con la cultura nel nome, ad esempio `Resources.fr.resx`, che riporta gli stessi nomi con i valori tradotti. A runtime, `ResourceManager` sceglie il file corrispondente alla cultura corrente della UI e, per tutto ciò che manca, esegue il fallback sulle culture padre.

## Cosa contiene un file .resx

Ogni risorsa è un elemento `<data>`. Il suo attributo `name` è la chiave che il codice cerca, `<value>` contiene il testo e un `<comment>` facoltativo spiega al traduttore a cosa serve il testo. Ecco un estratto (un file reale inizia anche con un blocco di schema e con voci `<resheader>` che Visual Studio genera automaticamente):

```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>
```

Il file francese ha gli stessi attributi `name`, ma con valori in francese. Cambiano solo i valori stringa. I nomi fungono da chiavi di ricerca, mentre le risorse non stringa, come le immagini, che hanno un attributo `type` e spesso anche un attributo `mimetype`, di norma restano invariate. Microsoft consiglia di modificare i file .resx in Visual Studio anziché a mano, perché l&#39;XML deve rimanere ben formato e conforme al formato predefinito ([Microsoft: Create resource files](https://learn.microsoft.com/en-us/dotnet/core/extensions/create-resource-files)).

## Come .NET trova la traduzione corretta

Assegna a ogni traduzione lo stesso nome radice del file neutro, inserendo la cultura prima dell&#39;estensione: `Resources.fr.resx`, `Resources.fr-CA.resx`. Durante la build, le risorse neutre vengono incorporate nell&#39;assembly principale e ogni cultura viene compilata in un assembly satellite, all&#39;interno di una cartella che porta il nome della cultura, ad esempio `fr/MyApp.resources.dll`.

Quando l&#39;app richiede una stringa, .NET la cerca nell&#39;assembly satellite della cultura richiesta, poi in quello della cultura padre e così via, fino a ricorrere alle risorse neutre. Per una richiesta `fr-CA`, l&#39;ordine è `fr-CA`, poi `fr` e infine il file neutro. Se non esiste alcun file di risorse nemmeno per la cultura predefinita, viene sollevata un&#39;eccezione `MissingManifestResourceException` o `MissingSatelliteAssemblyException`. Su Linux e macOS, il nome della cartella della cultura deve corrispondere esattamente a `CultureInfo.Name`, maiuscole e minuscole comprese ([Microsoft: Package and deploy resources](https://learn.microsoft.com/en-us/dotnet/core/extensions/package-and-deploy-resources)).

Grazie al fallback, puoi tradurre una sola volta per un&#39;intera famiglia di regioni. Microsoft suggerisce un unico file `de` per gli utenti in `de-DE`, `de-AT` e `de-CH`, con file regionali che contengono solo le stringhe che differiscono. Questo significa anche che una traduzione mancante non solleva mai un&#39;eccezione: l&#39;utente vede la lingua neutra e la build non ti segnala nulla. (Vedi [Cosa sono i codici locale?](/kb/locale-codes).)

## Usare i file .resx in ASP.NET Core, Windows Forms e WPF

### ASP.NET Core

Registra i servizi di localizzazione, scegli le culture da supportare e aggiungi il 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();

// Determina la cultura dalla query string, da un cookie o dall'intestazione Accept-Language, in quest'ordine.
app.UseRequestLocalization();
```

Poi inietta `IStringLocalizer<T>` e recupera le stringhe per nome, passando gli argomenti di formattazione subito dopo: `localizer["ItemsInCart", count]`. I file di risorse prendono il nome dal nome completo del tipo della classe, escluso il nome dell&#39;assembly: `Controllers.HomeController` legge quindi `Controllers.HomeController.fr.resx` nella cartella `Resources` (oppure `HomeController.fr.resx` in `Resources/Controllers`), mentre una classe marcatore vuota `SharedResource` raggruppa le stringhe condivise in tutta l&#39;app. `SupportedUICultures` determina quali file .resx vengono letti; `SupportedCultures` determina la formattazione di date e numeri ([Microsoft: Provide localized resources](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/localization/provide-resources)).

Quando non esiste una traduzione, `IStringLocalizer` restituisce la chiave stessa, per cui Microsoft documenta un flusso di lavoro senza alcun file .resx neutro: `localizer["About Title"]` mostra &quot;About Title&quot; in inglese ([Microsoft: Make content localizable](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/localization/make-content-localizable)). Per la visualizzazione funziona, ma non lascia alcun file sorgente che un traduttore o uno strumento possa leggere. Se vuoi generare le traduzioni a partire da un file, usa chiavi con nome abbinate a un file .resx neutro i cui valori contengano il testo inglese: è l&#39;approccio tradizionale, anch&#39;esso documentato da Microsoft.

### Windows Forms e WPF

In Windows Forms, imposta la proprietà **Localizable** di un form su `true`, quindi scegli una cultura nella proprietà **Language**: quando modifichi il testo nel designer, Visual Studio lo salva in un file specifico per la cultura, come `Form1.es-ES.resx` ([Microsoft: Localizing a hybrid application](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/walkthrough-localizing-a-hybrid-application)). I file generati dal designer contengono anche voci non testuali, come i nomi che iniziano con `>>`. Le app WPF possono caricare le stringhe .resx tramite `ResourceManager`; la procedura dettagliata di Microsoft sulla localizzazione XAML usa lo strumento LocBaml, che la stessa Microsoft definisce un esempio che &quot;is not a production-ready application&quot; ([Microsoft: Localize a WPF app](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/how-to-localize-an-application)).

### Modificarli in Visual Studio

A partire da Visual Studio 2022 versione 17.11, Resource Explorer mostra ogni file .resx con le relative culture affiancate. Fai clic con il pulsante destro del mouse su un file .resx e scegli **Open With &gt; Resource Explorer** (oppure premi **Ctrl+Alt+R**). Lo strumento segnala quando manca una traduzione (&quot;No value&quot;) e quando i segnaposto non corrispondono a quelli della cultura neutra, ad esempio `Hello, {name}!` rispetto a `Hola, {nombre}!` ([Microsoft: Manage application resources](https://learn.microsoft.com/en-us/visualstudio/ide/managing-application-resources-dotnet)).

## Cosa si rompe quando traduci i file .resx

* **Segnaposto.** Gli elementi di formato composito di .NET hanno la forma `{index[,width][:formatString]}`, ad esempio `{0}`, `{1,-10}` o `{0:N2}`. Una traduzione può riordinarli o usarne uno due volte, ma un elemento di formato che fa riferimento a un argomento inesistente solleva un&#39;eccezione `FormatException` a runtime, mentre se ne viene omesso uno il valore va perso senza alcun avviso. Le parentesi graffe letterali si scrivono `{{` e `}}` ([Microsoft: Formattazione composita](https://learn.microsoft.com/en-us/dotnet/standard/base-types/composite-formatting)).
* **Nomi.** Se l&#39;attributo `name` viene tradotto, la ricerca non trova nulla e quella stringa ripiega sulla lingua neutra.
* **XML.** Un valore che contiene `&` o `<` deve mantenere l&#39;escape come `&amp;` e `&lt;`, altrimenti il file non viene compilato.
* **Tasti di scelta rapida.** In Windows Forms, `&File` sottolinea la F. La traduzione deve contenere esattamente un `&` prima di una lettera appropriata.
* **Commenti.** I commenti servono da contesto per i traduttori, non sono testo da tradurre. La guida di Microsoft a Windows App SDK precisa che i traduttori non devono tradurli ([Microsoft: Localizzare le stringhe](https://learn.microsoft.com/en-us/windows/apps/windows-app-sdk/mrtcore/localize-strings)).
* **Disallineamento.** Quando uno sviluppatore aggiunge un nome al file neutro, questo deve essere presente anche in ogni file di cultura. Il fallback maschera la lacuna, quindi verifica che non manchino valori prima di ogni rilascio.

## Modi per tradurre i file .resx

| Approccio                                                     | Conserva nomi e risorse non stringa                                                   | Controlli dei segnaposto                                                                                  | Sincronizzazione tra le culture                                                                                                | Indicato quando                                                        |
| ------------------------------------------------------------- | ------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------- |
| Resource Explorer di Visual Studio, manualmente               | Sì                                                                                    | Segnala le discrepanze                                                                                    | Mostra i valori mancanti per ogni cultura                                                                                      | Una o due lingue parlate da qualcuno del team                          |
| Traduttori o un sistema di gestione delle traduzioni (TMS)    | Sì, se il TMS supporta il parsing dei file .resx                                      | Dipende dai controlli di qualità del TMS                                                                  | Tramite la sincronizzazione del repository del TMS                                                                             | Il lavoro è affidato a traduttori professionisti o a un fornitore      |
| Script basato su un&#39;API di traduzione automatica o un LLM | Solo se lo script esegue il parsing dell&#39;XML e invia i valori                     | Devi scriverli tu                                                                                         | Riesegui lo script e confronti il diff                                                                                         | Sei disposto a gestire lo script e la relativa validazione             |
| Incollare il file in un assistente di chat                    | Nessuna garanzia                                                                      | Nessuno                                                                                                   | Manuale                                                                                                                        | Un file occasionale da controllare riga per riga                       |
| CLI di General Translation                                    | Traduce solo i valori stringa; nomi, commenti e risorse non stringa restano invariati | Una traduzione che modifica o elimina un segnaposto viene scartata e .NET usa il fallback per quella voce | Riutilizza le traduzioni delle voci invariate; esegui [`gt translate`](/docs/cli/reference/commands/translate) a ogni rilascio | I file di risorse si trovano nel repository e cambiano a ogni rilascio |

Usa il Resource Explorer per una o due lingue che un collega è in grado di revisionare. Usa un [TMS](/kb/what-is-a-translation-management-system) quando i traduttori professionisti lavorano al di fuori della base di codice. Scegli General Translation quando i file .resx cambiano a ogni rilascio e i file tradotti vanno committati insieme al codice. (Vedi [General Translation vs. un TMS](/kb/general-translation-vs-tms).)

## Come tradurre i file .resx con General Translation

La CLI di General Translation, `gt`, traduce i file .resx, e i file `.resw` con lo stesso schema, tramite la chiave di file `resx` (`gt` 2.23.1 o versioni successive). Il nome del file neutro non contiene alcuna cultura, quindi fai puntare `include` a questo file, escludi i file tradotti che si trovano accanto a esso e usa `transform` per aggiungere la cultura prima dell&#39;estensione:

```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"
      }
    }
  }
}
```

Nella cartella `Resources`, questa configurazione legge `Controllers.HomeController.resx` e scrive `Controllers.HomeController.fr.resx` e `Controllers.HomeController.es-MX.resx`, mantenendo intatti i nomi puntati di ASP.NET Core. Elenca in `locales` tutte le culture che già distribuisci: l&#39;esclusione `[locales]` ignora i file tradotti solo per le impostazioni regionali configurate, quindi un `Resources.de.resx` non presente nell&#39;elenco verrebbe letto come file sorgente. Per i progetti UWP e WinUI che conservano i file `.resw` in una cartella per ciascuna lingua, usa `"include": ["Strings/[locale]/Resources.resw"]` senza `transform`.

La CLI richiede Node.js 20 o versioni successive, anche in un repository .NET: installala come indicato nell&#39;[Avvio rapido della CLI](/docs/cli/quickstart), accedi con [`npx gt login`](/docs/cli/reference/commands/login) e imposta `GT_PROJECT_ID` ([credenziali della CLI](/docs/cli/guides/configuring#credentials)). Se la tua app dispone già di traduzioni, importale prima con [`npx gt upload`](/docs/cli/reference/commands/upload). Poi esegui [`npx gt translate`](/docs/cli/reference/commands/translate). In CI, salva come `GT_API_KEY` una chiave API di progetto con i permessi **Files &gt; Write** e **Translation queue &gt; Enabled**.

Il file tradotto è una copia del sorgente in cui vengono sostituiti solo i valori stringa, quindi nomi, ordine delle voci, schema e blocchi `<resheader>`, commenti e risorse non stringa restano invariati. Le voci con un `mimetype`, un tipo diverso da `System.String`, un nome del designer `>>` o un valore vuoto non vengono inviate per la traduzione. Ogni `<comment>` viene inviato come contesto e le istruzioni di localizzazione Microsoft presenti nei commenti, come `{Locked}`, vengono rispettate. I segnaposto come `{0}`, `{0:N2}`, `{1,-10}`, `{count}` e le parentesi graffe doppie vengono preservati, un singolo tasto di scelta rapida `&` resta davanti a una lettera adatta e il file scaricato mantiene la codifica e il byte order mark del sorgente. (Consulta il [riferimento .resx](/docs/cli/reference/formats/resx-files).)

Rivedi le traduzioni nella [Dashboard](/docs/platform/dashboard/guides/reviewing-translations) o in Visual Studio ed esegui [`npx gt save-local`](/docs/cli/reference/commands/save-local) dopo aver modificato i file in locale, in modo che le esecuzioni successive conservino le tue modifiche. Un [gruppo di contesto](/docs/platform/dashboard/guides/defining-context-for-translations) applica alle risorse .NET lo stesso Glossario e gli stessi prompt personalizzati usati per i [file JSON](/kb/translate-json-files) della tua app web, così il nome di un prodotto viene tradotto allo stesso modo in entrambi.

## Domande frequenti

### Qual è la differenza tra .resx e .resw?

Condividono lo stesso schema. Le app UWP e WinUI usano file `.resw` organizzati in una cartella per ciascuna lingua, ad esempio `Strings/en-US/Resources.resw` e `Strings/de-DE/Resources.resw`, anziché indicare la cultura nel nome del file ([Microsoft: Localize strings](https://learn.microsoft.com/en-us/windows/apps/windows-app-sdk/mrtcore/localize-strings)).

### Mi serve un file separato per fr-CA se ho già fr?

No. Per qualsiasi nome mancante, una richiesta `fr-CA` usa `fr` come fallback, quindi aggiungi un file `fr-CA` solo per le stringhe che cambiano.

### Perché la mia app ASP.NET Core continua a mostrare l&#39;inglese anche dopo aver aggiunto un file in francese?

Verifica che `fr` sia presente in `SupportedUICultures`, che il nome del file corrisponda al nome del tipo della classe e, su Linux o macOS, che la cartella della cultura nell&#39;output della build (ad esempio `fr`) corrisponda esattamente a `CultureInfo.Name`, maiuscole e minuscole comprese.

## Punti chiave

* Ogni traduzione è un file .resx affiancato all&#39;originale, con la cultura nel nome, ad esempio `Resources.fr.resx`; traduci i valori, mai gli attributi `name`.
* .NET ricade da `fr-CA` a `fr` e poi alle risorse neutre, quindi le traduzioni mancanti mostrano la lingua neutra anziché generare un errore.
* Un elemento di formato che fa riferimento a un indice oltre gli argomenti forniti solleva un&#39;eccezione `FormatException`; controlla i segnaposto in stile `{0}` in ogni traduzione.
* Il Resource Explorer di Visual Studio 2022 17.11 segnala i valori mancanti e i segnaposto non corrispondenti tra le varie culture.
* La CLI di General Translation traduce i file .resx e .resw con la chiave `resx` (2.23.1+), mantenendo nomi, commenti e risorse non stringa, ed escludendo qualsiasi traduzione che danneggi un segnaposto.

## Related questions

- [Come si traducono i file JSON di i18n?](https://generaltranslation.com/it/kb/translate-json-files.mdx): Traduci solo i valori stringa di un file JSON di impostazione regionale. Lascia invariati le chiavi non plurali, i segnaposto come {{name}} e i tag, ma tieni presente che le chiavi plurali cambiano da una lingua all'altra: il polacco, ad esempio, richiede inbox_few e inbox_many. Usa uno strumento o un'API in grado di gestire il formato, quindi esegui il parsing dell'output e validalo prima della revisione.
- [Come si traducono i file PO e POT?](https://generaltranslation.com/it/kb/translate-po-files.mdx): Compila ogni msgstr, incluse tutte le forme plurali richieste dall'intestazione Plural-Forms, e lascia invariati msgid, msgctxt e i segnaposto. Esegui msgfmt --check per verificare intestazioni, numero di forme plurali e segnaposto nelle voci con un flag di formato, e controlla a parte che nessun msgstr sia vuoto. La CLI di General Translation genera un file PO tradotto per ogni lingua a partire dal tuo template POT.
- [Che cos'è un sistema di gestione delle traduzioni (TMS)?](https://generaltranslation.com/it/kb/what-is-a-translation-management-system.mdx): Un sistema di gestione delle traduzioni (TMS) è un software che archivia il contenuto di origine e le relative traduzioni e gestisce il flusso di lavoro di traduzione: memoria di traduzione, glossari, revisione, traduzione automatica e integrazioni. La sua memoria di traduzione riutilizza le traduzioni precedenti tramite corrispondenze esatte o parziali (fuzzy match). Crowdin, Lokalise, Phrase, Smartling e Transifex sono alcuni degli esempi più diffusi.
- [General Translation e un TMS (Crowdin, Lokalise, Phrase) a confronto](https://generaltranslation.com/it/kb/general-translation-vs-tms.mdx): Scegli General Translation quando gli sviluppatori vogliono una generazione delle traduzioni, un contesto derivato dal codice e una revisione collegati ai rilasci del prodotto. Puoi mantenere i cataloghi e la libreria di rendering che usi già, oppure scrivere JSX inline senza chiavi di traduzione. Un TMS è adatto a programmi incentrati su fornitori linguistici, editor CAT e scambio di file XLIFF; le sue integrazioni possono automatizzare il trasferimento dei file.
- [Come mantengo le traduzioni aggiornate a ogni distribuzione?](https://generaltranslation.com/it/kb/translations-in-ci.mdx): Esegui la traduzione come passaggio della pipeline prima di ogni build di produzione, così i nuovi testi vengono rilasciati già tradotti insieme alla distribuzione che li introduce. La CLI gt di General Translation lo fa con npx gt translate, usando una chiave API e un ID progetto archiviati come segreti CI.

## Previous and next questions

- Previous question: [Come si traducono i contenuti in Payload CMS?](https://generaltranslation.com/it/kb/translate-payload-content.mdx)
- Next question: [Come si traducono i file di impostazioni regionali YAML?](https://generaltranslation.com/it/kb/translate-yaml-files.mdx)

## Sitemap

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