How exactly do static fields work internally? [duplicate]

by

While the exact details of the type system are implementation dependent, let me go into some more detail than just stating that it depends and you should not care. I’ll describe how it approximately works in Microsoft’s implementation (.NET) according to the book CLR via C# by Jeffrey Richter and the article See How the CLR Creates Runtime Objects by Hanu Kommalapati et al. (original MSDN May 2005 issue).

Say you have a class:

class Foo
{
    // Instance fields
    string myBar = "Foobar";
    int myNum;

    // Static fields
    static string bar = "Foobar";
    static int num;
}

Foo myFoo = new Foo();
Type typeOfFoo = typeof(Foo);

Where do the instance fields live?

Whenever you say new Foo(), space is allocated and initialized for the object instance, and the constructor is called. This instance is shown as instance of Foo in the image below. Such as instance contains only the instance fields of the class (in this case myBar and myNum), and for objects allocated on the heap two extra fields used by the runtime (Sync block index and Type handle). The type handle is a pointer to a Type object that describes the type of the instance, in this case type of Foo.

When you say new Foo() again, new space is allocated which will again contain space for the instance fields of the type. As you can see, instance fields are associated with object instances.

The runtime puts each instance field at a fixed offset from the start of the object’s data. For example, myBar might live at offset +4. The address of the instance field is simply the address of the object plus the offset of the field.

Where do the static fields live?

Static fields in C# and Java are not associated with any object instance, but with a type. Classes, structs and enums are examples of types. Only once (per type) is some space allocated to hold the values of the static fields. It would make sense to allocate space for the static fields in the Type structure that describes the type, since there is also only one Type object per type. This is the approach taken by C# and Java.

The Type object1 is created when the type is loaded by the runtime. This structure contains all sorts of information needed for the runtime to be able to allocate new instances, call methods and perform casting, among other things. It also contains the space for the static fields, in this case bar and num.

The runtime has put each static field at some offset from the start of the type’s data. This is different for each type. For example, bar might live at offset +64. The address of the static field is the address of the Type object plus the offset of the field. The type is statically known.

Displays some object structures, and their relationships.

1) In Microsoft .NET multiple different structures describe a type, such as the MethodTable and the EEClass structures.

More Related Contents:

  1. Class with single method — best approach?
  2. Does reflection breaks the idea of private methods, because private methods can be access outside of the class?
  3. Getters and Setters are bad OO design? [duplicate]
  4. How Function overloading saves memory [closed]
  5. Is the array creation happening on every foreach loop? [closed]
  6. Difference between Equals/equals and == operator?
  7. Pre & post increment operator behavior in C, C++, Java, & C# [duplicate]
  8. Best practices for exception management in Java or C# [closed]
  9. Static vs non-static class members
  10. Can I pass parameters by reference in Java?
  11. Why are private fields private to the type, not the instance?
  12. How to unserialize PHP Serialized array/variable/class and return suitable object in C#
  13. When should I choose inheritance over an interface when designing C# class libraries? [closed]
  14. When to use enums, and when to replace them with a class with static members?
  15. Multiple Aggregates / Repositories in one Transaction
  16. Cross platform (php to C# .NET) encryption/decryption with Rijndael
  17. Why is “null” present in C# and Java?
  18. Cast interface to its concrete implementation object or vice versa?
  19. Reference type variable recycling – is a new reference variable created every loop in a loop if declared therein?
  20. C# Static variables – scope and persistence
  21. Can you explain Liskov Substitution Principle with a good C# example? [closed]
  22. Stroke Width Transform (SWT) implementation (Java, C#…) [closed]
  23. Virtual table/dispatch table
  24. How to convert code from C# to PHP [closed]
  25. Why can’t I retrieve an item from a HashSet without enumeration?
  26. Getters, setters, and properties best practices. Java vs. C#
  27. What is the difference between static methods in a Non static class and static methods in a static class?
  28. Using generics with XmlSerializer
  29. Why do both the abstract class and interface exist in C#?
  30. How does Java’s use-site variance compare to C#’s declaration site variance?

Leave a Comment