legge la stringa dal file .resx in C #

Come leggere la stringa dal file .resx in c #? per favore inviami le linee guida. passo dopo passo

Questo esempio è tratto dalla pagina MSDN su ResourceManager.GetString () :

// Create a resource manager to retrieve resources.
ResourceManager rm = new ResourceManager("items", Assembly.GetExecutingAssembly());

// Retrieve the value of the string resource named "welcome".
// The resource manager will retrieve the value of the  
// localized resource using the caller's current culture setting.
String str = rm.GetString("welcome");

ResourceManagernon dovrebbe essere necessario a meno che non si stia caricando da una risorsa esterna .
Per la maggior parte delle cose, supponi di aver creato un progetto (DLL, WinForms, qualunque cosa) usi solo lo spazio dei nomi del progetto, "Risorse" e l'identificatore di risorsa. per esempio:

Supponendo uno spazio dei nomi del progetto: UberSoft.WidgetPro

E il tuo resx contiene:

Puoi semplicemente usare:

Ubersoft.WidgetPro.Properties.Resources.RESPONSE_SEARCH_WILFRED

Prova questo, funziona per me .. semplice

Supponi che il nome del tuo file di risorse sia "TestResource.resx" e quindi desideri passare la chiave dinamicamente,

string resVal = TestResource.ResourceManager.GetString(dynamicKeyVal);

Aggiungi spazio dei nomi

using System.Resources;

Apri il file .resx e imposta "Access Modifier" su Public.

var <Variable Name> = Properties.Resources.<Resource Name>

Supponendo che il file .resx sia stato aggiunto utilizzando Visual Studio nelle proprietà del progetto, esiste un modo più semplice e meno soggetto a errori per accedere alla stringa.

1. L'espansione del file .resx in Esplora soluzioni dovrebbe mostrare un file .Designer.cs.
2. Quando viene aperto, il file .Designer.cs ha uno spazio dei nomi Properties e una classe interna. Per questo esempio si supponga che la classe sia denominata Resources.

3. L'accesso alla stringa è quindi facile come:

   var resourceManager = JoshCodes.Core.Testing.Unit.Properties.Resources.ResourceManager;
   var exampleXmlString = resourceManager.GetString("exampleXml");

4. Sostituisci JoshCodes.Core.Testing.Unitcon lo spazio dei nomi predefinito del progetto.

5. Sostituisci "exampleXml" con il nome della tua risorsa stringa.

Seguito dalla risposta @JeffH, consiglio di utilizzare il typeof()nome dell'assembly di stringhe.

    var rm = new ResourceManager(typeof(YourAssembly.Properties.Resources));
    string message = rm.GetString("NameOfKey", CultureInfo.CreateSpecificCulture("ja-JP"));

Se per qualche motivo non è possibile inserire i file delle risorse in App_GlobalResources, è possibile aprire i file delle risorse direttamente utilizzando ResXResourceReader o un lettore XML.

