Within the .NET Framework data types such as Boolean can either be true or false. Right?  Well, with the release of 2.0 Framework it has been possible to create nullable data types.  A nullable type can represent all the values of the underlying type plus empty (or undefined).  In the case of our Boolean it would be True/False and Nothing.

It is only possible to create a nullable types Nullable(Of T) for value types since the default value for reference types is already nothing.  The following types are valid as nullable: Boolean, Byte, Int16, Int32, Int64, Single, Double, Decimal, DateTime.  The following examples show examples on how to create a nullable variable type:

Dim success as New Nullable(Of Boolean)()

Dim customerId as New Nullable(Of Integer)()

With the release of .NET 3.5 it is also possible to use the short form versions:

Dim success as Boolean?

Dim customerId as Integer?

In C#

bool? success;
int? customerId;

To check of a nullable type as a value it is possible to use the HasValue  or Value properties.  Use the System.Nullable.GetValueOrDefault property return either the assigned value, or the default value for the underlying type.  

If customerId.HasValue Then

  ‘do something

End If

If assigning a nullable type to a non-nullable type you must cast operator is necessary.  For example:

int newCustomerId = (int)customerId;  // in C#

Nullable types can be useful when dealing with NULL values from a database query however they are not the same.  That is to say that DBNULL value is not the same as Nothing.  When returning data from the database the following code will be necessary:

int? customerId = null;

if (!DBNULL.Value.Equals(reader[“CustomerId”])){    // this code converts the DBNULL to a c# null
  customerId = (int)reader[“CustomerId”];
}

Generics provide a way for developers to define subroutines, functions, fields, properties as well as classes, structures, interfaces and even delegates in such a way that the parameters are not of any particular type.  In a sense the constructs are defined in a generic approach.

The .NET Framework contains the following namespaces:System.Collections, System.Collections.Generic.    The latter mimics very much the features of the former. 

System.Collections namespace (nongeneric)

ICollection is the most primitive interface of the System.Collections

Public Interface ICollection

  Inherits IEnumerable

  Sub CopyTo(ByVal array As Array, ByVal index As Integer)

  ReadOnly Property Count() As Integer

  ReadOnly Property IsSynchronized() As Boolean

  ReadOnly Property SyncRoot() As Object

End Interface

IDictionary is a simple collection that maintains a set of name/value pairs.  Using this type allows you such features as returning an item by say license plate number or persons name for example.

Public Interface IDictionary

  Inherits ICollection, IEnumerable

  Sub Add(ByVal key As Object, ByVal value As Object)

  Sub Clear()

  Function Contains(ByVal key As Object) As Boolean

  Function GetEnumerator() As IDictionaryEnumerator

  Sub Remove(ByVal key As Object)

  ReadOnly Property IsFixedSize() As Boolean

  ReadOnly Property IsReadOnly() As Boolean

  Property Item(ByVal key As Object) As Object

  ReadOnly Property Keys() As ICollection

  ReadOnly Property Values() As ICollection

End Interface

IList provides the ability to insert, remove and index items

Public Interface IList

  Inherits ICollection, IEnumerable

  Function Add(ByVal value As Object) As Integer

  Sub Clear()

  Function Contains(ByVal value As Object) As Boolean

  Function IndexOf(ByVal value As Object) As Integer

  Sub Insert(ByVal index As Integer, ByVal value As Object)

  Sub Remove(ByVal value As Object)

  Sub RemoveAt(ByVal index As Integer)

  ReadOnly Property IsFixedSize() As Boolean

  ReadOnly Property IsReadOnly() As Boolean

  Property Item(ByVal index As Integer) As Object

End Interface

So far I have show the key interfaces within System.Collections.  The interfaces alone do not provide the implementation.  The following will document the relationships between the above interfaces and the specific types within the System.Collections namespace.

While the above are types of System.Collections there are additional types within the System.Collections.Specialized such as BitVector32 (collection of booleans), CollectionsUtil (ignores case in strings), HybridDictionary (starts as ListDictionary however it switches automatically to hashTable as the collection gets large), ListDictionary (for small collections of 10 items or less), NameValueCollection (sorted collection of string keys and string values), StringCollection (collection of strings), StringDictionary (a hashtable with key values strongly typed to string type), StringEnumerator.

Now with respect to the System.Collections.Generic namespace; it contains a series of types that leverage the features of the for mentioned collections however they bring to the forefront the advantages: improved performance by avoiding boxing and unboxing, type-safety, code maintenance issues.  The generic collection when declared specifies the type of the collection item.  In the following example we create a generic collection that can only contain integers.  If the developer attempts to insert anything other than an Integer they will get a design time error.

Boxing/Unboxing is a term that is used when a value type variable is stored in a reference type structure.  This occurs with all nongeneric types as they operate of the System.Objects type.

For example:
Dim ar as New ArrayList()
ar.Add(123) ‘boxing occurs
Dim i as Integer = CType(ar(0), Integer) ‘unboxing occurs

Using a generic collection:
Dim ar as New List(Of Integer)
ar.Add(10) ‘no boxing
Dim i as Integer = ar(0) ‘no unboxing

The following is a list of interfaces within the System.Collections.Generic namespace: ICollections(Of T), IComparer(Of T), IDictionary(Of K, V), IEnumerable(Of T), IEnumerator(Of T), and IList(Of T).  There respective classes are as follows:

The convention is that generic types specify their placeholders typically with T to represent the type of variable the collection is to contain.

So far we have discussed generic in the sense of a collection class.  With all the same benefits a method can be defined as generic.  The following example shows how the method was defined to take two parameters of Type T.  Using a generic function like this can allow one function to operate on more than one type of variable.  The convention is to follow the method name with the type of the parameters passed in.  Calling the following function would look something like Test(Of String)(“test1”, “Test2”)

Public Function Test(Of T)(ByRef o1 as T, ByRef o2 as T) as T
  ‘do something
End Function

It is possible to establish constraints with respect to the type of T.  The following is a complete list of the types of constraints:
Of T as Structure > the type parameter must be a value type (ie. structure)
Of T as Class > the type parameter must be a reference type (i.e. classes)
Of T as New > the type parameter must have a default constructor
Of T as NameOf BaseClass > the type parameter must be derived from the class specified by NameOfBaseClass
Of T as NameOfInterface > the type parameter must implement the interface specified by NameOfInterface

’new items must have a default constructor
Public Class TestClass(Of T as New)
  ‘stuff here
End Class

The term generic can apply to Interfaces as well. In any case the interface will define the contract that the implementing class must adhere to.  When implementing a generic interface the supporting type specifies the placeholder type:

Public Interface IMyInterface(Of T)
  Function Add(ByVal x as T, ByVal y as T) as T
End Interface

Public Class MyClass
  Implements IMyInterface(Of Integer)

Public Function Add(ByVal x as Integer, ByVal y as Integer) as Integer
  Return x + y
End Function

By all means utilize the generic collection namespace over the system.collection nongeneric namespace.  In addition to improved performance(avoiding boxing/unboxing) your code will avoid type-safety issues of earlier releases of .NET.