What is a Structure in C#? Explained with Examples

Short Answer

In C#, a structure is a value type that can contain fields, properties, methods, and events. Unlike classes, which are reference types, structures are lightweight, stored on the stack, and copied by value. Structures are ideal for small, immutable data objects where performance and memory efficiency are important. Common use cases include representing mathematical concepts, coordinates, or simple data containers like DateTime and Point.

Detailed Explanation with Examples

What is a Structure in C#?

A structure in C# is a user-defined value type that can hold related data and behavior. It is defined using the struct keyword. Structures are similar to classes but have key differences in terms of memory allocation, performance, and usage.

Why Use Structures When We Have Classes?

While classes are more flexible and suitable for complex objects, structures are better suited for small, lightweight data objects. Here’s why structures are useful:

• Value Type Semantics:
  • Structures are value types, meaning they are stored directly in memory (usually on the stack) and copied by value when assigned or passed as arguments.
  • This ensures that each instance of a structure is independent, and changes to one instance do not affect others.
• Performance and Memory Efficiency:
  • Structures are more memory-efficient than classes because they avoid the overhead of heap allocation and garbage collection.
  • They are ideal for small objects where performance is critical.
• Immutable by Default:
  • Structures are immutable by default, meaning their state cannot be changed after creation. This ensures thread safety and prevents unintended modifications.
• Stack Allocation:
  • Structures are often allocated on the stack, making their creation and destruction faster than heap-allocated objects (like classes).
• Semantic Differences:
  • When you assign a structure to another variable, a copy of the structure’s value is created. This is different from classes, where assignment creates a reference to the same object.
• Common Use Cases:
  • Structures are used for simple data containers, such as mathematical concepts (e.g., vectors, points), coordinates, or small entities like DateTime and Color.

Example: Creating and Using a Structure

Let’s look at an example to understand how structures work in C#.

Step 1: Define a Structure

Here’s a StudentRecord structure with fields for Id, FirstName, LastName, ClassGrade, and an embedded Address structure.

struct Address
{
    public string Street;
    public string City;
    public string State;
    public string ZipCode;
}

struct StudentRecord
{
    public string Id;
    public string FirstName;
    public string LastName;
    public int ClassGrade;
    public Address Adrs;
}

Step 2: Initialize and Use the Structure

In the addStudent method, we create an instance of the StudentRecord structure and initialize its fields.

void addStudent()
{
    StudentRecord std1;
    std1.Id = "1";
    std1.FirstName = "John";
    std1.LastName = "Smith";
    std1.ClassGrade = 10;

    // Initialize the embedded Address structure
    std1.Adrs.Street = "123 Main St";
    std1.Adrs.City = "New York";
    std1.Adrs.State = "NY";
    std1.Adrs.ZipCode = "10001";

    // Display student details
    Console.WriteLine($"Id: {std1.Id}");
    Console.WriteLine($"First Name: {std1.FirstName}");
    Console.WriteLine($"Last Name: {std1.LastName}");
    Console.WriteLine($"Class Grade: {std1.ClassGrade}");
    Console.WriteLine($"Address: {std1.Adrs.Street}, {std1.Adrs.City}, {std1.Adrs.State} {std1.Adrs.ZipCode}");
}

Step 3: Observe the Output

When you run the program, you’ll see the following output:

Id: 1
First Name: John
Last Name: Smith
Class Grade: 10
Address: 123 Main St, New York, NY 10001

In this example:

• The StudentRecord structure is used to store student details.
• The Address structure is embedded within StudentRecord to store address information.
• Each field is accessed using the dot (.) operator.

Key Differences Between Structures and Classes

Here’s a comparison of structures and classes in C#:

Real-World Use Cases for Structures

Structures are commonly used in the following scenarios:

• Mathematical Concepts:
  • Structures are ideal for representing mathematical objects like points, vectors, or complex numbers.
  • Example:

    
    struct Point
    {
        public int X;
        public int Y;
    }
    			

• Date and Time:
  • The DateTime type in .NET is a structure, making it lightweight and efficient for handling date and time values.
• Coordinates:
  • Structures are commonly used for representing coordinates in graphics or game development.
  • Example:

    
    struct Coordinate
    {
        public double Latitude;
        public double Longitude;
    }
    			

• Configuration Settings:
  • Structures can be used to store small, immutable configuration settings.
  • Example:

    
    struct AppSettings
    {
        public int MaxRetries;
        public string LogLevel;
    }
    				

When to Use Structures vs Classes

Here’s a quick guide to help you decide when to use structures and when to use classes:

• Use Structures:
  • For small, immutable data objects.
  • When performance and memory efficiency are critical.
  • For objects that don’t require inheritance or complex behavior.
• Use Classes:
  • For complex objects with behavior and relationships.
  • When you need inheritance or polymorphism.
  • For objects that require heap allocation and garbage collection.

Final Thoughts

Structures in C# are a powerful tool for creating lightweight, efficient data objects. While classes are more flexible and suitable for complex scenarios, structures excel in performance-critical applications and for small, immutable data containers. By understanding the differences between structures and classes, you can choose the right tool for your specific programming needs.