Ecco un esempio di codice per l'utilizzo di ResXResourceReader:

   public static string GetResourceString(string ResourceName, string strKey)
   {


       //Figure out the path to where your resource files are located.
       //In this example, I'm figuring out the path to where a SharePoint feature directory is relative to a custom SharePoint layouts subdirectory.  

       string currentDirectory = Path.GetDirectoryName(HttpContext.Current.Server.MapPath(HttpContext.Current.Request.ServerVariables["SCRIPT_NAME"]));

       string featureDirectory = Path.GetFullPath(currentDirectory + "\\..\\..\\..\\FEATURES\\FEATURENAME\\Resources");

       //Look for files containing the name
       List<string> resourceFileNameList = new List<string>();

       DirectoryInfo resourceDir = new DirectoryInfo(featureDirectory);

       var resourceFiles = resourceDir.GetFiles();

       foreach (FileInfo fi in resourceFiles)
       {
           if (fi.Name.Length > ResourceName.Length+1 && fi.Name.ToLower().Substring(0,ResourceName.Length + 1) == ResourceName.ToLower()+".")
           {
               resourceFileNameList.Add(fi.Name);

           }
        }

       if (resourceFileNameList.Count <= 0)
       { return ""; }


       //Get the current culture
       string strCulture = CultureInfo.CurrentCulture.Name;

       string[] cultureStrings = strCulture.Split('-');

       string strLanguageString = cultureStrings[0];


       string strResourceFileName="";
       string strDefaultFileName = resourceFileNameList[0];
       foreach (string resFileName in resourceFileNameList)
       {
           if (resFileName.ToLower() == ResourceName.ToLower() + ".resx")
           {
               strDefaultFileName = resFileName;
           }

           if (resFileName.ToLower() == ResourceName.ToLower() + "."+strCulture.ToLower() + ".resx")
           {
               strResourceFileName = resFileName;
               break;
           }
           else if (resFileName.ToLower() == ResourceName.ToLower() + "." + strLanguageString.ToLower() + ".resx")
           {
               strResourceFileName = resFileName;
               break;
           }
       }

       if (strResourceFileName == "")
       {
           strResourceFileName = strDefaultFileName;
       }



       //Use resx resource reader to read the file in.
       //https://msdn.microsoft.com/en-us/library/system.resources.resxresourcereader.aspx

       ResXResourceReader rsxr = new ResXResourceReader(featureDirectory + "\\"+ strResourceFileName);         

       //IDictionaryEnumerator idenumerator = rsxr.GetEnumerator();
       foreach (DictionaryEntry d in rsxr)
       {
           if (d.Key.ToString().ToLower() == strKey.ToLower())
           {
               return d.Value.ToString();
           }
       }


       return "";
   }

Dopo aver aggiunto una risorsa (Name: ResourceName e Value: ResourceValue) alla soluzione / assembly, è possibile utilizzare semplicemente "Properties.Resources.ResourceName" per ottenere la risorsa richiesta.

Ho aggiunto il file .resx tramite Visual Studio. Questo ha creato un designer.csfile con proprietà per restituire immediatamente il valore di qualsiasi chiave che volevo. Ad esempio, questo è un codice generato automaticamente dal file del designer.

/// <summary>
///   Looks up a localized string similar to When creating a Commissioning change request, you must select valid Assignees, a Type, a Component, and at least one (1) affected unit..
/// </summary>
public static string MyErrorMessage {
    get {
        return ResourceManager.GetString("MyErrorMessage", resourceCulture);
    }
}

In questo modo, sono stato in grado di fare semplicemente:

string message = Errors.MyErrorMessage;

Dov'è Errorsil Errors.resxfile creato tramite Visual Studio ed MyErrorMessageè la chiave.

Ho aggiunto direttamente il mio file di risorse al mio progetto, quindi sono stato in grado di accedere alle stringhe all'interno con il nome del file resx.

Esempio: in Resource1.resx, chiave "resourceKey" -> stringa "dataString". Per ottenere la stringa "dataString", è sufficiente inserire Resource1.resourceKey.

Potrebbero esserci ragioni per non farlo di cui non sono a conoscenza, ma per me ha funzionato.

Il modo più semplice per farlo è:

1. Crea una cartella di sistema App_GlobalResources e aggiungi un file di risorse ad essa, ad esempio Messages.resx
2. Crea le tue voci nel file delle risorse, ad esempio ErrorMsg = Questo è un errore.
3. Quindi per accedere a quella voce: string errormsg = Resources.Messages.ErrorMsg

Il modo più semplice per ottenere valore dal file di risorse. Aggiungi file di risorse nel progetto. Ora prendi la stringa dove vuoi aggiungere come nel mio caso fosse un blocco di testo (SilverLight). Non è necessario aggiungere anche alcuno spazio dei nomi. Nel mio caso funziona bene

txtStatus.Text = Constants.RefractionUpdateMessage;

Constants è il nome del mio file di risorse nel progetto.

Crea un gestore delle risorse per recuperare le risorse.

ResourceManager rm = new ResourceManager("param1",Assembly.GetExecutingAssembly());

String str = rm.GetString("param2");

param1 = "AssemblyName.ResourceFolderName.ResourceFileName"

param2 = nome della stringa da recuperare dal file di risorse

Questo funziona per me. diciamo di avere un file strings.resx con una stringa ok al suo interno. per leggerlo

String varOk = My.Resources.strings.ok