A structure (or struct) is a value type that is used to encapsulate small groups of related variables. Structures are similar to classes, but they have some key differences, such as being value types (as opposed to reference types) and not supporting inheritance (though they can implement interfaces). Structures are useful for defining lightweight objects that have value semantics.

Key Features of C# Structures

1. Value Type: Structures are stored on the stack (unless they are part of a reference type), and when you assign a structure to another, a copy of the value is made.

2. No Inheritance: Structures do not support inheritance, meaning you cannot derive one structure from another. However, they can implement interfaces.

3. Default Constructor: Structures do not have a default (parameterless) constructor. The compiler provides a default constructor that initializes all fields to their default values.

4. Memory Efficiency: Structures can be more memory-efficient than classes for small objects, as they avoid the overhead of heap allocation.

5. Initialization: You can initialize a structure using an object initializer.

Defining a Structure

Here's a detailed example of how to define and use a structure in C#:

Example: Defining a Structure

csharp
1using System;
2
3public struct Point
4{
5    public int X;
6    public int Y;
7
8    // Constructor to initialize the structure
9    public Point(int x, int y)
10    {
11        X = x;
12        Y = y;
13    }
14
15    // Method to display the point
16    public void Display()
17    {
18        Console.WriteLine($"Point({X}, {Y})");
19    }
20}
21
22public class Program
23{
24    public static void Main()
25    {
26        // Creating an instance of the structure
27        Point p1 = new Point(10, 20);
28        p1.Display(); // Output: Point(10, 20)
29
30        // Copying the structure
31        Point p2 = p1; // p2 is a copy of p1
32        p2.X = 30; // Changing p2 does not affect p1
33
34        p1.Display(); // Output: Point(10, 20)
35        p2.Display(); // Output: Point(30, 20)
36
37        // Using object initializer
38        Point p3 = new Point { X = 5, Y = 15 };
39        p3.Display(); // Output: Point(5, 15)
40    }
41}

Explanation of the Example

1. Structure Definition:

   • The Point structure has two public fields, X and Y, which represent the coordinates of a point in 2D space.
   • A constructor is defined to initialize the fields when creating a new instance of Point.
   • A method Display is included to print the coordinates of the point.

2. Creating Instances:

   • In the Main method, an instance of Point named p1 is created using the constructor.
   • The Display method is called to show the coordinates.

3. Copying Structures:

   • When p2 is assigned the value of p1, a copy of p1 is made. Modifying p2 does not affect p1, demonstrating the value-type behavior of structures.

4. Object Initializer:

   • An instance of Point named p3 is created using an object initializer, which allows setting the properties directly.

When to Use Structures

• Use structures when you need to represent a simple data structure that has value semantics, such as a point in a 2D space, a color, or a rectangle.
• Structures are ideal for small data types that are frequently created and destroyed, as they provide better performance due to stack allocation.
• Avoid using structures for large data types or when you need inheritance or polymorphism, as classes would be more appropriate in those cases.

Features of  Structures