Structs

Beginner Topic: Categories of Types

All types fall into two categories: reference types and value types. The differences between the types in each category stem from the fact that each category uses a different location in memory. To review, this Beginner Topic reintroduces the value type/reference type discussion to refamiliarize those who are unfamiliar with it.

Value Types

Value types directly contain their values, as shown in Figure. In other words, the variable refers to the same location in memory that the value is stored. Because of this, when a different variable is assigned the same value, a memory copy of the original variable's value is made to the location of the new variable. A second variable of the same value type cannot refer to the same location in memory as the first variable. So changing the value of the first variable will not affect the value in the second.

1. Value Types Contain the Data Directly

[View full size image]

Similarly, passing a value type to a method such as Console.WriteLine() will also result in a memory copy, and any changes to the parameter value inside the method will not affect the original value within the calling function. Since value types require a memory copy, they generally should be defined to consume a small amount of memory (less than 16 bytes approximately).

The amount of memory that is required for the value type is fixed at compile time and will not change at runtime. This fixed size allows value types to be stored in the area of memory known as the stack.

Reference Types

In contrast, reference types and the variables that refer to them point to the data storage location (see Figure). Reference types store the reference (memory address) where the data is located, instead of the data directly. Therefore, to access the data, the runtime will read the memory location out of the variable and then jump to the location in memory that contains the data. The memory area of the data a reference type points to is the heap.

2. Reference Types Point to the Heap

[View full size image]

Dereferencing a reference type to access its value involves an extra hop. However, a reference type does not require the same memory copy of the data that a value type does, resulting in circumstances when reference types are more efficient. When assigning one reference type variable to another reference type variable, only a memory copy of the address occurs, and as such, the memory copy required by a reference type is always the size of the address itself. (A 32-bit processor will copy 32 bits and a 64-bit processor will copy 64 bits, and so on.) Obviously, not copying the data would be faster than a value type's behavior if the data size is large.

Since reference types copy only the address of the data, two different variables can point to the same data, and changing the data through one variable will change the data for the other variable as well. This happens both for assignment and for method calls. Therefore, a method can affect the data of a reference type back at the caller.

     // Use keyword struct to declare a value type.
    struct Angle                                                   
     {
     public Angle(int hours, int minutes, int seconds)
     {
         _Hours = hours;
         _Minutes = minutes;
         _Seconds = seconds;
     }

     public int Hours
     {
         get { return _Hours; }
     }
     private int _Hours;

     public int Minutes
     {
         get { return _Minutes; }
     }
     private int _Minutes;

     public int Seconds
     {
         get { return _Seconds; }
     }
     private int _Seconds;

     public Angle Move(int hours, int minutes, int seconds)
     {
         return new Angle(
             Hours + hours,
             Minutes + minutes.
             Seconds + seconds)
     }
}

// Declaring a class - a reference type
// (declaring it as a struct would create a value type
// larger than 16 bytes.)
class Coordinate
{
   public Angle Longitude
   {
       get { return _Longitude; }
       set { _Longitude = value; }
   }
   private Angle _Longitude;

   public Angle Latitude
   {
       get { return _Latitude; }
       set { _Latitude = value; }
   }
   private Angle _Latitude;
}

struct Angle
{
   // ...
   // ERROR:    Fields cannot be initialized at declaration time
   // int _Hours = 42;
   // ...
}

// ERROR:  The 'this' object cannot be used before
//         all of its fields are assigned to
// public Angle(int hours, int minutes, int seconds)
// {
//     Hours = hours;    // Shorthand for this.Hours = hours;
//     Minutes = minutes // Shorthand for this.Minutes = ...;
//     Seconds = seconds // Shorthand for this.Seconds = ...;
// }

Advanced Topic: Using new with Value Types

Invoking the new operator on a reference type compiles to the CIL instruction newobj. new is available to value types as well, but in contrast, the underlying CIL instruction is initobj. This instruction initializes the memory with default values (the equivalent of assigning default(<type>) in C# 2.0).

Language Contrast: C++struct Defines Type with Public Members

In C++, the difference between structs and classes is simply that by default, a struct's members are public. C# doesn't include this subtle distinction. The contrast is far greater in C#, where struct significantly changes the memory behavior from that of a class.

// Use keyword struct to declare a value type.
struct Angle                                                     
{
  public Angle(int hours, int minutes)
      : this( hours, minutes, default(int))
  {
  }

  // ...
}