ResourceManager ResourceManager ResourceManager ResourceManager Class

Definizione

Rappresenta un gestore delle risorse che offre un comodo accesso a risorse specifiche delle impostazioni cultura in fase di esecuzione.Represents a resource manager that provides convenient access to culture-specific resources at run time.

public ref class ResourceManager
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class ResourceManager
type ResourceManager = class
Public Class ResourceManager
Ereditarietà
ResourceManagerResourceManagerResourceManagerResourceManager
Derivato
Attributi

Esempi

Nell'esempio seguente viene illustrato come utilizzare impostazioni cultura esplicite e le impostazioni cultura correnti dell'interfaccia utente implicite per ottenere risorse di stringa da un assembly principale e da un assembly satellite.The following example demonstrates how to use an explicit culture and the implicit current UI culture to obtain string resources from a main assembly and a satellite assembly. Per ulteriori informazioni, vedere la sezione "percorsi di directory per gli assembly satellite non installati nella global assembly cache" dell'argomento creazione di assembly satellite .For more information, see the "Directory Locations for Satellite Assemblies Not Installed in the Global Assembly Cache" section of the Creating Satellite Assemblies topic.

Per eseguire questo esempio:To run this example:

  1. Nella directory dell'app creare un file denominato RMC. txt che contiene le stringhe di risorse seguenti:In the app directory, create a file named rmc.txt that contains the following resource strings:

    
    day=Friday  
    year=2006  
    holiday="Cinco de Mayo"  
    
    
  2. Usare il Generatore di file di risorse per generare il file di risorse RMC. resources dal file di input RMC. txt, come indicato di seguito:Use the Resource File Generator to generate the rmc.resources resource file from the rmc.txt input file as follows:

    resgen rmc.txt  
    
  3. Creare una sottodirectory della directory dell'app e assegnarle il nome "es-MX".Create a subdirectory of the app directory and name it "es-MX". Si tratta del nome delle impostazioni cultura dell'assembly satellite che verrà creato nei tre passaggi successivi.This is the culture name of the satellite assembly that you will create in the next three steps.

  4. Creare un file denominato rmc.es-MX. txt nella directory es-MX che contiene le stringhe di risorse seguenti:Create a file named rmc.es-MX.txt in the es-MX directory that contains the following resource strings:

    
    day=Viernes  
    year=2006  
    holiday="Cinco de Mayo"  
    
    
  5. Usare il Generatore di file di risorse per generare il file di risorse RMC.es-MX. resources dal file di input RMC.es-MX. txt, come indicato di seguito:Use the Resource File Generator to generate the rmc.es-MX.resources resource file from the rmc.es-MX.txt input file as follows:

    resgen rmc.es-MX.txt  
    
  6. Si supponga che il nome file per questo esempio sia RMC. vb o rmc.cs.Assume that the filename for this example is rmc.vb or rmc.cs. Copiare il codice sorgente seguente in un file.Copy the following source code into a file. Quindi compilarlo e incorporare il file di risorse dell'assembly principale, RMC. resources, nell'assembly eseguibile.Then compile it and embed the main assembly resource file, rmc.resources, in the executable assembly. Se si usa il compilatore Visual Basic, la sintassi è:If you are using the Visual Basic compiler, the syntax is:

    vbc rmc.vb /resource:rmc.resources  
    

    La sintassi corrispondente per il C# compilatore è la seguente:The corresponding syntax for the C# compiler is:

    csc /resource:rmc.resources rmc.cs  
    
  7. Usare assembly linker per creare un assembly satellite.Use the Assembly Linker to create a satellite assembly. Se il nome di base dell'app è RMC, il nome dell'assembly satellite deve essere RMC. resources. dll.If the base name of the app is rmc, the satellite assembly name must be rmc.resources.dll. L'assembly satellite deve essere creato nella directory es-MX.The satellite assembly should be created in the es-MX directory. Se es-MX è la directory corrente, usare questo comando:If es-MX is the current directory, use this command:

    al /embed:rmc.es-MX.resources /c:es-MX /out:rmc.resources.dll   
    
  8. Eseguire RMC. exe per ottenere e visualizzare le stringhe di risorse incorporate.Run rmc.exe to obtain and display the embedded resource strings.

using System;
using System.Resources;
using System.Reflection;
using System.Threading;
using System.Globalization;

class Example 
{
    public static void Main() 
    {
    string day;
    string year;
    string holiday;
    string celebrate = "{0} will occur on {1} in {2}.\n";

    // Create a resource manager. 
    ResourceManager rm = new ResourceManager("rmc", 
                             typeof(Example).Assembly);

    Console.WriteLine("Obtain resources using the current UI culture.");

    // Get the resource strings for the day, year, and holiday 
    // using the current UI culture. 
    day  = rm.GetString("day");
    year = rm.GetString("year");
    holiday = rm.GetString("holiday");
    Console.WriteLine(celebrate, holiday, day, year);

    // Obtain the es-MX culture.
    CultureInfo ci = new CultureInfo("es-MX");

    Console.WriteLine("Obtain resources using the es-MX culture.");

   // Get the resource strings for the day, year, and holiday 
   // using the specified culture. 
    day  = rm.GetString("day", ci);
    year = rm.GetString("year", ci);
    holiday = rm.GetString("holiday", ci);
// ---------------------------------------------------------------
// Alternatively, comment the preceding 3 code statements and 
// uncomment the following 4 code statements:
// ----------------------------------------------------------------
// Set the current UI culture to "es-MX" (Spanish-Mexico).
//    Thread.CurrentThread.CurrentUICulture = ci;

// Get the resource strings for the day, year, and holiday 
// using the current UI culture. Use those strings to 
// display a message. 
//    day  = rm.GetString("day");
//    year = rm.GetString("year");
//    holiday = rm.GetString("holiday");
// ---------------------------------------------------------------

// Regardless of the alternative that you choose, display a message 
// using the retrieved resource strings.
    Console.WriteLine(celebrate, holiday, day, year);
    }
}
/*
This example displays the following output:

   Obtain resources using the current UI culture.
   "5th of May" will occur on Friday in 2006.
   
   Obtain resources using the es-MX culture.
   "Cinco de Mayo" will occur on Viernes in 2006.
*/
Imports System.Resources
Imports System.Reflection
Imports System.Threading
Imports System.Globalization

Class Example
    Public Shared Sub Main() 
        Dim day As String
        Dim year As String
        Dim holiday As String
        Dim celebrate As String = "{0} will occur on {1} in {2}." & vbCrLf

        ' Create a resource manager. 
        Dim rm As New ResourceManager("rmc", GetType(Example).Assembly)

        Console.WriteLine("Obtain resources using the current UI culture.")

        ' Get the resource strings for the day, year, and holiday 
        ' using the current UI culture. 
        day = rm.GetString("day")
        year = rm.GetString("year")
        holiday = rm.GetString("holiday")
        Console.WriteLine(celebrate, holiday, day, year)

        ' Obtain the es-MX culture.
        Dim ci As New CultureInfo("es-MX")

        Console.WriteLine("Obtain resources using the es-MX culture.")

        ' Get the resource strings for the day, year, and holiday 
        ' using the es-MX culture.  
        day = rm.GetString("day", ci)
        year = rm.GetString("year", ci)
        holiday = rm.GetString("holiday", ci)

        ' ---------------------------------------------------------------
        ' Alternatively, comment the preceding 3 code statements and 
        ' uncomment the following 4 code statements:
        ' ----------------------------------------------------------------
        ' Set the current UI culture to "es-MX" (Spanish-Mexico).
        '    Thread.CurrentThread.CurrentUICulture = ci
        ' Get the resource strings for the day, year, and holiday 
        ' using the current UI culture. 
        '    day  = rm.GetString("day")
        '    year = rm.GetString("year")
        '    holiday = rm.GetString("holiday")
        ' ---------------------------------------------------------------

        ' Regardless of the alternative that you choose, display a message 
        ' using the retrieved resource strings.
        Console.WriteLine(celebrate, holiday, day, year)
    End Sub 
