The BigInteger structure becomes available if you add a reference to the System.Numerics namespace. BigInteger represents a positive or negative integer of any size.  This is great for doing arithmetic calculations with very large numbers, and is one of the problems you had to solve on your own in previous versions of .NET Framework.

After the reference is added, you can create a BigInteger using the New keyword, and an initial value can be passed to the constructor, like so:

Dim X As New System.Numerics.BigInteger(Long.MaxValue)
Console.WriteLine(X.ToString())

To do arithmetic operations, create the BigIntegers you need for the operation, and then call the static (shared) functions of the BigInteger structure to do the calculations. In this case, I call the static function Multiply.

Dim X As New System.Numerics.BigInteger(Long.MaxValue)
Dim Y As New System.Numerics.BigInteger(Long.MaxValue)
Dim Z As System.Numerics.BigInteger = _
     System.Numerics.BigInteger.Multiply(X, Y)
Console.WriteLine(Z.ToString())

Just by adding a few of these lines to the above code, will give you one insanely large number.

Z = System.Numerics.BigInteger.Multiply(Z, Z)
Z = System.Numerics.BigInteger.Multiply(Z, Z)
Z = System.Numerics.BigInteger.Multiply(Z, Z)
Z = System.Numerics.BigInteger.Multiply(Z, Z)

One way to serialize this number in SQL Server could be to store the underlying bytes of the number that the BigInteger instance represents. The BigInteger structure has a member function that returns these bytes as a byte array called GetByteArray. An existing byte array can be passed to the constructor of the BigInteger to reconstruct the number.

To get your hands on this new and cool feature, create an ASP.NET 4.0 application or web site from within Visual Studio 2010. Check the Data section of the Toolbox window for a new control called Chart. Dragging out a Chart onto a web page creates the following code:

<asp:Chart ID="Chart1" runat="server">
  <Series>
    <asp:Series Name="Series1">
  </asp:Series>
  </Series>
    <ChartAreas>
      <asp:ChartArea Name="ChartArea1">
    </asp:ChartArea>
  </ChartAreas>
</asp:Chart>

There is a huge amount of properties available for the chart. They control the look of the chart, the chart type among other things. I don’t have any databases installed on this computer, so to get some data to do a chart from; I connect the control to a data source that represents the system database master. I use the following query to get a bunch of large numbers:

SELECT [name],[number] FROM dbo.spt_values WHERE [number]>17000

I use number as Y value member.

This is what I have to do to get the fully functional chart! Fooling around with chart types and visual properties is dangerously amusing.

If you haven’t got a database server at all, you can quickly create an object data source in Visual Basic, and assign that to your chart. Connection this code…

Public Class MyChartData

    Private mValue As Integer

    Public Sub New(ByVal Value As Integer)
        Me.mValue = Value
    End Sub

    Public ReadOnly Property Value() As Integer
        Get
            Return Me.mValue
        End Get
    End Property

    Public Shared Function GetItems() As MyChartData()
        Dim Ret As New List(Of MyChartData)()
        Ret.Add(New MyChartData(10))
        Ret.Add(New MyChartData(20))
        Ret.Add(New MyChartData(15))
        Ret.Add(New MyChartData(25))
        Return Ret.ToArray()
    End Function

End Class

…gives you this beautiful result:

Ah, the simplicity! Aaaaah, the power!

Now I have had the opportunity to try out the new collection initializers of Visual Basic 10. This is good stuff and I am very happy about being able to do line breaks when I use this (just as C programmers can do whenever they want). Examine this simple example that consist of a ContactPerson class, and a generic collection that I initialize using the collection initializer.

Module Module1

    Public Class ContactPerson
        Public FirstName As String
        Public LastName As String
        Public EMail As String

        Public Overrides Function ToString() As String
            Return Me.FirstName & " " & Me.LastName & " " & Me.EMail
        End Function
    End Class

    Sub Main()

        Dim L As New List(Of ContactPerson) From {
         {New ContactPerson With {.FirstName = "Anders", .LastName = "Andersson", .EMail = "anders@some.thing"}},
         {New ContactPerson With {.FirstName = "Bertil", .LastName = "Bengtsson", .EMail = "bertil@some.thing"}},
         {New ContactPerson With {.FirstName = "Calle", .LastName = "Ceder", .EMail = "calle@some.thing"}}
         }

        For Each P As ContactPerson In L
            Console.WriteLine(P.ToString())
        Next

    End Sub

End Module

Note that the element type does not require any special constructor, I can provide a constructor and target that, but here I am using the object initializer that was introduced in Visual Basic 9.

Instead of the parenthesis that I would use to call the List constructor, I use the From keyword with a curly bracket, and each element is surrounded by curly brackets, separated by a comma. Finally, I have to use another set of curly brackets because I use the object initializer for each element, instead of a regular constructor.

If I adapt this code to use a constructor for each element, this is how it could look. This uses the new collection initializer and traditional constructors (and therefor less curly brackets).

Module Module1

    Public Class ContactPerson
        Public Sub New(ByVal FirstName As String, ByVal LastName As String, ByVal EMail As String)
            Me.FirstName = FirstName
            Me.LastName = LastName
            Me.EMail = EMail
        End Sub
        Public FirstName As String
        Public LastName As String
        Public EMail As String

        Public Overrides Function ToString() As String
            Return Me.FirstName & " " & Me.LastName & " " & Me.EMail
        End Function
    End Class

    Sub Main()

        Dim L As New List(Of ContactPerson) From {
         {New ContactPerson("Anders", "Andersson", "anders@some.thing")},
         {New ContactPerson("Bertil", "Bengtsson", "bertil@some.thing")},
         {New ContactPerson("Calle", "Ceder", "calle@some.thing")}
         }

        For Each P As ContactPerson In L
            Console.WriteLine(P.ToString())
        Next

    End Sub

End Module

There are only a few new changes and additions made to the language Visual Basic in version 10. Changes in version 7, 8 and 9 were huge, and from version 9, I really like what it has become, and all that is needed in version 10 is some polishing. I will spend a few posts on some of the features.

In version 9, we got object initializers and in Visual Basic 10 the initializers will work for arrays and collections. Microsoft call them Collection Initializers. This is a good example of polishing, because the object initializers did not help that much, especially not if you have implemented the constructors that you desire.

A Collection Initializer is a different story. Here, we actually accomplish something useful.

Now, we can create a collection and initialize it with some elements that also are initialized, all in one single line!

The syntax is:

Dim Variable = New CollectionClass = {{element initialization}, {element initialization}, …}

If you want to initialize a collection of objects, and each object is initialized with two integer values (this could be a polygon with points), the could would look like this (if I use the generic collection):

Dim C = New List(Of MyPoint) From {{10, 20}, {15, 25}, {30, 40}}

This would require 4 lines in Visual Basic 9. One to create the collection, and one for each element. If you like, you can break the line at a comma in Visual Basic 10. Good for formatting.