lire la chaîne du fichier .resx en C #

Comment lire la chaîne du fichier .resx en c #? veuillez m'envoyer des directives. pas à pas

Cet exemple provient de la page MSDN sur 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");

ResourceManagerne devrait pas être nécessaire sauf si vous chargez à partir d'une ressource externe .
Pour la plupart des choses, disons que vous avez créé un projet (DLL, WinForms, peu importe), vous utilisez simplement l'espace de noms du projet, «Resources» et l'identificateur de ressource. par exemple:

En supposant un espace de noms de projet: UberSoft.WidgetPro

Et votre resx contient:

Vous pouvez simplement utiliser:

Ubersoft.WidgetPro.Properties.Resources.RESPONSE_SEARCH_WILFRED

Essayez ceci, ça marche pour moi .. simple

Supposons que votre nom de fichier de ressources est "TestResource.resx" et que vous souhaitez passer la clé dynamiquement,

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

Ajouter un espace de noms

using System.Resources;

Ouvrez le fichier .resx et définissez "Access Modifier" sur Public.

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

En supposant que le fichier .resx a été ajouté à l'aide de Visual Studio sous les propriétés du projet, il existe un moyen plus simple et moins sujet aux erreurs d'accéder à la chaîne.

1. Le développement du fichier .resx dans l'Explorateur de solutions doit afficher un fichier .Designer.cs.
2. Une fois ouvert, le fichier .Designer.cs possède un espace de noms Properties et une classe interne. Pour cet exemple, supposons que la classe s'appelle Resources.

3. Accéder à la chaîne est alors aussi simple que:

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

4. Remplacez JoshCodes.Core.Testing.Unitpar l'espace de noms par défaut du projet.

5. Remplacez "exampleXml" par le nom de votre ressource de chaîne.

Suivi de la réponse @JeffH, je recommande d'utiliser le typeof()nom d'assembly de chaîne.

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

Si, pour une raison quelconque, vous ne pouvez pas placer vos fichiers de ressources dans App_GlobalResources, vous pouvez ouvrir les fichiers de ressources directement à l'aide de ResXResourceReader ou d'un lecteur XML.

Voici un exemple de code pour utiliser 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 "";
   }

Une fois que vous avez ajouté une ressource (Nom: ResourceName et Value: ResourceValue) à la solution / assembly, vous pouvez simplement utiliser "Properties.Resources.ResourceName" pour obtenir la ressource requise.

J'ai ajouté le fichier .resx via Visual Studio. Cela a créé un designer.csfichier avec des propriétés pour renvoyer immédiatement la valeur de toute clé que je voulais. Par exemple, il s'agit d'un code généré automatiquement à partir du fichier de concepteur.

/// <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);
    }
}

De cette façon, j'ai pu simplement faire:

string message = Errors.MyErrorMessage;

Où Errorsest le Errors.resxfichier créé via Visual Studio et MyErrorMessageest la clé.

J'ai ajouté mon fichier de ressources directement à mon projet, et j'ai donc pu accéder aux chaînes à l'intérieur très bien avec le nom de fichier resx.

Exemple: dans Resource1.resx, clé "resourceKey" -> string "dataString". Pour obtenir la chaîne "dataString", je viens de mettre Resource1.resourceKey.

Il peut y avoir des raisons de ne pas faire cela que je ne connais pas, mais cela a fonctionné pour moi.

Le moyen le plus simple de procéder est:

1. Créez un dossier système App_GlobalResources et ajoutez-y un fichier de ressources, par exemple Messages.resx
2. Créez vos entrées dans le fichier de ressources, par exemple ErrorMsg = Ceci est une erreur.
3. Puis pour accéder à cette entrée: string errormsg = Resources.Messages.ErrorMsg

Le moyen le plus simple d'obtenir de la valeur à partir du fichier de ressources. Ajoutez un fichier de ressources dans le projet. Maintenant, récupérez la chaîne où vous souhaitez ajouter comme dans mon cas, c'était un bloc de texte (SilverLight). Pas besoin d'ajouter un espace de noms également, cela fonctionne bien dans mon cas

txtStatus.Text = Constants.RefractionUpdateMessage;

Constantes est le nom de mon fichier de ressources dans le projet.

Créez un gestionnaire de ressources pour récupérer des ressources.

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

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

param1 = "AssemblyName.ResourceFolderName.ResourceFileName"

param2 = nom de la chaîne à récupérer dans le fichier de ressources

Cela fonctionne pour moi. disons que vous avez un fichier strings.resx avec la chaîne ok dedans. pour le lire

String varOk = My.Resources.strings.ok