End Class
' This example displays the following output:
'Obtain resources using the current UI culture.
'"5th of May" will occur on Friday in 2006.
'
'Obtain resources using the es-MX culture.
'"Cinco de Mayo" will occur on Viernes in 2006.

Commenti

Importante

La chiamata a metodi da questa classe con dati non attendibili costituisce un rischio per la sicurezza.Calling methods from this class with untrusted data is a security risk. Chiamare i metodi da questa classe solo con dati attendibili.Call the methods from this class only with trusted data. Per altre informazioni, vedere Data Validation (Convalida dei dati).For more information, see Data Validation.

La ResourceManager classe recupera le risorse da un file con estensione resources binario incorporato in un assembly o da un file con estensione resources autonomo.The ResourceManager class retrieves resources from a binary .resources file that is embedded in an assembly or from a standalone .resources file. Se un'app è stata localizzata e le risorse localizzate sono state distribuite in assembly satellite, Cerca le risorse specifiche delle impostazioni cultura, fornisce il fallback delle risorse quando una risorsa localizzata non esiste e supporta la serializzazione delle risorse.If an app has been localized and localized resources have been deployed in satellite assemblies, it looks up culture-specific resources, provides resource fallback when a localized resource does not exist, and supports resource serialization.

Per altre informazioni sulla creazione e la gestione di risorse nelle app Windows 8.x StoreWindows 8.x Store e nelle app desktop, vedere le sezioni seguenti:For more information about creating and managing resources in desktop apps and Windows 8.x StoreWindows 8.x Store apps, see the following sections:

App desktopDesktop Apps

Per le applicazioni desktop, ResourceManager la classe recupera le risorse dai file di risorse binarie (con estensione resources).For desktop apps, the ResourceManager class retrieves resources from binary resource (.resources) files. In genere, un compilatore di linguaggio o assembly linker (al. exe) incorpora questi file di risorse in un assembly.Typically, a language compiler or the Assembly Linker (AL.exe) embeds these resource files in an assembly. È anche possibile usare un ResourceManager oggetto per recuperare le risorse direttamente da un file con estensione resources che non è incorporato in un assembly CreateFileBasedResourceManager , chiamando il metodo.You can also use a ResourceManager object to retrieve resources directly from a .resources file that is not embedded in an assembly, by calling the CreateFileBasedResourceManager method.

Attenzione

L'uso di file con estensione resources autonomi in un'app ASP.NET interrompe la distribuzione XCOPY, perché le risorse rimangono bloccate fino ReleaseAllResources a quando non vengono rilasciate in modo esplicito dal metodo.Using standalone .resources files in an ASP.NET app will break XCOPY deployment, because the resources remain locked until they are explicitly released by the ReleaseAllResources method. Se si vuole distribuire le risorse con le app ASP.NET, è necessario compilare i file con estensione resources in assembly satellite.If you want to deploy resources with your ASP.NET apps, you should compile your .resources files into satellite assemblies.

In un'app basata su risorse, un file. resources contiene le risorse delle impostazioni cultura predefinite le cui risorse vengono usate se non è possibile trovare risorse specifiche delle impostazioni cultura.In a resource-based app, one .resources file contains the resources of the default culture whose resources are used if no culture-specific resources can be found. Se, ad esempio, le impostazioni cultura predefinite di un'app sono inglese (en), le risorse della lingua inglese vengono usate ogni volta che non è possibile trovare le risorse localizzate per impostazioni cultura specifiche, ad esempio inglese (Stati Uniti) (en-US) o francese (Francia) (fr-FR).For example, if an app's default culture is English (en), the English language resources are used whenever localized resources cannot be found for a specific culture, such as English (United States) (en-US) or French (France) (fr-FR). In genere, le risorse per le impostazioni cultura predefinite sono incorporate nell'assembly principale dell'app e le risorse per altre impostazioni cultura localizzate sono incorporate in assembly satellite.Typically, the resources for the default culture are embedded in the main app assembly, and resources for other localized cultures are embedded in satellite assemblies. Gli assembly satellite contengono solo risorse.Satellite assemblies contain only resources. Hanno lo stesso nome file radice dell'assembly principale e un'estensione di. resources. dll.They have the same root file name as the main assembly and an extension of .resources.dll. Per le app i cui assembly non sono registrati nella Global Assembly Cache, gli assembly satellite vengono archiviati in una sottodirectory dell'app il cui nome corrisponde alle impostazioni cultura dell'assembly.For apps whose assemblies are not registered in the global assembly cache, satellite assemblies are stored in an app subdirectory whose name corresponds to the assembly's culture.

Creazione di risorseCreating Resources

Quando si sviluppa un'app basata sulle risorse, le informazioni sulle risorse vengono archiviate in file di testo (file con estensione. txt o. restext) o file XML (file con estensione resx).When you develop a resource-based app, you store resource information in text files (files that have a .txt or .restext extension) or XML files (files that have a .resx extension). Compilare quindi i file di testo o XML con il Generatore di file di risorse (Resgen. exe) per creare un file con estensione resources binario.You then compile the text or XML files with the Resource File Generator (Resgen.exe) to create a binary .resources file. È quindi possibile incorporare il file con estensione resources risultante in un eseguibile o in una libreria /resources usando un' C# opzione del compilatore, ad esempio per i compilatori e Visual Basic, oppure è possibile incorporarla in un assembly satellite usando.You can then embed the resulting .resources file in an executable or library by using a compiler option such as /resources for the C# and Visual Basic compilers, or you can embed it in a satellite assembly by using the . Se si include un file con estensione resx nel progetto di Visual Studio, Visual Studio gestisce automaticamente la compilazione e l'incorporamento delle risorse predefinite e localizzate come parte del processo di compilazione.If you include a .resx file in your Visual Studio project, Visual Studio handles the compilation and embedding of default and localized resources automatically as part of the build process.

Idealmente, è consigliabile creare risorse per ogni lingua supportata dall'app o almeno per un subset significativo di ogni linguaggio.Ideally, you should create resources for every language your app supports, or at least for a meaningful subset of each language. I nomi file binari. resources seguono la convenzione di denominazione baseName. cultureName. resources, dove baseName è il nome dell'app o il nome di una classe, a seconda del livello di dettaglio desiderato.The binary .resources file names follow the naming convention basename.cultureName.resources, where basename is the name of the app or the name of a class, depending on the level of detail you want. La CultureInfo.Name proprietà viene utilizzata per determinare cultureName.The CultureInfo.Name property is used to determine cultureName. Una risorsa per le impostazioni cultura predefinite dell'app deve essere denominata baseName. resources.A resource for the app's default culture should be named basename.resources.

Si supponga, ad esempio, che un assembly disponga di diverse risorse in un file di risorse con il nome di base MyResources.For example, suppose that an assembly has several resources in a resource file that has the base name MyResources. Questi file di risorse devono avere nomi quali risorse. ja-JP. resources per le impostazioni cultura Giappone (giapponese), MyResources. de. resources per le impostazioni cultura tedesche, MyResources. zh-CHS. resources per le impostazioni cultura del cinese semplificato e MyResources.fr-BE. resources per le impostazioni cultura francesi (Belgium).These resource files should have names such as MyResources.ja-JP.resources for the Japan (Japanese) culture, MyResources.de.resources for the German culture, MyResources.zh-CHS.resources for the simplified Chinese culture, and MyResources.fr-BE.resources for the French (Belgium) culture. Il file di risorse predefinito deve essere denominato myResources. resources.The default resource file should be named MyResources.resources. I file di risorse specifici delle impostazioni cultura vengono in genere inseriti in assembly satellite per ogni impostazione cultura.The culture-specific resource files are commonly packaged in satellite assemblies for each culture. Il file di risorse predefinito deve essere incorporato nell'assembly principale dell'app.The default resource file should be embedded in the app's main assembly.

Si noti che assembly linker consente di contrassegnare le risorse come private, ma è sempre necessario contrassegnarle come pubbliche, in modo che possano accedervi da altri assembly.Note that Assembly Linker allows resources to be marked as private, but you should always mark them as public so they can be accessed by other assemblies. Poiché un assembly satellite non contiene codice, le risorse contrassegnate come private non sono disponibili per l'app tramite alcun meccanismo.(Because a satellite assembly contains no code, resources that are marked as private are unavailable to your app through any mechanism.)

