If I inline a HashSet collection initialization, does the compiler know to do it only once?

Question

I often do this...

private void Check()
 {
 string s = "blah";

 if ( new HashSet<string>{"Joe","Eddie","Buckethead"}.Contains(s) )
   Debug.Log("Guitarist.");
 }

In the pipeline, is the HashSet in fact created only the once (at startup time? compile time?) and then used every time?

By the way, I assume that if you do this:

private HashSet<string> g = new HashSet<string>()
                         {"Joe","Eddie","Buckethead"};
private void Check()
 {
 string s = "blah";

 if ( g.Contains(s) )
  Debug.Log("Guitarist.");
 }

then indeed, of course it is only done once when the Class is instantiated. (Or, perhaps at compile time / launch time? But in any event, only the once.)

Answer 1

Here's the IL for your first method:

Check:
IL_0000:  ldstr       "blah"
IL_0005:  stloc.0     // s
IL_0006:  newobj      System.Collections.Generic.HashSet..ctor
IL_000B:  dup         
IL_000C:  ldstr       "Joe"
IL_0011:  callvirt    System.Collections.Generic.HashSet.Add
IL_0016:  pop         
IL_0017:  dup         
IL_0018:  ldstr       "Eddie"
IL_001D:  callvirt    System.Collections.Generic.HashSet.Add
IL_0022:  pop         
IL_0023:  dup         
IL_0024:  ldstr       "Buckethead"
IL_0029:  callvirt    System.Collections.Generic.HashSet.Add
IL_002E:  pop         
IL_002F:  ldloc.0     // s
IL_0030:  callvirt    System.Collections.Generic.HashSet.Contains
IL_0035:  brfalse.s   IL_0041
IL_0037:  ldstr       "Guitarist."
IL_003C:  call        System.Console.WriteLine
IL_0041:  ret         

Here's the code for the second method:

Check:
IL_0000:  ldstr       "blah"
IL_0005:  stloc.0     // s
IL_0006:  ldarg.0     
IL_0007:  ldfld       g
IL_000C:  ldloc.0     // s
IL_000D:  callvirt    System.Collections.Generic.HashSet.Contains
IL_0012:  brfalse.s   IL_001E
IL_0014:  ldstr       "Guitarist."
IL_0019:  call        System.Console.WriteLine
IL_001E:  ret         

And that's the optimized compile for the code.

So, yep, the first creates a new HashSet every time.

Oh, I changed Debug.Log to Console.WriteLine, but that's a trivial change.

Answer 2

new will create the new object at runtime exactly at the point in time when the thread reaches that line.

So in the case of the first snippet, each invocation of the Check method will cause a new HashSet object to be created.

In the second case, a new HashSet object is created everytime you construct a new instance of the containing class.

Answer 3

This code

{
    string s = "blah";

    if ( new HashSet<string>{"Joe","Eddie","Buckethead"}.Contains(s) )
       Debug.Log("Guitarist.");
}

always instantiates a new HashSet<string>.

By the way, that new object is available as soon as it is no longer referenced, in this case after your closing }.

You are correct that placing it as a class instance field will initialize it once, when the class is initialized. You can use the readonly keyword in that case to prevent your class from changing the initial value after the object is initialized. If you have an expensive initialization that never changes and potentially many instances of your class, you can mark the field as static so that a single instance of the HashSet<string> is shared among all object instances.

hmm .. ok but compilers know to only make once other literals, right? (eg, "strings" etc)

Constants don't incur any initialization overhead. The compiler can use the literal value where appropriate.

By default string literals are interned (see also), meaning that memory for a given string will only be allocated once.