Some things about structs vs classes I haven't seen mentioned prior to me
"starting" this post:
Pulled from
"ms-help://MS.VSCC/MS.MSDNQTR.2003FEB.1033/vbcn7/html/vaconstructuresandclasses.h
tm"
Similarities
Structures and classes are similar in the following respects:
*Both are container types, meaning that they contain other types as members.
*Both have members, which can include constructors, methods, properties,
fields, constants, enumerations, events, and event handlers.
*Members of both can have individualized accessibilities. For example, one
member can be declared Public and another Private.
*Both can implement interfaces.
*Both can have shared constructors, with or without parameters.
*Both can expose a default property, provided that property takes at least
one argument.
*Both can declare and raise events, and both can declare delegates.
Differences
Structures and classes differ in the following particulars:
*Structures are value types; classes are reference types.
*Structures use stack allocation; classes use heap allocation.
*All structure members are Public by default; class variables and constants
are Private by default, while other class members are Public by default. This
behavior for class members provides compatibility with the Visual Basic 6.0
system of defaults.
*A structure must have at least one nonshared variable or event member; a
class can be completely empty.
*Structure members cannot be declared as Protected; class members can.
*A structure procedure can handle events only if it is a Shared Sub
procedure, and only by means of the AddHandler statement; any class procedure can
handle events, using either the Handles keyword or the AddHandler statement.
*Structure variable declarations cannot specify initializers, the New
keyword, or initial sizes for arrays; class variable declarations can.
*Structures implicitly inherit from the ValueType class and cannot inherit
from any other type; classes can inherit from any class or classes other than
ValueType.
*Structures are not inheritable; classes are.
*Structures are never terminated, so the common language runtime (CLR) never
calls the Finalize method on any structure; classes are terminated by the garbage
collector, which calls Finalize on a class when it detects there are no active
references remaining.
*A structure does not require a constructor; a class does.
*Structures can have nonshared constructors only if they take parameters;
classes can have them with or without parameters.
*Every structure has an implicit public constructor without parameters. This
constructor initializes all the structure's data members to their default values.
You cannot redefine this behavior.
Instances and Variables
Because structures are value types, each structure variable is permanently bound
to an individual structure instance. But classes are reference types, and an
object variable can refer to various class instances. This distinction affects
your usage of structures and classes in the following ways:
A structure variable implicitly includes an initialization of the members using
the structure's parameterless constructor. Therefore, Dim S As Struct1 is
equivalent to Dim S As Struct1 = New Struct1().
When you assign one structure variable to another, or pass a structure instance
to a procedure argument, the current values of all the variable members are
copied to the new structure. When you assign one object variable to another, or
pass an object variable to a procedure, only the reference pointer is copied.
You can assign the value Nothing to a structure variable, but the instance
continues to be associated with the variable. You can still call its methods and
access its data members, although variable members are reinitialized by the
assignment. In contrast, if you set an object variable to Nothing, you dissociate
it from any class instance, and you cannot access any members through the
variable until you assign another instance to it.
An object variable can have different class instances assigned to it at different
times, and several object variables can refer to the same class instance at the
same time. Changes you make to the values of class members affect those members
when accessed through another variable pointing to the same instance. Structure
members, however, are isolated within their own instance. Changes to their values
are not reflected in any other structure variables, even in other instances of
the same Structure declaration.
Equality testing of two structures must be performed with a member-by-member
test. Two object variables can be compared using the Equals method. Equals
indicates whether the two variables point to the same instance.
