Lesen Sie die Zeichenfolge aus der RESX-Datei in C #

Wie lese ich den String aus der .resx-Datei in c #? Bitte senden Sie mir Richtlinien. Schritt für Schritt

Dieses Beispiel stammt von der MSDN-Seite in 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");

ResourceManagersollte nicht benötigt werden, es sei denn, Sie laden von einer externen Ressource.
Angenommen, Sie haben ein Projekt erstellt (DLL, WinForms usw.), verwenden Sie einfach den Projektnamespace "Ressourcen" und die Ressourcenkennung. z.B:

Angenommen, ein Projekt-Namespace: UberSoft.WidgetPro

Und dein Resx enthält:

Sie können einfach verwenden:

Ubersoft.WidgetPro.Properties.Resources.RESPONSE_SEARCH_WILFRED

Versuchen Sie dies, funktioniert für mich .. einfach

Angenommen, Ihr Ressourcendateiname lautet "TestResource.resx" und Sie möchten den Schlüssel dann dynamisch übergeben.

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

Namespace hinzufügen

using System.Resources;

Öffnen Sie die .resx-Datei und setzen Sie "Access Modifier" auf Public.

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

Angenommen, die .resx-Datei wurde mit Visual Studio unter den Projekteigenschaften hinzugefügt, gibt es eine einfachere und weniger fehleranfällige Möglichkeit, auf die Zeichenfolge zuzugreifen.

1. Wenn Sie die .resx-Datei im Projektmappen-Explorer erweitern, sollte eine .Designer.cs-Datei angezeigt werden.
2. Beim Öffnen verfügt die Datei .Designer.cs über einen Eigenschaften-Namespace und eine interne Klasse. In diesem Beispiel wird angenommen, dass die Klasse Ressourcen heißt.

3. Der Zugriff auf die Zeichenfolge ist dann so einfach wie:

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

4. Durch JoshCodes.Core.Testing.Unitden Standard-Namespace des Projekts ersetzen .

5. Ersetzen Sie "exampleXml" durch den Namen Ihrer Zeichenfolgenressource.

Gefolgt von @ JeffH Antwort, empfehle ich, typeof()als String Assembly Name zu verwenden.

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

Wenn Sie Ihre Ressourcendateien aus irgendeinem Grund nicht in App_GlobalResources ablegen können, können Sie Ressourcendateien direkt mit ResXResourceReader oder einem XML-Reader öffnen.

Hier ist ein Beispielcode für die Verwendung des 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 "";
   }

Sobald Sie der Lösung / Assembly eine Ressource (Name: Ressourcenname und Wert: ResourceValue) hinzugefügt haben, können Sie einfach "Properties.Resources.ResourceName" verwenden, um die erforderliche Ressource abzurufen.

Ich habe die .resx-Datei über Visual Studio hinzugefügt. Dadurch wurde eine designer.csDatei mit Eigenschaften erstellt, die sofort den Wert eines beliebigen Schlüssels zurückgibt. Dies ist beispielsweise ein automatisch generierter Code aus der Designer-Datei.

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

Auf diese Weise konnte ich einfach Folgendes tun:

string message = Errors.MyErrorMessage;

Wo Errorswird die Errors.resxDatei über Visual Studio erstellt und MyErrorMessageist der Schlüssel.

Ich habe meine Ressourcendatei direkt zu meinem Projekt hinzugefügt, sodass ich mit dem Namen der Resx-Datei problemlos auf die darin enthaltenen Zeichenfolgen zugreifen konnte.

Beispiel: Geben Sie in Resource1.resx den Schlüssel "resourceKey" -> string "dataString" ein. Um die Zeichenfolge "dataString" zu erhalten, habe ich einfach Resource1.resourceKey eingefügt.

Es mag Gründe geben, dies nicht zu tun, von denen ich nichts weiß, aber es hat bei mir funktioniert.

Der einfachste Weg, dies zu tun, ist:

1. Erstellen Sie einen App_GlobalResources-Systemordner und fügen Sie ihm eine Ressourcendatei hinzu, z. B. Messages.resx
2. Erstellen Sie Ihre Einträge in der Ressourcendatei, z. B. ErrorMsg = Dies ist ein Fehler.
3. Um dann auf diesen Eintrag zuzugreifen: string errormsg = Resources.Messages.ErrorMsg

Der einfachste Weg, um Wert aus der Ressourcendatei zu erhalten. Fügen Sie dem Projekt eine Ressourcendatei hinzu. Holen Sie sich nun die Zeichenfolge, die Sie hinzufügen möchten, wie in meinem Fall ein Textblock (SilverLight). Es ist auch nicht erforderlich, einen Namespace hinzuzufügen. In meinem Fall funktioniert es einwandfrei

txtStatus.Text = Constants.RefractionUpdateMessage;

Konstanten ist mein Ressourcendateiname im Projekt.

Erstellen Sie einen Ressourcenmanager, um Ressourcen abzurufen.

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

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

param1 = "AssemblyName.ResourceFolderName.ResourceFileName"

param2 = Name der Zeichenfolge, die aus der Ressourcendatei abgerufen werden soll

Das funktioniert bei mir. Angenommen, Sie haben eine Datei strings.resx mit der Zeichenfolge ok. um es zu lesen

String varOk = My.Resources.strings.ok