Reference type variable recycling – is a new reference variable created every loop in a loop if declared therein?

by

No, “variables” exist almost entirely for the sake of the programmer. You’re not creating any additional work at run-time by declaring the variable inside the method.

In theory, the compiler will set aside space on the stack when a method is called for each variable declared in that method. So the presence of that variable in the method would be more important than its scope. No space is allocated on the heap unless the new keyword is used.

In practice, the compiler can identify variables that have such a short scope that they can be stored in a register on the CPU instead of needing space on the stack. For example:

var a = b[c];
a.ToString();
// never access "a" again.

… would be the same as:

b[c].ToString();

… because the compiler recognizes that it only needs to store the result of b[c] long enough to call a method on it, so it can just use a CPU register instead of using memory.

For this reason, declaring your variable inside the loop could actually cause the method to allocate less stack space for the variable, depending on the possible logic flow afterward. However, that gets into huge micro-optimization that doesn’t make any sense for most people to care about.

Update

Since some people still seem to think that declaring a variable in a loop has some effect, I guess I need to provide proof. Type the following programs into LINQPad.

int j;
for(int i = 0; i < 5; i++)
{
    j = i;
}

… and…

for(int i = 0; i < 5; i++)
{
    int j = i;
}

Execute the code, then go to the IL tab to see the generated IL code. It’s the same for both of these programs:

IL_0000:  ldc.i4.0    
IL_0001:  stloc.0     
IL_0002:  br.s        IL_0008
IL_0004:  ldloc.0     
IL_0005:  ldc.i4.1    
IL_0006:  add         
IL_0007:  stloc.0     
IL_0008:  ldloc.0     
IL_0009:  ldc.i4.5    
IL_000A:  blt.s       IL_0004

So there’s incontrovertible proof that this will make no difference at compile time. You’ll get exactly the same compiled IL from both programs.

More Related Contents:

  1. c# – Objects not saving their own information
  2. How to override a function without redefine in c#?
  3. Why Doesn’t C# Allow Static Methods to Implement an Interface?
  4. Auto-implemented getters and setters vs. public fields
  5. How exactly do static fields work internally? [duplicate]
  6. Is there an alternative to bastard injection? (AKA poor man’s injection via default constructor)
  7. Large Switch statements: Bad OOP?
  8. Class with single method — best approach?
  9. How do I target attributes for a record class?
  10. Why can’t I declare C# methods virtual and static?
  11. What is abstraction in C#? [duplicate]
  12. What is the difference between the override and new keywords in C#?
  13. Static and Instance methods with the same name?
  14. How to solve circular reference?
  15. Covariance and Contravariance with C# Arrays [duplicate]
  16. Blocking access to private member variables? Force use of public properties?
  17. Difference between virtual and abstract methods [duplicate]
  18. C# code for association, aggregation, composition
  19. Is there a much better way to create deep and shallow clones in C#?
  20. Parameter Action in which T3 can be optional
  21. C# : Converting Base Class to Child Class
  22. downcast and upcast
  23. Is it possible to override a constructor in C#?
  24. Is there a way to reach a `protected` member of another object from a derived type?
  25. Getters and Setters are bad OO design? [duplicate]
  26. Using Reflection to create a DataTable from a Class?
  27. What is the difference between static methods in a Non static class and static methods in a static class?
  28. Are global static classes and methods bad?
  29. Using generics with XmlSerializer
  30. Why do both the abstract class and interface exist in C#?

Leave a Comment