Structures

In this part of the C# tutorial, we will cover structures.

A structure is a value type. The type is defined with the struct keyword. Structures are very similar to the classes; they differ in some aspects. Structures are meant to represent lightweight objects like Point, Rectangle, Color and similar. In many cases, structures may be more efficient than classes. Structures are value types and are created on the stack. Note that primitive data types like int, bool, float are technically struct types.

Structures can have constructors. They can contain data members and methods. They also can implement interfaces.

All struct types inherit from System.ValueType. And further from object. Structures are never abstract and they are always implicitly sealed. So struct types do not support inheritance. And therefore, the struct data member cannot be declared protected. The abstract and sealed modifiers are not permitted for a struct definition. A struct is not permitted to declare a parameterless constructor.

using System;


public struct Point
{
    private int x;
    private int y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public override string ToString()
    {
        return String.Format("Point, x:{0}, y:{1}", x, y);
    }
}


public class CSharpApp
{
    static void Main()
    {
        Point p = new Point(2, 5);
        Console.WriteLine(p);        
    }
}

We have a simple example demonstrating the struct type. We create a Point struct. The point could be represented by a class too, but with struct we are more efficient. Especially if we dealt with lots of points.

public struct Point
{
    ...
}

The structure is declared with the struct keyword.

public override string ToString()
{
    return String.Format("Point, x:{0}, y:{1}", x, y);
}

The inheritance is not supported for struct types. But we can use the override keyword for methods, from which the struct type implicitly inherits. The ToString() method is such a case.

Point p = new Point(2, 5);
Console.WriteLine(p);

We create the Point structure and call the ToString() method upon it.

$ ./simple.exe 
Point, x:2, y:5

Output.

It is possible to create an instance of the struct type without the new keyword.

using System;


public struct Person 
{
    public string name; 
    public int age;
}

public class CSharpApp
{
    static void Main()
    {
        Person p;
        p.name = "Jane";
        p.age = 17;

        Console.WriteLine("{0} is {1} years old", 
            p.name, p.age);        
    }
}

We have a Person structure with two public members.

Person p;

First we declare a Person struct.

p.name = "Jane";
p.age = 17;

Later we initialize the structure with some data.

$ ./properties.exe 
Jane is 17 years old

Output.

Structures are value types The structure types are value types. They are created on the stack. When a value type is created only a single space in memory is allocated to store the value. An assignment of a value type copies the value.

using System;


public struct Person 
{
    public Person(string name, int age)
    {
        this.Name = name;
        this.Age = age;
    }

    public string Name { get; set; }

    public int Age { get; set; }

    public override string ToString()
    {
        return String.Format("{0} is {1} years old", Name, Age);
    }
}


public class CSharpApp
{
    static void Main()
    {
        Person p1 = new Person("Beky", 18);
        Person p2 = p1;

        Console.WriteLine(p2); 
        p2.Name = "Jane";
        p2.Age = 17;

        Console.WriteLine(p2); 
        Console.WriteLine(p1);           
    }
}

We have a Person structure with two data members. We have a two parameter constructor and we also use automatic properties.

public string Name { get; set; }
public int Age { get; set; }

Automatic properties can be used in struct types.

Person p1 = new Person("Beky", 18);
Person p2 = p1;

Here we create a struct. And then the created struct is assigned to another struct. We create a copy of the structure.

p2.Name = "Jane";
p2.Age = 17;

We change the data of the second structure. The first one is not affected, since we work on the copy of the original struct type.

$ ./valuetype.exe 
Beky is 18 years old
Jane is 17 years old
Beky is 18 years old

Output.

Primitive types are structures The primitive data types like int, float or bool are structures under the hood. This differs from languages like C++ or Java. We will have an example demonstrating this.

using System;


public class CSharpApp
{
    static void Main()
    {
        float x = 12.3f;
        int y = 34;
        bool z = false;

        Console.WriteLine(x.GetType());
        Console.WriteLine(y.GetType());
        Console.WriteLine(z.GetType());
    }
}

We have three variables. A float an int and a bool. We call the GetType() method on each of them.

Console.WriteLine(x.GetType());

We call the GetType() method on the float value. Each structure implicitly inherits from the System.ValueType class, which contains the GetType() method.

$ ./primitivetypes.exe 
System.Single
System.Int32
System.Boolean

Output.

In this part of the C# tutorial, we mentioned structures.

Home ‡ Contents ‡ Top of Page