Per altre informazioni sulla creazione, il packaging e la distribuzione delle risorse, vedere gli articoli creazione di file di risorse, creazione di assembly satellitee creazione di pacchetti e distribuzione di risorse.For more information about creating, packaging, and deploying resources, see the articles Creating Resource Files, Creating Satellite Assemblies, and Packaging and Deploying Resources.

Creazione di un'istanza di un oggetto ResourceManagerInstantiating a ResourceManager Object

Si crea un'istanza ResourceManager di un oggetto che recupera le risorse da un file con estensione resources incorporato chiamando uno degli overload del relativo costruttore di classe.You instantiate a ResourceManager object that retrieves resources from an embedded .resources file by calling one of its class constructor overloads. Questa operazione associa strettamente un ResourceManager oggetto a un particolare file con estensione resources e a tutti i file con estensione resources localizzati associati in assembly satellite.This tightly couples a ResourceManager object with a particular .resources file and with any associated localized .resources files in satellite assemblies.

I due costruttori più comunemente denominati sono:The two most commonly called constructors are:

  • ResourceManager(String, Assembly)Cerca le risorse in base a due tipi di informazioni fornite: il nome di base del file con estensione resources e l'assembly in cui risiede il file default. resources.ResourceManager(String, Assembly) looks up resources based on two pieces of information that you supply: the base name of the .resources file, and the assembly in which the default .resources file resides. Il nome di base include lo spazio dei nomi e il nome radice del file con estensione resources, senza impostazioni cultura o estensione.The base name includes the namespace and root name of the .resources file, without its culture or extension. Si noti che i file con estensione resources compilati dalla riga di comando in genere non includono un nome di spazio dei nomi, mentre i file con estensione resources creati nell'ambiente di Visual Studio.Note that .resources files that are compiled from the command line typically do not include a namespace name, whereas .resources files that are created in the Visual Studio environment do. Se, ad esempio, un file di risorse è denominato MyCompany. StringResources. resources e il ResourceManager costruttore viene chiamato da un metodo statico denominato Example.Main, il codice seguente ResourceManager crea un'istanza di un oggetto in grado di recuperare le risorse da. file di risorse:For example, if a resource file is named MyCompany.StringResources.resources and the ResourceManager constructor is called from a static method named Example.Main, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager("MyCompany.StringResources", 
                                             typeof(Example).Assembly);
    
    Dim rm As New ResourceManager("MyCompany.StringResources",
                                  GetType(Example).Assembly)
    
  • ResourceManager(Type)Cerca le risorse negli assembly satellite in base alle informazioni provenienti da un oggetto tipo.ResourceManager(Type) looks up resources in satellite assemblies based on information from a type object. Il nome completo del tipo corrisponde al nome di base del file con estensione resources senza l'estensione del nome file.The type's fully qualified name corresponds to the base name of the .resources file without its file name extension. Nelle app desktop create con la finestra di progettazione risorse di Visual Studio, Visual Studio crea una classe wrapper il cui nome completo è uguale al nome radice del file con estensione resources.In desktop apps that are created by using the Visual Studio Resource Designer, Visual Studio creates a wrapper class whose fully qualified name is the same as the root name of the .resources file. Se, ad esempio, un file di risorse è denominato MyCompany. StringResources. resources ed è presente una MyCompany.StringResourcesclasse wrapper denominata, il codice seguente ResourceManager crea un'istanza di un oggetto in grado di recuperare le risorse dal file con estensione resources:For example, if a resource file is named MyCompany.StringResources.resources and there is a wrapper class named MyCompany.StringResources, the following code instantiates a ResourceManager object that can retrieve resources from the .resources file:

    ResourceManager rm = new ResourceManager(typeof(MyCompany.StringResources));
    
    Dim rm As New ResourceManager(GetType(MyCompany.StringResources))
    

Se non è possibile trovare le risorse appropriate, la chiamata al costruttore crea ResourceManager un oggetto valido.If the appropriate resources cannot be found, the constructor call creates a valid ResourceManager object. Tuttavia, il tentativo di recuperare una risorsa genera un' MissingManifestResourceException eccezione.However, the attempt to retrieve a resource throws a MissingManifestResourceException exception. Per informazioni sulla gestione dell'eccezione, vedere la sezione gestione delle eccezioni MissingManifestResourceException e MissingSatelliteAssembly più avanti in questo articolo.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssembly Exceptions section later in this article.

Nell'esempio seguente viene illustrato come creare un'istanza ResourceManager di un oggetto.The following example shows how to instantiate a ResourceManager object. Contiene il codice sorgente per un eseguibile denominato ShowTime. exe.It contains the source code for an executable named ShowTime.exe. Include anche il seguente file di testo denominato Strings. txt che contiene una singola risorsa stringa TimeHeader,:It also includes the following text file named Strings.txt that contains a single string resource, TimeHeader:

TimeHeader=The current time is  

È possibile usare un file batch per generare il file di risorse e incorporarlo nell'eseguibile.You can use a batch file to generate the resource file and embed it into the executable. Ecco il file batch per generare un eseguibile usando il C# compilatore:Here's the batch file to generate an executable by using the C# compiler:

  
resgen strings.txt  
csc ShowTime.cs /resource:strings.resources  
  

Per il compilatore di Visual Basic, è possibile usare il file batch seguente:For the Visual Basic compiler, you can use the following batch file:

  
resgen strings.txt  
vbc ShowTime.vb /resource:strings.resources  
  
using System;
using System.Resources;

public class Example
{
   public static void Main()
   {
      ResourceManager rm = new ResourceManager("Strings", 
                               typeof(Example).Assembly);
      string timeString = rm.GetString("TimeHeader");
      Console.WriteLine("{0} {1:T}", timeString, DateTime.Now);   
   }
}
// The example displays output like the following:
//        The current time is 2:03:14 PM
Imports System.Resources

Module Example
   Public Sub Main()
      Dim rm As New ResourceManager("Strings", GetType(Example).Assembly)
      Dim timeString As String = rm.GetString("TimeHeader")
      Console.WriteLine("{0} {1:T}", timeString, Date.Now)   
   End Sub
End Module
' The example displays output similar to the following:
'       The current time is 2:03:14 PM

ResourceManager e risorse specifiche delle impostazioni culturaResourceManager and Culture-Specific Resources

