First, for those who may not be familiar with this feature, .NET 3.5 allows developers to add methods to existing types without using inheritance or partial classes by creating static methods that can be invoked by using instance method syntax.

 

When I first heard about this feature, it reminded me of the decorator pattern in OOP (I’m not speaking of the implementation, but the concept… )

 

Since there are lots of examples for C# developers, and very few for VB.NET, here is an example of adding Serialize and Deserialize methods to any object written in VB.NET:

 

1.    Add a module file to your project and paste the following code:

 

' TODO: need to add SEH and NULL handling!

' TODO: Check for object being marked with Serializable attribute

Module Module1

    <System.Runtime.CompilerServices.Extension()> _

    Public Function Serialize(ByVal o As Object) As String

        Dim data() As Byte

        Using ms As New System.IO.MemoryStream()

            Dim f As New System.Runtime.Serialization.Formatters.Binary.BinaryFormatter

            f.Serialize(ms, o)

            data = ms.ToArray

        End Using

        Return Convert.ToBase64String(data)

    End Function

 

    <System.Runtime.CompilerServices.Extension()> _

    Public Function Deserialize(ByVal s As String) As Object

        Dim result As Object

        Dim data() As Byte = Convert.FromBase64String(s)

        Using ms As New System.IO.MemoryStream(data)

            Dim f As New System.Runtime.Serialization.Formatters.Binary.BinaryFormatter

            result = f.Deserialize(ms)

        End Using

        Return result

    End Function

End Module

 

2.    Below is an example of using this extension method (the important lines are in bold):

 

Public Class Form2

    Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

        Dim t As New Test

        t.i = Integer.Parse(Me.TextBox1.Text)

        t.s = Me.TextBox2.Text

 

        Me.TextBox3.Text = t.Serialize()

    End Sub

 

    Private Sub Form2_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

        Me.TextBox1.Text = New Random().Next(1, 1000).ToString()

        Me.TextBox2.Text = "Time now is " + DateTime.Now().ToLongTimeString()

    End Sub

 

    Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click

        Dim t As Test = Me.TextBox3.Text.Deserialize()

        Me.TextBox4.Text = t.i.ToString()

        Me.TextBox5.Text = t.s

    End Sub

End Class

 

<System.Serializable()> _

Public Class Test

    Private _s As String

    Public Property s() As String

        Get

            Return _s

        End Get

        Set(ByVal value As String)

            _s = value

        End Set

    End Property

 

    Private _n As New NestedTest

    Public Property i() As Integer

        Get

            Return _n.i

        End Get

        Set(ByVal value As Integer)

            _n.i = value

        End Set

    End Property

End Class

 

<System.Serializable()> _

Public Class NestedTest

    Private _i As Integer

    Public Property i() As Integer

        Get

            Return _i

        End Get

        Set(ByVal value As Integer)

            _i = value

        End Set

    End Property

End Class

 

 

 

Now, to the promised performance impact…  I ran and timed a test that created 100,000,000 instances of an object with the extension methods above, and compared the execution time to doing the same but without the extension methods.  Just to be clear, I didn’t actually execute the extension methods…  My goal was to find out if simply adding the extension methods would significantly impact the object instantiation time by running the following code:

 

Dim t As New System.Diagnostics.Stopwatch

t.Start()

Dim o As Test

Dim i As Integer

For i = 0 To 100000000

o = New Test

o.i = 1

o = Nothing

Next

t.Stop()

System.Diagnostics.Debug.WriteLine(t.ElapsedMilliseconds().ToString())

 

To my surprise, my tests show that adding extension methods did not result in any measurable performance decrease.  On my dual proc laptop with 4 Gb RAM, the results were as follows:

 

                   With Extension Methods                 Without Extension Methods

--------------------------------------------------------------------------------------

Run 1            4071 ms                                     3905 ms

Run 2            4118 ms                                     3916 ms

Run 3            4145 ms                                     3904 ms

 

Bottom line – it appears that using extension methods does not have any measurable performance hit on object instantiation time.