What is a “rooted reference”?

by

It means a GC root.

Have a read through this article, maybe it will help with your understanding:

GC roots are not objects in themselves but are instead references to objects. Any object referenced by a GC root will automatically survive the next garbage collection. There are four main kinds of root in .NET:

A local variable in a method that is currently running is considered to be a GC root. The objects referenced by these variables can always be accessed immediately by the method they are declared in, and so they must be kept around. The lifetime of these roots can depend on the way the program was built. In debug builds, a local variable lasts for as long as the method is on the stack. In release builds, the JIT is able to look at the program structure to work out the last point within the execution that a variable can be used by the method and will discard it when it is no longer required. This strategy isn’t always used and can be turned off, for example, by running the program in a debugger.

Static variables are also always considered GC roots. The objects they reference can be accessed at any time by the class that declared them (or the rest of the program if they are public), so .NET will always keep them around. Variables declared as ‘thread static’ will only last for as long as that thread is running.

If a managed object is passed to an unmanaged COM+ library through interop, then it will also become a GC root with a reference count. This is because COM+ doesn’t do garbage collection: It uses, instead, a reference counting system; once the COM+ library finishes with the object by setting the reference count to 0 it ceases to be a GC root and can be collected again.

If an object has a finalizer, it is not immediately removed when the garbage collector decides it is no longer ‘live’. Instead, it becomes a special kind of root until .NET has called the finalizer method. This means that these objects usually require more than one garbage collection to be removed from memory, as they will survive the first time they are found to be unused.

(emphasis mine)

More Related Contents:

  1. The type or namespace name could not be found [duplicate]
  2. What’s the difference between the ‘ref’ and ‘out’ keywords?
  3. How do ValueTypes derive from Object (ReferenceType) and still be ValueTypes?
  4. Creating a copy of an object in C# [duplicate]
  5. C# ‘is’ operator performance
  6. Dependent DLL is not getting copied to the build output folder in Visual Studio
  7. Static Generic Class as Dictionary
  8. Why C# is not allowing non-member functions like C++
  9. Why check this != null?
  10. What are major differences between C# and Java?
  11. What is the difference between a C# Reference and a Pointer?
  12. When is a C# value/object copied and when is its reference copied?
  13. sizeof(int) on x64?
  14. Float vs Double Performance
  15. What’s the method representation in memory?
  16. How is GetHashCode() implemented for Int32?
  17. How are DLLs loaded by the CLR?
  18. What are the differences between value types and reference types in C#? [duplicate]
  19. Declaring a new instance of a class in C#
  20. Func delegate with ref variable
  21. Is it Possible to Return a Reference to a Variable in C#? [duplicate]
  22. Asynchronous iterator Task
  23. Why does struct alignment depend on whether a field type is primitive or user-defined?
  24. Assembly binding redirect does not work
  25. Why only literal strings saved in the intern pool by default?
  26. Boxing / Unboxing Nullable Types – Why this implementation?
  27. variable scope in statement blocks
  28. Passing a class as a ref parameter in C# does not always work as expected. Can anyone explain?
  29. Where is the .NET JIT-compiled code cached?
  30. Why value-types are stored onto Stacks?

Leave a Comment