Un'app localizzata richiede la distribuzione di risorse, come illustrato nell'articolo creazione di pacchetti e distribuzione di risorse.A localized app requires resources to be deployed, as discussed in the article Packaging and Deploying Resources. Se gli assembly sono configurati correttamente, Resource Manager determina le risorse da recuperare in base alla Thread.CurrentUICulture proprietà del thread corrente.If the assemblies are properly configured, the resource manager determines which resources to retrieve based on the current thread's Thread.CurrentUICulture property. Questa proprietà restituisce anche le impostazioni cultura dell'interfaccia utente del thread corrente. Se, ad esempio, un'app viene compilata con risorse della lingua inglese predefinite nell'assembly principale e con le risorse della lingua francese e russa in due Thread.CurrentUICulture assembly satellite e la proprietà è impostata su fr-FR, Resource Manager recupera il francese risorse.(That property also returns the current thread's UI culture.) For example, if an app is compiled with default English language resources in the main assembly and with French and Russian language resources in two satellite assemblies, and the Thread.CurrentUICulture property is set to fr-FR, the resource manager retrieves the French resources.

È possibile impostare la CurrentUICulture proprietà in modo esplicito o implicito.You can set the CurrentUICulture property explicitly or implicitly. Il modo in cui viene impostato determina il ResourceManager modo in cui l'oggetto recupera le risorse in base alle impostazioni cultura:The way you set it determines how the ResourceManager object retrieves resources based on culture:

  • Se si imposta in modo esplicito la Thread.CurrentUICulture proprietà su impostazioni cultura specifiche, Resource Manager recupera sempre le risorse per le impostazioni cultura, indipendentemente dal browser o dalla lingua del sistema operativo dell'utente.If you explicitly set the Thread.CurrentUICulture property to a specific culture, the resource manager always retrieves the resources for that culture, regardless of the user's browser or operating system language. Si consideri un'app compilata con risorse della lingua inglese predefinite e tre assembly satellite contenenti risorse per la lingua inglese (Stati Uniti), francese (Francia) e russo (Russia).Consider an app that is compiled with default English language resources and three satellite assemblies that contain resources for English (United States), French (France), and Russian (Russia). Se la CurrentUICulture proprietà è impostata su fr-FR, l' ResourceManager oggetto recupera sempre le risorse francesi (Francia), anche se la lingua del sistema operativo dell'utente non è francese.If the CurrentUICulture property is set to fr-FR, the ResourceManager object always retrieves the French (France) resources, even if the user's operating system language is not French. Assicurarsi che questo sia il comportamento desiderato prima di impostare la proprietà in modo esplicito.Make sure that this is the desired behavior before you set the property explicitly.

    Nelle app ASP.NET è necessario impostare la Thread.CurrentUICulture proprietà in modo esplicito, in quanto è improbabile che l'impostazione del server corrisponda alle richieste client in ingresso.In ASP.NET apps, you must set the Thread.CurrentUICulture property explicitly, because it is unlikely that the setting on the server will match incoming client requests. Un'app ASP.NET può impostare la Thread.CurrentUICulture proprietà in modo esplicito sulla lingua di accettazione del browser dell'utente.An ASP.NET app can set the Thread.CurrentUICulture property explicitly to the user's browser accept language.

    Impostando in modo Thread.CurrentUICulture esplicito la proprietà vengono definite le impostazioni cultura dell'interfaccia utente correnti per quel thread.Explicitly setting the Thread.CurrentUICulture property defines the current UI culture for that thread. Non influisce sulle impostazioni cultura correnti dell'interfaccia utente di tutti gli altri thread in un'app.It does not affect the current UI culture of any other threads in an app.

  • È possibile impostare le impostazioni cultura dell'interfaccia utente di tutti i thread in un dominio dell' CultureInfo applicazione assegnando un oggetto che rappresenta le CultureInfo.DefaultThreadCurrentUICulture impostazioni cultura alla proprietà statica.You can set the UI culture of all threads in an app domain by assigning a CultureInfo object that represents that culture to the static CultureInfo.DefaultThreadCurrentUICulture property.

  • Se non si impostano in modo esplicito le impostazioni cultura correnti dell'interfaccia utente e non si definiscono impostazioni cultura predefinite per il CultureInfo.CurrentUICulture dominio dell'applicazione corrente, la proprietà viene GetUserDefaultUILanguage impostata in modo implicito dalla funzione di Windows.If you do not explicitly set the current UI culture and you do not define a default culture for the current app domain, the CultureInfo.CurrentUICulture property is set implicitly by the Windows GetUserDefaultUILanguage function. Questa funzione è fornita dall'interfaccia utente multilingue (MUI), che consente all'utente di impostare la lingua predefinita.This function is provided by the Multilingual User Interface (MUI), which enables the user to set the default language. Se la lingua dell'interfaccia utente non è impostata dall'utente, per impostazione predefinita viene utilizzato il linguaggio installato dal sistema, ovvero la lingua delle risorse del sistema operativo.If the UI language is not set by the user, it defaults to the system-installed language, which is the language of operating system resources.

Il semplice esempio "Hello World" seguente imposta in modo esplicito le impostazioni cultura dell'interfaccia utente correnti.The following simple "Hello world" example sets the current UI culture explicitly. Contiene risorse per tre impostazioni cultura: Inglese (Stati Uniti) o en-US, francese (Francia) o fr-FR e russo (Russia) o ur-ur.It contains resources for three cultures: English (United States) or en-US, French (France) or fr-FR, and Russian (Russia) or ru-RU. Le risorse en-US sono contenute in un file di testo denominato Greetings. txt:The en-US resources are contained in a text file named Greetings.txt:

HelloString=Hello world!  

Le risorse fr-FR sono contenute in un file di testo denominato Greetings.fr-fr. txt:The fr-FR resources are contained in a text file named Greetings.fr-FR.txt:

HelloString=Salut tout le monde!  

Le risorse ur-ur sono contenute in un file di testo denominato Greetings.ru-ru. txt:The ru-RU resources are contained in a text file named Greetings.ru-RU.txt:

HelloString=Всем привет!  

Ecco il codice sorgente per l'esempio (example. vb per la versione Visual Basic o Example.cs per la C# versione):Here's the source code for the example (Example.vb for the Visual Basic version or Example.cs for the C# version):

using System;
using System.Globalization;
using System.Resources;
using System.Threading;

public class Example
{
   public static void Main()
   {
      // Create array of supported cultures
      string[] cultures = {"en-CA", "en-US", "fr-FR", "ru-RU" };
      Random rnd = new Random();
      int cultureNdx = rnd.Next(0, cultures.Length);
      CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
      ResourceManager rm = new ResourceManager("Greetings", typeof(Example).Assembly);
      try {
         CultureInfo newCulture = new CultureInfo(cultures[cultureNdx]);
         Thread.CurrentThread.CurrentCulture = newCulture;
         Thread.CurrentThread.CurrentUICulture = newCulture;
         string greeting = String.Format("The current culture is {0}.\n{1}",
                                         Thread.CurrentThread.CurrentUICulture.Name,
                                         rm.GetString("HelloString"));
         Console.WriteLine(greeting);
      }
      catch (CultureNotFoundException e) {
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName);
      }
      finally {
         Thread.CurrentThread.CurrentCulture = originalCulture;
         Thread.CurrentThread.CurrentUICulture = originalCulture;
      }
   }
}
// The example displays output like the following:
//       The current culture is ru-RU.
//       Всем привет!
Imports System.Globalization
Imports System.Resources
Imports System.Threading

Module Example
   Sub Main()
      ' Create array of supported cultures
      Dim cultures() As String = {"en-CA", "en-US", "fr-FR", "ru-RU" }
      Dim rnd As New Random()
      Dim cultureNdx As Integer = rnd.Next(0, cultures.Length)
      Dim originalCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
      Dim rm As New ResourceManager("Greetings", GetType(Example).Assembly)
      Try
         Dim newCulture As New CultureInfo(cultures(cultureNdx))
         Thread.CurrentThread.CurrentCulture = newCulture
         Thread.CurrentThread.CurrentUICulture = newCulture
         Dim greeting As String = String.Format("The current culture is {0}.{1}{2}",
                                                Thread.CurrentThread.CurrentUICulture.Name,
                                                vbCrLf, rm.GetString("HelloString"))

         Console.WriteLine(greeting)
      Catch e As CultureNotFoundException
         Console.WriteLine("Unable to instantiate culture {0}", e.InvalidCultureName)
      Finally
         Thread.CurrentThread.CurrentCulture = originalCulture
         Thread.CurrentThread.CurrentUICulture = originalCulture
      End Try
   End Sub
End Module
' The example displays output like the following:
'       The current culture is ru-RU.
'       Всем привет!

Per compilare questo esempio, creare un file batch (. bat) che contenga i comandi seguenti ed eseguirlo dal prompt dei comandi.To compile this example, create a batch (.bat) file that contains the following commands and run it from the command prompt. Se si utilizza C#, specificare csc anziché vbc e Example.cs anziché Example.vb.If you're using C#, specify csc instead of vbc and Example.cs instead of Example.vb.

resgen Greetings.txt   
vbc Example.vb /resource:Greetings.resources  
  
resgen Greetings.fr-FR.txt  
Md fr-FR  
al /embed:Greetings.fr-FR.resources /culture:fr-FR /out:fr-FR\Example.resources.dll  
  
resgen Greetings.ru-RU.txt  
Md ru-RU  
al /embed:Greetings.ru-RU.resources /culture:ru-RU /out:ru-RU\Example.resources.dll  

Recupero di risorseRetrieving Resources

Chiamare i GetObject(String) metodi e GetString(String) per accedere a una risorsa specifica.You call the GetObject(String) and GetString(String) methods to access a specific resource. È anche possibile chiamare il GetStream(String) metodo per recuperare le risorse non di stringa come matrice di byte.You can also call the GetStream(String) method to retrieve non-string resources as a byte array. Per impostazione predefinita, in un'app con risorse localizzate, questi metodi restituiscono la risorsa per le impostazioni cultura determinate dalle impostazioni cultura dell'interfaccia utente correnti del thread che ha effettuato la chiamata.By default, in an app that has localized resources, these methods return the resource for the culture determined by the current UI culture of the thread that made the call. Per ulteriori informazioni sulla modalità di definizione delle impostazioni cultura dell'interfaccia utente correnti di un thread, vedere la sezione precedente, ResourceManager e risorse specifiche delle impostazioni cultura.See the previous section, ResourceManager and Culture-Specific Resources, for more information about how the current UI culture of a thread is defined. Se il gestore di risorse non riesce a trovare la risorsa per le impostazioni cultura dell'interfaccia utente del thread corrente, usa un processo di fallback per recuperare la risorsa specificata.If the resource manager cannot find the resource for the current thread's UI culture, it uses a fallback process to retrieve the specified resource. Se il gestore di risorse non riesce a trovare le risorse localizzate, USA le risorse delle impostazioni cultura predefinite.If the resource manager cannot find any localized resources, it uses the resources of the default culture. Per ulteriori informazioni sulle regole di fallback delle risorse, vedere la sezione "processo di fallback delle risorse" dell'articolo creazione di pacchetti e distribuzione di risorse.For more information about resource fallback rules, see the "Resource Fallback Process" section of the article Packaging and Deploying Resources.

Nota

Se non è possibile trovare il file con ResourceManager estensione resources specificato nel costruttore della classe, il tentativo di recuperare MissingManifestResourceException una MissingSatelliteAssemblyException risorsa genera un'eccezione o.If the .resources file specified in the ResourceManager class constructor cannot be found, the attempt to retrieve a resource throws a MissingManifestResourceException or MissingSatelliteAssemblyException exception. Per informazioni sulla gestione dell'eccezione, vedere la sezione gestione delle eccezioni MissingManifestResourceException e MissingSatelliteAssemblyException più avanti in questo argomento.For information about dealing with the exception, see the Handling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions section later in this topic.

Nell'esempio seguente viene usato GetString il metodo per recuperare le risorse specifiche delle impostazioni cultura.The following example uses the GetString method to retrieve culture-specific resources. È costituito da risorse compilate da file con estensione txt per le impostazioni cultura inglese (en), francese (Francia) (fr-FR) e russe (Russia) (RU-UR).It consists of resources compiled from .txt files for the English (en), French (France) (fr-FR), and Russian (Russia) (ru-RU) cultures. Nell'esempio vengono modificate le impostazioni cultura correnti e le impostazioni cultura correnti dell'interfaccia utente in inglese (Stati Uniti), francese (Francia), russo (Russia) e svedese (Svezia).The example changes the current culture and current UI culture to English (United States), French (France), Russian (Russia), and Swedish (Sweden). Viene quindi chiamato il GetString metodo per recuperare la stringa localizzata, visualizzata insieme al giorno e al mese correnti.It then calls the GetString method to retrieve the localized string, which it displays along with the current day and month. Si noti che l'output Visualizza la stringa localizzata appropriata tranne quando le impostazioni cultura correnti dell'interfaccia utente sono svedesi (Svezia).Notice that the output displays the appropriate localized string except when the current UI culture is Swedish (Sweden). Poiché le risorse della lingua svedese non sono disponibili, l'app usa invece le risorse delle impostazioni cultura predefinite, ovvero l'inglese.Because Swedish language resources are unavailable, the app instead uses the resources of the default culture, which is English.

Nell'esempio sono necessari i file di risorse basati su testo elencati nella tabella seguente.The example requires the text-based resource files listed in following table. Ogni oggetto ha una sola risorsa stringa DateStartdenominata.Each has a single string resource named DateStart.

cultureCulture Nome fileFile name Nome della risorsaResource name Valore della risorsaResource value
en-USen-US DateStrings.txtDateStrings.txt DateStart Oggi èToday is
fr-FRfr-FR DateStrings.fr-FR.txtDateStrings.fr-FR.txt DateStart Aujourd ' hui, est leAujourd'hui, c'est le
ru-RUru-RU DateStrings.ru-RU.txtDateStrings.ru-RU.txt DateStart СегодняСегодня

Ecco il codice sorgente per l'esempio (ShowDate. vb per la versione del Visual Basic o ShowDate.cs per la C# versione del codice).Here's the source code for the example (ShowDate.vb for the Visual Basic version or ShowDate.cs for the C# version of the code).

using System;
using System.Globalization;
using System.Resources;
using System.Threading;

[assembly:NeutralResourcesLanguage("en")]

public class Example
{
   public static void Main()
   {
      string[] cultureNames = { "en-US", "fr-FR", "ru-RU", "sv-SE" };
      ResourceManager rm = new ResourceManager("DateStrings",
                                               typeof(Example).Assembly);
      
      foreach (var cultureName in cultureNames) {
         CultureInfo culture = CultureInfo.CreateSpecificCulture(cultureName);
         Thread.CurrentThread.CurrentCulture = culture; 
         Thread.CurrentThread.CurrentUICulture = culture;

         Console.WriteLine("Current UI Culture: {0}", 
                           CultureInfo.CurrentUICulture.Name);
         string dateString = rm.GetString("DateStart");
         Console.WriteLine("{0} {1:M}.\n", dateString, DateTime.Now);                           
      }                                           
   }
}
// The example displays output similar to the following:
//       Current UI Culture: en-US
//       Today is February 03.
//       
//       Current UI Culture: fr-FR
//       Aujourd'hui, c'est le 3 février
//       
//       Current UI Culture: ru-RU
//       Сегодня февраля 03.
//       
//       Current UI Culture: sv-SE
//       Today is den 3 februari.
Imports System.Globalization
Imports System.Resources
Imports System.Threading

<Assembly:NeutralResourcesLanguage("en")>

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "fr-FR", "ru-RU", "sv-SE" }
      Dim rm As New ResourceManager("DateStrings",
                                    GetType(Example).Assembly)
      
      For Each cultureName In cultureNames
         Dim culture As CultureInfo = CultureInfo.CreateSpecificCulture(cultureName)
         Thread.CurrentThread.CurrentCulture = culture 
         Thread.CurrentThread.CurrentUICulture = culture

         Console.WriteLine("Current UI Culture: {0}", 
                           CultureInfo.CurrentUICulture.Name)
         Dim dateString As String = rm.GetString("DateStart")
         Console.WriteLine("{0} {1:M}.", dateString, Date.Now)                           
         Console.WriteLine()
      Next                                           
   End Sub
End Module
' The example displays output similar to the following:
'       Current UI Culture: en-US
'       Today is February 03.
'       
'       Current UI Culture: fr-FR
'       Aujourd'hui, c'est le 3 février
'       
'       Current UI Culture: ru-RU
'       Сегодня февраля 03.
'       
'       Current UI Culture: sv-SE
'       Today is den 3 februari.

Per compilare questo esempio, creare un file batch contenente i comandi seguenti ed eseguirlo dal prompt dei comandi.To compile this example, create a batch file that contains the following commands and run it from the command prompt. Se si utilizza C#, specificare csc anziché vbc e showdate.cs anziché showdate.vb.If you're using C#, specify csc instead of vbc and showdate.cs instead of showdate.vb.

  
resgen DateStrings.txt  
vbc showdate.vb /resource:DateStrings.resources  
  
md fr-FR  
resgen DateStrings.fr-FR.txt  
al /out:fr-FR\Showdate.resources.dll /culture:fr-FR /embed:DateStrings.fr-FR.resources   
  
md ru-RU  
resgen DateStrings.ru-RU.txt  
al /out:ru-RU\Showdate.resources.dll /culture:ru-RU /embed:DateStrings.ru-RU.resources  
  

Esistono due modi per recuperare le risorse di impostazioni cultura specifiche diverse dalle impostazioni cultura correnti dell'interfaccia utente:There are two ways to retrieve the resources of a specific culture other than the current UI culture:

  • È possibile chiamare il GetString(String, CultureInfo)metodo GetObject(String, CultureInfo), o GetStream(String, CultureInfo) per recuperare una risorsa per impostazioni cultura specifiche.You can call the GetString(String, CultureInfo), GetObject(String, CultureInfo), or GetStream(String, CultureInfo) method to retrieve a resource for a specific culture. Se non è possibile trovare una risorsa localizzata, Resource Manager usa il processo di fallback delle risorse per individuare una risorsa appropriata.If a localized resource cannot be found, the resource manager uses the resource fallback process to locate an appropriate resource.

  • È possibile chiamare il GetResourceSet metodo per ottenere un ResourceSet oggetto che rappresenta le risorse per determinate impostazioni cultura.You can call the GetResourceSet method to obtain a ResourceSet object that represents the resources for a particular culture. Nella chiamata al metodo è possibile determinare se il gestore di risorse esegue il probe delle impostazioni cultura padre se non è in grado di trovare le risorse localizzate o se è semplicemente in grado di eseguire il fallback alle risorse delle impostazioni cultura predefinite.In the method call, you can determine whether the resource manager probes for parent cultures if it is unable to find localized resources, or whether it simply falls back to the resources of the default culture. È quindi possibile usare i ResourceSet metodi per accedere alle risorse (localizzate per le impostazioni cultura) in base al nome o per enumerare le risorse nel set.You can then use the ResourceSet methods to access the resources (localized for that culture) by name, or to enumerate the resources in the set.

Gestione delle eccezioni MissingManifestResourceException e MissingSatelliteAssemblyExceptionHandling MissingManifestResourceException and MissingSatelliteAssemblyException Exceptions

Se si tenta di recuperare una risorsa specifica, ma il gestore di risorse non riesce a trovare tale risorsa e non è stata definita alcuna impostazione cultura predefinita oppure non è possibile individuare le risorse delle impostazioni cultura predefinite, MissingManifestResourceException Resource Manager genera un'eccezione se prevede di trovare le risorse nell'assembly principale o un MissingSatelliteAssemblyException se prevede di trovare le risorse in un assembly satellite.If you try to retrieve a specific resource, but the resource manager cannot find that resource and either no default culture has been defined or the resources of the default culture cannot be located, the resource manager throws a MissingManifestResourceException exception if it expects to find the resources in the main assembly or a MissingSatelliteAssemblyException if it expects to find the resources in a satellite assembly. Si noti che l'eccezione viene generata quando si chiama un metodo di recupero delle risorse GetString , GetObjectad esempio o, e non quando si ResourceManager crea un'istanza di un oggetto.Note that the exception is thrown when you call a resource retrieval method such as GetString or GetObject, and not when you instantiate a ResourceManager object.

L'eccezione viene in genere generata nelle condizioni seguenti:The exception is typically thrown under the following conditions:

  • Il file di risorse o l'assembly satellite appropriato non esiste.The appropriate resource file or satellite assembly does not exist. Se il gestore delle risorse prevede che le risorse predefinite dell'app siano incorporate nell'assembly dell'app principale, sono assenti.If the resource manager expects the app's default resources to be embedded in the main app assembly, they are absent. Se l' NeutralResourcesLanguageAttribute attributo indica che le risorse predefinite dell'app risiedono in un assembly satellite, l'assembly non viene trovato.If the NeutralResourcesLanguageAttribute attribute indicates that the app's default resources reside in a satellite assembly, that assembly cannot be found. Quando si compila l'app, assicurarsi che le risorse siano incorporate nell'assembly principale o che l'assembly satellite necessario venga generato e che sia denominato in modo appropriato.When you compile your app, make sure that resources are embedded in the main assembly or that the necessary satellite assembly is generated and is named appropriately. Il nome deve avere il formato appname. resources. dll e deve trovarsi in una directory denominata dopo le impostazioni cultura di cui sono contenute le risorse.Its name should take the form appName.resources.dll, and it should be located in a directory named after the culture whose resources it contains.

  • Per l'app non sono definite impostazioni cultura predefinite o non associate ad alcun paese.Your app doesn't have a default or neutral culture defined. Aggiungere l' NeutralResourcesLanguageAttribute attributo a un file di codice sorgente o al file di informazioni del progetto (AssemblyInfo. vb per un'app Visual Basic o AssemblyInfo.cs C# per un'app).Add the NeutralResourcesLanguageAttribute attribute to a source code file or to the project information file (AssemblyInfo.vb for a Visual Basic app or AssemblyInfo.cs for a C# app) file.

  • Il baseName parametroResourceManager(String, Assembly) nel costruttore non specifica il nome di un file con estensione resources.The baseName parameter in the ResourceManager(String, Assembly) constructor does not specify the name of a .resources file. Il nome deve includere lo spazio dei nomi completo del file di risorse, ma non l'estensione del nome file.The name should include the resource file's fully qualified namespace but not its file name extension. In genere, i file di risorse creati in Visual Studio includono nomi di spazio dei nomi, ma i file di risorse creati e compilati al prompt dei comandi non lo eseguono.Typically, resource files that are created in Visual Studio include namespace names, but resource files that are created and compiled at the command prompt do not. È possibile determinare i nomi dei file con estensione resources incorporati compilando ed eseguendo l'utilità riportata di seguito.You can determine the names of embedded .resources files by compiling and running the following utility. Si tratta di un'app console che accetta il nome di un assembly principale o di un assembly satellite come parametro della riga di comando.This is a console app that accepts the name of a main assembly or satellite assembly as a command-line parameter. Visualizza le stringhe che devono essere fornite come baseName parametro in modo che Resource Manager possa identificare correttamente la risorsa.It displays the strings that should be provided as the baseName parameter so that the resource manager can correctly identify the resource.

    using System;
    using System.IO;
    using System.Reflection;
    using System.Resources;
    
    public class Example
    {
       public static void Main()
       {
          if (Environment.GetCommandLineArgs().Length == 1) { 
             Console.WriteLine("No filename.");
             return;
          }
          
          string filename = Environment.GetCommandLineArgs()[1].Trim();
          // Check whether the file exists.
          if (! File.Exists(filename)) {
             Console.WriteLine("{0} does not exist.", filename);
             return;
          }   
          
          // Try to load the assembly.
          Assembly assem = Assembly.LoadFrom(filename);
          Console.WriteLine("File: {0}", filename);
             
          // Enumerate the resource files.
          string[] resNames = assem.GetManifestResourceNames();
          if (resNames.Length == 0)
             Console.WriteLine("   No resources found.");
    
          foreach (var resName in resNames)
             Console.WriteLine("   Resource: {0}", resName.Replace(".resources", ""));
    
          Console.WriteLine();
       }
    }
    
    Imports System.IO
    Imports System.Reflection
    Imports System.Resources
    
    Module Example
       Public Sub Main()
          If Environment.GetCommandLineArgs.Length = 1 Then 
             Console.WriteLine("No filename.")
             Exit Sub
          End If
          Dim filename As String = Environment.GetCommandLineArgs(1).Trim()
          ' Check whether the file exists.
          If Not File.Exists(filename) Then
             Console.WriteLine("{0} does not exist.", filename)
             Exit Sub
          End If   
          
          ' Try to load the assembly.
          Dim assem As Assembly = Assembly.LoadFrom(filename)
          Console.WriteLine("File: {0}", filename)
             
          ' Enumerate the resource files.
          Dim resNames() As String = assem.GetManifestResourceNames()
          If resNames.Length = 0 Then
             Console.WriteLine("   No resources found.")
          End If
          For Each resName In resNames
             Console.WriteLine("   Resource: {0}", resName.Replace(".resources", ""))
          Next
          Console.WriteLine()
       End Sub
    End Module
    

Se si modificano le impostazioni cultura correnti dell'applicazione in modo esplicito, è necessario ricordare anche che Gestione risorse recupera un set di risorse in base al valore CultureInfo.CurrentUICulture della proprietà e non alla CultureInfo.CurrentCulture proprietà.If you are changing the current culture of your application explicitly, you should also remember that the resource manager retrieves a resource set based on the value of the CultureInfo.CurrentUICulture property, and not the CultureInfo.CurrentCulture property. In genere, se si modifica un valore, è necessario modificare anche l'altro.Typically, if you change one value, you should also change the other.

Controllo delle versioni delle risorseResource Versioning

Poiché l'assembly principale che contiene le risorse predefinite di un'app è separato dagli assembly satellite dell'app, è possibile rilasciare una nuova versione dell'assembly principale senza ridistribuire gli assembly satellite.Because the main assembly that contains an app's default resources is separate from the app's satellite assemblies, you can release a new version of your main assembly without redeploying the satellite assemblies. Usare l'attributo SatelliteContractVersionAttribute per usare gli assembly satellite esistenti e indicare a Resource Manager di non ridistribuirli con una nuova versione dell'assembly principale.You use the SatelliteContractVersionAttribute attribute to use existing satellite assemblies and instruct the resource manager not to redeploy them with a new version of your main assembly,

Per ulteriori informazioni sul supporto del controllo delle versioni per gli assembly satellite, vedere l'articolo recupero di risorse.For more information about versioning support for satellite assemblies, see the article Retrieving Resources.

<satelliteassemblies > nodo del file di configurazione<satelliteassemblies> Configuration File Node

Per gli eseguibili distribuiti ed eseguiti da un sito Web (file href. exe), l' ResourceManager oggetto può verificare la presenza di assembly satellite sul Web, il che può influire negativamente sulle prestazioni dell'app.For executables that are deployed and run from a website (HREF .exe files), the ResourceManager object may probe for satellite assemblies over the web, which can hurt your app's performance. Per eliminare il problema relativo alle prestazioni, è possibile limitare questo Probe agli assembly satellite distribuiti con l'app.To eliminate the performance problem, you can limit this probing to the satellite assemblies that you have deployed with your app. A tale scopo, si crea un <satelliteassemblies> nodo nel file di configurazione dell'app per specificare che è stato distribuito un set specifico di impostazioni cultura per l'app e che l' ResourceManager oggetto non deve tentare di eseguire il probe per le impostazioni cultura non elencate in quel nodo.To do this, you create a <satelliteassemblies> node in your app's configuration file to specify that you have deployed a specific set of cultures for your app, and that the ResourceManager object should not try to probe for any culture that is not listed in that node.

Nota

L'alternativa preferita alla creazione di <satelliteassemblies> un nodo consiste nell'utilizzare la funzionalità del manifesto di distribuzione ClickOnce .The preferred alternative to creating a <satelliteassemblies> node is to use the ClickOnce Deployment Manifest feature.

Nel file di configurazione dell'app creare una sezione simile alla seguente:In your app's configuration file, create a section similar to the following:

<?xml version ="1.0"?>  
<configuration>  
    <satelliteassemblies>  
        <assembly name="MainAssemblyName, Version=versionNumber, Culture=neutral, PublicKeyToken=null|yourPublicKeyToken">  
            <culture>cultureName1</culture>  
            <culture>cultureName2</culture>  
            <culture>cultureName3</culture>  
        </assembly>  
    </satelliteassemblies>  
</configuration>  

Modificare le informazioni di configurazione nel modo seguente:Edit this configuration information as follows:

  • Specificare uno o più <assembly> nodi per ogni assembly principale distribuito, in cui ogni nodo specifica un nome di assembly completo.Specify one or more <assembly> nodes for each main assembly that you deploy, where each node specifies a fully qualified assembly name. Specificare il nome dell'assembly principale al posto di MainAssemblyNamee specificare i Versionvalori di attributo, PublicKeyTokene Culture che corrispondono all'assembly principale.Specify the name of your main assembly in place of MainAssemblyName, and specify the Version, PublicKeyToken, and Culture attribute values that correspond to your main assembly.

    Per l' Version attributo, specificare il numero di versione dell'assembly.For the Version attribute, specify the version number of your assembly. Ad esempio, la prima versione dell'assembly potrebbe essere il numero di versione 1.0.0.0.For example, the first release of your assembly might be version number 1.0.0.0.

    Per l' PublicKeyToken attributo, specificare la parola null chiave se l'assembly non è stato firmato con un nome sicuro oppure specificare il token di chiave pubblica se è stato firmato l'assembly.For the PublicKeyToken attribute, specify the keyword null if you have not signed your assembly with a strong name, or specify your public key token if you have signed your assembly.

    Per l' Culture attributo, specificare la parola neutral chiave per definire l'assembly principale e fare in ResourceManager modo che la classe verifichi solo le impostazioni cultura elencate <culture> nei nodi.For the Culture attribute, specify the keyword neutral to designate the main assembly and cause the ResourceManager class to probe only for the cultures listed in the <culture> nodes.

    Per ulteriori informazioni sui nomi di assembly completi, vedere l'articolo nomi degli assembly.For more information about fully qualified assembly names, see the article Assembly Names. Per ulteriori informazioni sugli assembly con nome sicuro, vedere l'articolo creazione e utilizzo di assembly con nome sicuro.For more information about strong-named assemblies, see the article Creating and Using Strong-Named Assemblies.

  • Specificare uno o più <culture> nodi con un nome di impostazioni cultura specifico, ad esempio "fr-FR", o un nome di impostazioni cultura non associate ad alcun paese, ad esempio "fr".Specify one or more <culture> nodes with a specific culture name, such as "fr-FR", or a neutral culture name, such as "fr".

Se sono necessarie risorse per qualsiasi assembly non elencato <satelliteassemblies> nel nodo, la classe esegue il ResourceManager Probe delle impostazioni cultura usando le regole di sondaggio standard.If resources are needed for any assembly not listed under the <satelliteassemblies> node, the ResourceManager class probes for cultures using standard probing rules.

Applicazioni Windows 8.x StoreWindows 8.x StoreWindows 8.x StoreWindows 8.x Store Apps

Importante

Sebbene la ResourceManager classe sia supportata nelle Windows 8.x StoreWindows 8.x Store app, non è consigliabile utilizzarla.Although the ResourceManager class is supported in Windows 8.x StoreWindows 8.x Store apps, we do not recommend its use. Usare questa classe solo quando si sviluppano Libreria di classi portabilePortable Class Library progetti che possono essere usati con le Windows 8.x StoreWindows 8.x Store app.Use this class only when you develop Libreria di classi portabilePortable Class Library projects that can be used with Windows 8.x StoreWindows 8.x Store apps. Per recuperare le risorse Windows 8.x StoreWindows 8.x Store dalle app, usare invece la classe Windows. ApplicationModel. resources. ResourceLoader .To retrieve resources from Windows 8.x StoreWindows 8.x Store apps, use the Windows.ApplicationModel.Resources.ResourceLoader class instead.

Per Windows 8.x StoreWindows 8.x Store le app, ResourceManager la classe recupera le risorse dai file di indice delle risorse del pacchetto (PRI).For Windows 8.x StoreWindows 8.x Store apps, the ResourceManager class retrieves resources from package resource index (PRI) files. Un singolo file PRI (il file PRI del pacchetto dell'applicazione) contiene le risorse per le impostazioni cultura predefinite e per tutte le impostazioni cultura localizzate.A single PRI file (the application package PRI file) contains the resources for both the default culture and any localized cultures. Usare l'utilità MakePRI per creare un file PRI da uno o più file di risorse che si trovano nel formato di risorse XML (con estensione resw).You use the MakePRI utility to create a PRI file from one or more resource files that are in XML resource (.resw) format. Per le risorse incluse in un progetto di Visual Studio, Visual Studio gestisce automaticamente il processo di creazione e creazione del pacchetto del file PRI.For resources that are included in a Visual Studio project, Visual Studio handles the process of creating and packaging the PRI file automatically. È quindi possibile usare la classe ResourceManager .NET Framework per accedere alle risorse della libreria o dell'app.You can then use the .NET Framework ResourceManager class to access the app's or library's resources.

È possibile creare un'istanza ResourceManager di un oggetto Windows 8.x StoreWindows 8.x Store per un'app in modo analogo a un'app desktop.You can instantiate a ResourceManager object for a Windows 8.x StoreWindows 8.x Store app in the same way that you do for a desktop app.

È quindi possibile accedere alle risorse per determinate impostazioni cultura passando il nome della risorsa da recuperare al GetString(String) metodo.You can then access the resources for a particular culture by passing the name of the resource to be retrieved to the GetString(String) method. Per impostazione predefinita, questo metodo restituisce la risorsa per le impostazioni cultura determinate dalle impostazioni cultura dell'interfaccia utente correnti del thread che ha effettuato la chiamata.By default, this method returns the resource for the culture determined by the current UI culture of the thread that made the call. È anche possibile recuperare le risorse per impostazioni cultura specifiche passando il nome della risorsa e un CultureInfo oggetto che rappresenta le impostazioni cultura di cui deve essere recuperata la risorsa GetString(String, CultureInfo) al metodo.You can also retrieve the resources for a specific culture by passing the name of the resource and a CultureInfo object that represents the culture whose resource is to be retrieved to the GetString(String, CultureInfo) method. Se non è possibile trovare la risorsa per le impostazioni cultura correnti dell'interfaccia utente o le impostazioni cultura specificate, Resource Manager usa un elenco di fallback della lingua dell'interfaccia utente per individuare una risorsa appropriata.If the resource for the current UI culture or the specified culture cannot be found, the resource manager uses a UI language fallback list to locate a suitable resource.

Costruttori

ResourceManager() ResourceManager() ResourceManager() ResourceManager()

Inizializza una nuova istanza della classe ResourceManager con i valori predefiniti.Initializes a new instance of the ResourceManager class with default values.

ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly) ResourceManager(String, Assembly)

Inizializza una nuova istanza della classe ResourceManager che ricerca le risorse contenute nei file con il nome radice specificato nell'assembly fornito.Initializes a new instance of the ResourceManager class that looks up resources contained in files with the specified root name in the given assembly.

ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type) ResourceManager(String, Assembly, Type)

