C# Struct: Everything you need to know [2023]

Definition

To define a struct in C#, we use the struct keyword:

public struct Color
{
	 public string Name;
}

We can break the above code to:

• public - access modifier
• struct - keyword to define it's a structure
• Color - the struct name
• public string Name - structure member

Initialization

To initialize a struct, we use the new operator:

var blue = new Color() { Name = "Blue" };

We can also define structs without the new keyword, like this:

Color c;
c.Name = "Blue";

If you use this method to initialize a struct, the fields will remain unassigned.

Access

To access struct members, we use the dot . syntax:

Console.WriteLine(blue.Name);

Default values

If we don't change the values, the default value for struct members is the same as the default value for each field inside the struct.

If we have a struct defined as:

public struct Color
{
	 public string Name;
}
var blue = new Color();

The default value of the field Name will be default(string) which is null.

Structs store data. Classes define behavior.

Structs are ideal for simple structures or data carriers.

These questions will help you decide whether to use a struct:

1. What is the primary responsibility of this type? Is it data storage?
2. Is its public interface defined entirely by properties that access or modify its data members?
3. Will this type ever have subclasses?
4. Will this type need polymorphism?

The main disadvantages of structs are:

• Structs do not support inheritance: Inheritance is a common object-oriented technique that allows for extending functionality.
• Expensive to copy, which impacts performance: If we pass the struct between methods, data gets copied. It might not seem much, but we can easily get in trouble if we have a large list of structs.

The main difference between struct and class in C# is that structs are value types, while classes are reference types. Classes support inheritance, but structs don't. Classes can have a null reference, while structs can't.

This table summarizes the differences between structs and classes:

The main difference between struct and record is that struct is a value type, while a record is an immutable object.

Structs are better for structures that are similar to primitive data types such as int, bool, and double. On the other hand, records are better for encapsulating complex data.

The main difference between reference types and value types is that value types are meant to be small and lightweight, while reference types form more complex class hierarchies.

When we pass a value type to a method, the instance of that value type is copied. On the other hand, reference types pass a memory reference, so they are not copied.

Example: Reference Type vs Value Type

In C#, an integer (int) is an example of a value type, while a string is a reference type.

When we pass an integer to a method, a copy of that integer value is passed. And any changes made to that integer within the method do not affect the original integer outside the method.

int x = 10;
ChangeInteger(x);
Console.WriteLine(x); // Output: 10. The original variable is not changed!

void ChangeInteger(int y)
{
  y = 20;
}

On the other hand, when we pass a string as a parameter to a method, a reference to the memory location of that string is passed to the method. Any changes made to that string within the method affect the original string.

string s = "hello";
ChangeString(s);
Console.WriteLine(s); // Output: world. The original variable is changed!

void ChangeString(string t)
{
t = "world";
}

Structs can implement interfaces. The C# community rarely recommends it because it makes boxing more likely.

From my experience, I think of structs as a very specific group of data. So having different implementations isn't very useful.