VB.NET Structure

Array Class Collections File String Console Data Directive Enum Exception If Interface Lambda Loop Nothing Number Process Property Regex Sort StringBuilder Structure Sub Time Windows


A Structure is a value type. Its data is contained directly inside its bytes. Integers, Booleans and DateTimes are built-in Structures. When we pass a Structure to a method, its bytes are copied each time.

Tip:Structures are stored on the evaluation stack (not the managed heap) when used in a method body.

Tip 2:This gives Structures performance advantages—and sometimes hurts performance.



To start, this program has a Structure called Simple.
This Structure has three fields:
an Integer,
a Boolean
and a Double. These fields are stored directly as part of the Simple Structure itself. In Main we create an instance of Simple.


Note:The Simple Structure is created and used without calling its constructor (Sub New). It is used in the same way as an Integer.

Program that uses Structure: VB.NET

Structure Simple
    Public _position As Integer
    Public _exists As Boolean
    Public _lastValue As Double
End Structure

Module Module1
    Sub Main()
	Dim s As Simple
	s._position = 1
	s._exists = False
	s._lastValue = 5.5

    End Sub
End Module




Performance optimization

The performance difference between a Structure and a Class comes from how the types are allocated. A Class reference points to data stored in a separate location—the managed heap. A Structure variable stores data in the variable itself.

Here, a Structure called Box is allocated many times in a loop. The managed heap is not accessed. All the Box instances are stored in local variable memory. Next a Class called Ball is allocated in a similar loop.

For Loops

But:On each iteration the managed heap is accessed.
This triggers garbage collection at intervals.
This reduces performance.

Program that times Structure: VB.NET

Structure Box
    Public _a As Integer
    Public _b As Boolean
    Public _c As DateTime
End Structure

Class Ball
    Public _a As Integer
    Public _b As Boolean
    Public _c As DateTime
End Class

Module Module1
    Sub Main()
	Dim m As Integer = 100000000
	Dim s1 As Stopwatch = Stopwatch.StartNew
	For i As Integer = 0 To m - 1
	    Dim b As Box
	    b._a = 1
	    b._b = False
	    b._c = DateTime.MaxValue

	Dim s2 As Stopwatch = Stopwatch.StartNew
	For i As Integer = 0 To m - 1
	    Dim b As Ball = New Ball
	    b._a = 1
	    b._b = False
	    b._c = DateTime.MaxValue

	Dim u As Integer = 1000000
	Console.WriteLine(((s1.Elapsed.TotalMilliseconds * u) / m).ToString("0.00 ns"))
	Console.WriteLine(((s2.Elapsed.TotalMilliseconds * u) / m).ToString("0.00 ns"))
    End Sub
End Module


2.26 ns
8.20 ns
This section provides information

Each allocation of the Structure took around 2 nanoseconds.
But each allocation of the Class,
which has equivalent fields,
took 8 nanoseconds. Allocating a Structure in this kind of loop has performance advantages.

However, the Structure, when passed as an argument to a Function, will be slower. It is larger.
The Class is only four bytes—
or eight bytes,
depending on the system. When more bytes are copied, Function calls are slower.


Further:This is not true if the JIT-compiler happens to inline the Function call. We have little control over this.


The VB.NET programming language

We explored Structures in the VB.NET programming language. Structures are unique in their allocation behavior. They are not references to the managed heap. Instead they are stored directly inside their bytes.

Usually:Structures will decrease program performance. It is often better to use Classes for custom types.