Fields are ordinary member variables or member instances of a class. Properties
are an abstraction to get and set their values. Properties are also called
accessors because they offer a way to change and retrieve a field if you expose
a field in the class as private. Generally, you should declare your member
variables private, then declare or define properties for them.
There are three obvious reasons for the necessity of properties in VB.NET
You can delay the creation of actual reference fields until you use them, which
saves resources. You can differentiate the representation and actual storage.
Representation is implemented via properties and storage is implemented via
fields. You can check constraints when setting and getting properties. If the
value is not suitable, you do not store the data in the field and a type-safety
error is returned. This really provides 100% type-safe accessors on demand.
Properties afford you the advantage of more elegant syntax along with the
robustness and better encapsulation of accessor methods. The syntax for
implementing a property in VB.NET, along with a constructor and a destructor and
using the property is shown in the Age property in below example.
Example of Constructor Destructor:
// example property, ctor, dtor, exception
Module module1
Public Class Individual
Private m_age As Int32
//
note that this is private
// we could do this instead, more explicit
// private Int32 age;
// the default specifiers are all
private!!!
Public Sub New(ByVal
age As Int32)// constructor, ctor
Me.m_age
= age// this object, just for more clarity
End Sub
Protected Overrides Sub
Finalize()// destructor
Try
m_age = 0
Finally
MyBase.Finalize()
End Try
End Sub
Public Property
Age() As Int32// public property
Get
Return m_age
End Get
Set(ByVal
value As Int32)
// validating value
If value > 0 AndAlso
value < 200 Then
m_age = value
Else
// throw exception if invalid
value
Throw New ArgumentException("not
between 1 and 150 ?")
End If
End Set
End Property
End Class
Sub Main()
Try
Dim
Jabbar As New Individual(27)
Console.WriteLine("This
year, Jabbar was {0} years old", Jabbar.Age)
Jabbar.Age +=
1// uses both get and set to
do increment
Console.WriteLine("Next
year, Jabbar will be {0} years old",
Jabbar.Age)
Catch e As ArgumentException // catches this specific type and derived
types
// uses Exception.ToString()
Console.WriteLine("{0}
Caught exception #1.", e)
End Try
Console.ReadLine()
End Sub
End Module
Output
The pseudocode in example below presents a read-only property example that defers
resource allocation with the help of properties.
Example
// example property pseudocode, delayed resource allocation
// you allocate resources only when you really need them
// class 1
Module Module1
Class MyReader
// prop1 - property
End Class
// class 2
Class MyWriter
// prop2 - property
// prop3 - property
End Class
Public Class
ExamplePropertyImplementation
Private Shared
reader As MyReader
Private Shared
writer As MyWriter
Private Shared
[error] As MyWriter
// public property
Public Shared ReadOnly Property
prop1() As MyReader
Get
If reader Is Nothing Then
reader = New
Reader()
End If
Return reader
End Get
End Property
// public property
Public Shared ReadOnly Property
prop2() As MyWriter
Get
If writer Is Nothing Then
writer = New MyWriter()
End If
Return writer
End Get
End Property
// public property
Public Shared ReadOnly Property
prop3() As MyWriter
Get
If [error] Is Nothing Then
[error] = New
Writer()
End If
Return [error]
End Get
End Property
End Class
End Module
By exposing these members as properties, the class can delay their
initialization until they are actually used. Thus, if the application makes no
reference to the prop2 and prop3 properties, no objects are created for those
objects.
Conclusion
Hope this article would have helped you in understanding Fields and Properties
in VB.NET