Inizializza una nuova istanza della classe ResourceManager che usa una classe ResourceSet specificata per cercare le risorse contenute nei file con il nome radice specificato nell'assembly fornito.Initializes a new instance of the ResourceManager class that uses a specified ResourceSet class to look up resources contained in files with the specified root name in the given assembly.

ResourceManager(Type) ResourceManager(Type) ResourceManager(Type) ResourceManager(Type)

Inizializza una nuova istanza della classe ResourceManager che ricerca le risorse negli assembly satellite in base alle informazioni derivate dall'oggetto di tipo specificato.Initializes a new instance of the ResourceManager class that looks up resources in satellite assemblies based on information from the specified type object.

Campi

BaseNameField BaseNameField BaseNameField BaseNameField

Specifica il nome radice dei file di risorse in cui l'oggetto ResourceManager cerca le risorse.Specifies the root name of the resource files that the ResourceManager searches for resources.

HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber HeaderVersionNumber

Specifica la versione delle intestazioni dei file di risorse interpretabili e producibili dall'implementazione corrente di ResourceManager.Specifies the version of resource file headers that the current implementation of ResourceManager can interpret and produce.

MagicNumber MagicNumber MagicNumber MagicNumber

Contiene il numero usato per identificare i file di risorse.Holds the number used to identify resource files.

