Are ResourceStrings Really Cached?

Question

All, a while back (when I was rushed off my feet) I asked the following question Performace Overheads when Using Resource Files (.resx) regarding the performance overhead of using resource strings. I got an up-voted answer and took the answer to be correct. However, before, I was localising message strings which are called in error conditions and not performance critical - now I have been asked to implement localisation to our codes 'power-house' (lots of performance critical code, embedded loops etc.). Having some time to look into this in more detail and I noticed that calling a resource like ``` Resources.MessageStrings.SomeResourceName ``` merely refers the call to the auto-generated code `MessageStrings.Designer.cs`, which uses ``` internal static string SomeResourceName { get { return ResourceManager.GetString("SomeResourceName", resourceCulture);} } ``` So digging deeper, I thought I would decompile `ResourceManager` which is found in C:\Program Files (x86)\Reference Assemblies…

Accepted Answer

The ressources are cached. If you follow the call stack through the resource manager it is like this: 1.

```
[System.Security.SecuritySafeCritical]  // auto-generated 
public virtual String GetString(String name, CultureInfo culture) {
  //...
  String value = rs.GetString(name, _ignoreCase);
  //...
}
```

2.

```
public virtual string GetString(string name, bool ignoreCase)
{
  object objectInternal = this.GetObjectInternal(name);
  //...
}
```

3.

```
private object GetObjectInternal(string name)
{
  //...
  Hashtable hashtable = this.Table;
  //...
  return hashtable[(object) name];
}
```

So at this point the values is read from the hashtable.

The hashtable is filled once the ressource file is accessed:

Constructor:

```
[SecuritySafeCritical]
public ResourceSet(string fileName)
{
  this.Reader = (IResourceReader) new ResourceReader(fileName);
  this.CommonInit();
  this.ReadResources();
}
```

and the ReadResources:

```
protected virtual void ReadResources()
{
  IDictionaryEnumerator enumerator = this.Reader.GetEnumerator();
  while (enumerator.MoveNext())
  {
    object obj = enumerator.Value;
    this.Table.Add(enumerator.Key, obj);
  }
}
```

Are ResourceStrings Really Cached?

Solution

Problem

Related problems