Scope of Variables: Instantiation Inside or Outside Loop

Question

Through a question I posted yesterday, it became clear that declaring a variable outside of a loop and instantiating it inside, has no performance benefits over simply moving the declaration to inside the loop, so declaring and instantiating is done at the same time. But what about instantiation? Consider the two options below.

//OPTION 1:
while (_doWork)
{
    Person p = new Person(name = "John", age = 35);
    //work that involves reading (not writing to) p
}

//OPTION 2:
Person p = new Person(name = "John", age = 35);
while (_doWork)
{
    //work that involves reading (not writing to) p
}

For the purposes of this question, the key assumptions are:

1. p is not needed outside of the loop
2. p does not get written too (so outcome wise, the two are the same)
3. There is no outcome reason for why we should keep re-instantiating p (p looks the same in both options)

Question: Which is better performance wise, and which option is better practice?

The answer to this post (despite being about declaration, not instantiation) seems to indicate the latter: Declaring variables inside or outside of a loop

My Thoughts:

• It just seems like a major waste to me to keep reinstantiating it. Might be okay for primitive types, but for complex classes?
• int a = 0 is the same as int a = new int(), so I guess the answer to the above also applies to primitive types?

Answer 1

Which is better performance wise, and which option is better practice?

As per your question, If only a single Person instance is needed, there is no logical reason to instansiate it over and over inside the loop. Allocate it once outside of your loop and use it inside.

About primitive types, you should distinguish between value types (int, long, double) and reference type (string). Value types get allocated on the stack, while reference types get allocated on the heap. Thus, as for your Person class, we will have to allocate the right amount of bytes inside the heap, while allocating an int on the stack is a faster allocation.

Other than best practices, if you want to know which of the two has better performance, benchmark your code. This is the output running in Debug Mode with .NET Framework 4.5, VS2013, on my Intel Core i5 M430:

public class Person
{
    public Person(string name, int age)
    {
        Age = age;
        Name = name;
    }

    public int Age { get; set; }
    public string Name { get; set; }
}

private static void Main(string[] args)
{
   Stopwatch sw = new Stopwatch();
   sw.Start();
   for (int i = 0; i < 1000000; i++)
   {
      Person p = new Person("John", 35);
      var age = p.Age;
      var name = p.Name;
   }

   Console.WriteLine("Loop with inner allocation took {0}", m sw.Elapsed);

   sw.Restart();
   Person px = new Person("John", 35);

   for (int i = 0; i < 1000000; i++)
   {
      var age = px.Age;
      var name = px.Name;
   }

   Console.WriteLine("Loop with outter allocation took {0}", sw.Elapsed)
}

And the results:

Loop with inner allocation took 00:00:00.0708861
Loop with outter allocation took 00:00:00.0155522

Answer 2

If you do something 10 times it's less performant than if you do it only once, therefore a single instantiation is more efficient. It's also pointless to intialize an object mutliple times if you only need one instance. That could also have side effects which could make things even worse.

So always declare and initialize it outside of the loop if it doesn't change in the loop. That will also increase readability since everybody can see immediately that this object will most likely not change in the following loop.

Person p = new Person("John", 35);
while (_doWork)
{
    //work that involves reading (not writing to) p
}

If you have to create the object in the loop you should declare it in the loop. But not because it's more performant but more readable.

Read: https://softwareengineering.stackexchange.com/questions/56585/where-do-you-declare-variables-the-top-of-a-method-or-when-you-need-them