<UseRandomizedStringHashAlgorithm> Element

The following sections describe attributes, child elements, and parent elements.

Attributes

enabled Attribute

Child Elements

None.

Parent Elements

By default, the StringComparer class and the String.GetHashCode method use a single hashing algorithm that produces a consistent hash code across application domains and processes. This is equivalent to setting the enabled attribute of the <UseRandomizedStringHashAlgorithm> element to 0. This is the hashing algorithm used in the .NET Framework 4.

The StringComparer class and the String.GetHashCode method can also use a different hashing algorithm that computes hash codes on a per application domain basis. As a result, hash codes for equivalent strings will differ across application domains and processes. This is an opt-in feature; to take advantage of it, you must set the enabled attribute of the <UseRandomizedStringHashAlgorithm> element to 1.

The string lookup in a hash table is typically an O(1) operation. However, when a large number of collisions occur, the lookup can become an O(n2) operation. You can use the <UseRandomizedStringHashAlgorithm> configuration element to generate a random hashing algorithm per application domain, which in turn limits the number of deliberate collisions.

The following example defines a DisplayString class that includes a private string constant, s, whose value is "This is a string." It also includes a ShowStringHashCode method that displays the string value and its hash code along with the name of the application domain in which the method is executing.

using System;

public class Example
{
   public static void Main()
   {
      // Show hash code in current domain.
      DisplayString display = new DisplayString();
      display.ShowStringHashCode();

      // Create a new app domain and show string hash code.
      AppDomain domain = AppDomain.CreateDomain("NewDomain");
      var display2 = (DisplayString) domain.CreateInstanceAndUnwrap(typeof(Example).Assembly.FullName, 
                                                          "DisplayString");   
      display2.ShowStringHashCode();
   }
}

public class DisplayString : MarshalByRefObject
{
   private String s = "This is a string.";

   public override bool Equals(Object obj)
   {
      String s2 = obj as String; 
      if (s2 == null)
         return false;
      else 
         return s == s2; 
   }

   public bool Equals(String str)
   {
      return s == str;
   }    

   public override int GetHashCode()
   {
      return s.GetHashCode();
   }

   public override String ToString() 
   {
      return s;
   }

   public void ShowStringHashCode()
   {
      Console.WriteLine("String '{0}' in domain '{1}': {2:X8}",
                        s, AppDomain.CurrentDomain.FriendlyName, 
                        s.GetHashCode());
   }
}

When you run the example without supplying a configuration file, it displays output similar to the following. Note that the hash codes for the string are identical in the two application domains.

String 'This is a string.' in domain 'PerDomain.exe': 941BCEAC
String 'This is a string.' in domain 'NewDomain': 941BCEAC

However, if you add the following configuration file to the example's directory and then run the example, the hash codes for the same string will differ by application domain.

<?xml version ="1.0"?>
<configuration>
   <runtime>
      <UseRandomizedStringHashAlgorithm enabled="1" />
   </runtime>
</configuration>

When the configuration file is present, the example displays the following output:

String 'This is a string.' in domain 'PerDomain.exe': 5435776D
String 'This is a string.' in domain 'NewDomain': 75CC8236

Reference