MainAssembly MainAssembly MainAssembly MainAssembly

Specifica l'assembly principale che contiene le risorse.Specifies the main assembly that contains the resources.

ResourceSets ResourceSets ResourceSets ResourceSets

Contiene un oggetto Hashtable che restituisce un mapping dalle impostazioni cultura agli oggetti ResourceSet.Contains a Hashtable that returns a mapping from cultures to ResourceSet objects.

Proprietà

BaseName BaseName BaseName BaseName

Ottiene il nome radice dei file di risorse in cui l'oggetto ResourceManager ricerca le risorse.Gets the root name of the resource files that the ResourceManager searches for resources.

FallbackLocation FallbackLocation FallbackLocation FallbackLocation

Ottiene o imposta il percorso da cui recuperare le risorse di fallback predefinite.Gets or sets the location from which to retrieve default fallback resources.

IgnoreCase IgnoreCase IgnoreCase IgnoreCase

Ottiene o imposta un valore che indica se il gestore delle risorse consente la ricerca delle risorse senza distinzione tra maiuscole e minuscole nei metodi GetString(String) e GetObject(String).Gets or sets a value that indicates whether the resource manager allows case-insensitive resource lookups in the GetString(String) and GetObject(String) methods.

ResourceSetType ResourceSetType ResourceSetType ResourceSetType

