Using Structures in VB.NET






2.47/5 (16 votes)
Oct 20, 2004
3 min read

238493
Through this article, I wanted to introduce you to the structures in VB.NET. Also, I compared and contrasted Structures to Classes.
Introduction
Structure
s are complex data types that encapsulate small pieces of tightly related data items. As with Class
es, Structure
s can contain data members as well as member methods to work with data inside a structure. Since the in-memory representation of Structure
is 'value type', memory management is handled efficiently.
Structures Vs Classes
Structures | Classes |
---|---|
Value type | Reference type |
Supports data members, code members (methods) and events | Supports data members, code members (methods) and events |
Can not inherit | Supports inheritance |
Preferable when you perform large number of operations on each instance | Preferable when you need to initialize one or more members upon creation |
Can not control initialization using structure variable | Can have parameterized constructors |
Less flexible, limited event handling support | More flexible, unlimited event handling support |
Declaration
Structure
s are declared using Structure
... End Structure
statements. Between these two statements, there must be at least one member declared. This member can be of any data type, non-shared and non-event. The following example shows how to encapsulate product info into a structure called Product
.
Private Structure Product
'Declare data members
Public ProductID as Integer
Public ProductName as String
Private UnitPrice as Single
'Declare code members
Public Function GetPrice() as Single
GetPrice = UnitPrice
End Function
End Structure
In the above example, the Product
structure is declared as Private
. That means you can not access it from the object of the class where you defined it. As you can see, the data member UnitPrice
is declared as Private
, yes, you are right, you can't access it outside the structure.
Note that there is a function GetPrice
defined within the Structure
. Using this code member, one can get UnitPrice
of a product. You can also define Sub
procedures, properties and events. You can define a property as a default property, but it must accept at least one argument. You can declare events using Shared Sub
procedure. To cause an event to actually happen, you have to use RaiseEvent
statement.
The default accessibility for a structure is Public
. You can use Private
, Protected
and Friend
keywords also. You must specify accessibility for every member you declare inside a Structure
. If you declare them with Dim
statement, they are considered as Public
. Remember that you can not initialize a Structure
's data members at the time of instantiation. You have to access and initialize them individually after creation of a Structure
variable or through a Structure
code member. If you assign one Structure
variable to another, a new copy is created in the other variable. Hence the changes to the values of first variable does not happen to the second. On the other hand, if you assign a Class
object to another, changes to the data of one object reflects in the other. This is obvious in the case of Class
es because the two objects in the above situation share the same instance.
Conclusion
- Use
Structure
s only if you want to use tiny pieces of related data as a single composite data type that resembles a built-in data type. - Use
Class
es if you can't decide which one to use amongClass
es andStructure
s. Because,Class
es are more flexible. Though there are storage and performance advantages withStructure
s, often they are negligible.