netcore/System.Private.CoreLib/shared/System/Resources/ResourceSet.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 /*============================================================
   6 **
   7 **
   8 **
   9 **
  10 **
  11 ** Purpose: Culture-specific collection of resources.
  12 **
  13 **
  14 ===========================================================*/
  15
  16 using System.Collections;
  17 using System.Diagnostics;
  18 using System.IO;
  19 using System.Reflection;
  20
  21 namespace System.Resources
  22 {
  23     // A ResourceSet stores all the resources defined in one particular CultureInfo.
  24     //
  25     // The method used to load resources is straightforward - this class
  26     // enumerates over an IResourceReader, loading every name and value, and
  27     // stores them in a hash table.  Custom IResourceReaders can be used.
  28     //
  29     public class ResourceSet : IDisposable, IEnumerable
  30     {
  31         protected IResourceReader Reader = null!;
  32         internal Hashtable? Table; // TODO-NULLABLE: Avoid nulling out in Dispose
  33
  34         private Hashtable? _caseInsensitiveTable;  // For case-insensitive lookups.
  35
  36         protected ResourceSet()
  37         {
  38             // To not inconvenience people subclassing us, we should allocate a new
  39             // hashtable here just so that Table is set to something.
  40             Table = new Hashtable();
  41         }
  42
  43         // For RuntimeResourceSet, ignore the Table parameter - it's a wasted
  44         // allocation.
  45         internal ResourceSet(bool junk)
  46         {
  47         }
  48
  49         // Creates a ResourceSet using the system default ResourceReader
  50         // implementation.  Use this constructor to open & read from a file
  51         // on disk.
  52         //
  53         public ResourceSet(string fileName)
  54             : this()
  55         {
  56             Reader = new ResourceReader(fileName);
  57             ReadResources();
  58         }
  59
  60         // Creates a ResourceSet using the system default ResourceReader
  61         // implementation.  Use this constructor to read from an open stream
  62         // of data.
  63         //
  64         public ResourceSet(Stream stream)
  65             : this()
  66         {
  67             Reader = new ResourceReader(stream);
  68             ReadResources();
  69         }
  70
  71         public ResourceSet(IResourceReader reader)
  72             : this()
  73         {
  74             if (reader == null)
  75                 throw new ArgumentNullException(nameof(reader));
  76             Reader = reader;
  77             ReadResources();
  78         }
  79
  80         // Closes and releases any resources used by this ResourceSet, if any.
  81         // All calls to methods on the ResourceSet after a call to close may
  82         // fail.  Close is guaranteed to be safely callable multiple times on a
  83         // particular ResourceSet, and all subclasses must support these semantics.
  84         public virtual void Close()
  85         {
  86             Dispose(true);
  87         }
  88
  89         protected virtual void Dispose(bool disposing)
  90         {
  91             if (disposing)
  92             {
  93                 // Close the Reader in a thread-safe way.
  94                 IResourceReader? copyOfReader = Reader;
  95                 Reader = null!; // TODO-NULLABLE: Avoid nulling out in Dispose
  96                 if (copyOfReader != null)
  97                     copyOfReader.Close();
  98             }
  99             Reader = null!; // TODO-NULLABLE: Avoid nulling out in Dispose
 100             _caseInsensitiveTable = null;
 101             Table = null;
 102         }
 103
 104         public void Dispose()
 105         {
 106             Dispose(true);
 107         }
 108
 109         // Returns the preferred IResourceReader class for this kind of ResourceSet.
 110         // Subclasses of ResourceSet using their own Readers &; should override
 111         // GetDefaultReader and GetDefaultWriter.
 112         public virtual Type GetDefaultReader()
 113         {
 114             return typeof(ResourceReader);
 115         }
 116
 117         // Returns the preferred IResourceWriter class for this kind of ResourceSet.
 118         // Subclasses of ResourceSet using their own Readers &; should override
 119         // GetDefaultReader and GetDefaultWriter.
 120         public virtual Type GetDefaultWriter()
 121         {
 122             Assembly resourceWriterAssembly = Assembly.Load("System.Resources.Writer, Version=4.0.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a");
 123             return resourceWriterAssembly.GetType("System.Resources.ResourceWriter", throwOnError: true)!;
 124         }
 125
 126         public virtual IDictionaryEnumerator GetEnumerator()
 127         {
 128             return GetEnumeratorHelper();
 129         }
 130
 131         IEnumerator IEnumerable.GetEnumerator()
 132         {
 133             return GetEnumeratorHelper();
 134         }
 135
 136         private IDictionaryEnumerator GetEnumeratorHelper()
 137         {
 138             Hashtable? copyOfTable = Table;  // Avoid a race with Dispose
 139             if (copyOfTable == null)
 140                 throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
 141             return copyOfTable.GetEnumerator();
 142         }
 143
 144         // Look up a string value for a resource given its name.
 145         //
 146         public virtual string? GetString(string name)
 147         {
 148             object? obj = GetObjectInternal(name);
 149             try
 150             {
 151                 return (string?)obj;
 152             }
 153             catch (InvalidCastException)
 154             {
 155                 throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotString_Name, name));
 156             }
 157         }
 158
 159         public virtual string? GetString(string name, bool ignoreCase)
 160         {
 161             object? obj;
 162             string? s;
 163
 164             // Case-sensitive lookup
 165             obj = GetObjectInternal(name);
 166             try
 167             {
 168                 s = (string?)obj;
 169             }
 170             catch (InvalidCastException)
 171             {
 172                 throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotString_Name, name));
 173             }
 174
 175             // case-sensitive lookup succeeded
 176             if (s != null || !ignoreCase)
 177             {
 178                 return s;
 179             }
 180
 181             // Try doing a case-insensitive lookup
 182             obj = GetCaseInsensitiveObjectInternal(name);
 183             try
 184             {
 185                 return (string?)obj;
 186             }
 187             catch (InvalidCastException)
 188             {
 189                 throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotString_Name, name));
 190             }
 191         }
 192
 193         // Look up an object value for a resource given its name.
 194         //
 195         public virtual object? GetObject(string name)
 196         {
 197             return GetObjectInternal(name);
 198         }
 199
 200         public virtual object? GetObject(string name, bool ignoreCase)
 201         {
 202             object? obj = GetObjectInternal(name);
 203
 204             if (obj != null || !ignoreCase)
 205                 return obj;
 206
 207             return GetCaseInsensitiveObjectInternal(name);
 208         }
 209
 210         protected virtual void ReadResources()
 211         {
 212             Debug.Assert(Table != null);
 213             Debug.Assert(Reader != null);
 214             IDictionaryEnumerator en = Reader.GetEnumerator();
 215             while (en.MoveNext())
 216             {
 217                 object? value = en.Value;
 218                 Table.Add(en.Key, value);
 219             }
 220             // While technically possible to close the Reader here, don't close it
 221             // to help with some WinRes lifetime issues.
 222         }
 223
 224         private object? GetObjectInternal(string name)
 225         {
 226             if (name == null)
 227                 throw new ArgumentNullException(nameof(name));
 228
 229             Hashtable? copyOfTable = Table;  // Avoid a race with Dispose
 230
 231             if (copyOfTable == null)
 232                 throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
 233
 234             return copyOfTable[name];
 235         }
 236
 237         private object? GetCaseInsensitiveObjectInternal(string name)
 238         {
 239             Hashtable? copyOfTable = Table;  // Avoid a race with Dispose
 240
 241             if (copyOfTable == null)
 242                 throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
 243
 244             Hashtable? caseTable = _caseInsensitiveTable;  // Avoid a race condition with Close
 245             if (caseTable == null)
 246             {
 247                 caseTable = new Hashtable(StringComparer.OrdinalIgnoreCase);
 248
 249                 IDictionaryEnumerator en = copyOfTable.GetEnumerator();
 250                 while (en.MoveNext())
 251                 {
 252                     caseTable.Add(en.Key, en.Value);
 253                 }
 254                 _caseInsensitiveTable = caseTable;
 255             }
 256
 257             return caseTable[name];
 258         }
 259     }
 260 }