Ottiene il tipo di oggetto set di risorse usato dal gestore delle risorse per costruire un oggetto ResourceSet.Gets the type of the resource set object that the resource manager uses to construct a ResourceSet object.

Metodi

CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type) CreateFileBasedResourceManager(String, String, Type)

Restituisce un oggetto ResourceManager che ricerca le risorse in una directory specifica invece che nel manifesto dell'assembly per le risorse.Returns a ResourceManager object that searches a specific directory instead of an assembly manifest for resources.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly) GetNeutralResourcesLanguage(Assembly)

Restituisce le informazioni specifiche delle impostazioni cultura per le risorse predefinite dell'assembly principale mediante il recupero del valore dell'attributo NeutralResourcesLanguageAttribute su un assembly specificato.Returns culture-specific information for the main assembly's default resources by retrieving the value of the NeutralResourcesLanguageAttribute attribute on a specified assembly.

GetObject(String) GetObject(String) GetObject(String) GetObject(String)

Restituisce il valore della risorsa non di tipo stringa specificata.Returns the value of the specified non-string resource.

GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo) GetObject(String, CultureInfo)

Ottiene il valore della risorsa non di tipo stringa specificata localizzata per le impostazioni cultura specificate.Gets the value of the specified non-string resource localized for the specified culture.

GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo) GetResourceFileName(CultureInfo)

Genera il nome del file di risorse per l'oggetto CultureInfo specificato.Generates the name of the resource file for the given CultureInfo object.

GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean) GetResourceSet(CultureInfo, Boolean, Boolean)

Recupera il set di risorse per impostazioni cultura specifiche.Retrieves the resource set for a particular culture.

GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly) GetSatelliteContractVersion(Assembly)

Restituisce la versione specificata dall'attributo SatelliteContractVersionAttribute nell'assembly specificato.Returns the version specified by the SatelliteContractVersionAttribute attribute in the given assembly.

GetStream(String) GetStream(String) GetStream(String) GetStream(String)

Restituisce un oggetto di flusso di memoria non gestito dalla risorsa specificata.Returns an unmanaged memory stream object from the specified resource.

GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo) GetStream(String, CultureInfo)

Restituisce un oggetto flusso di memoria non gestito dalla risorsa specificata usando le impostazioni cultura specificate.Returns an unmanaged memory stream object from the specified resource, using the specified culture.

GetString(String) GetString(String) GetString(String) GetString(String)

Restituisce il valore della risorsa di tipo stringa specificata.Returns the value of the specified string resource.

GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo) GetString(String, CultureInfo)

Restituisce il valore della risorsa di tipo stringa localizzata per le impostazioni cultura specificate.Returns the value of the string resource localized for the specified culture.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean) InternalGetResourceSet(CultureInfo, Boolean, Boolean)

Fornisce l'implementazione per trovare un set di risorse.Provides the implementation for finding a resource set.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
ReleaseAllResources() ReleaseAllResources() ReleaseAllResources() ReleaseAllResources()

Indica al gestore delle risorse di chiamare il metodo Close() su tutti gli oggetti ResourceSet e di rilasciare tutte le risorse.Tells the resource manager to call the Close() method on all ResourceSet objects and release all resources.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche