• Use & to concatenate strings:

  Visual Basic

  MsgBox("hello" & vbCrLf & "goodbye")
  
  

• For appending strings in loops, use the StringBuilder object:

  Visual Basic

  Dim longString As New System.Text.StringBuilder
  For count As Integer = 1 To 1000
    longString.Append(count)
  Next
  
  

Take advantage of type inference for local variables:

Public Sub GetQuery()
  Dim filterValue = "London"
  Dim query = From customer In customers _
              Where customer.Country = filterValue
End Sub

Use relaxed delegates and leave out event arguments if you are not using the event arguments in your code:

Public Sub Form1_Load() Handles Form1.Load
End Sub

• Use Integer rather than unsigned types unless memory is at a premium.

• Use the short syntax when initializing arrays on the declaration line:

  Visual Basic

  Dim letters1() As String = {"a", "b", "c"}
  
  

  Rather than this:

  Visual Basic

  Dim letters2() As String = New String() {"a", "b", "c"}
  
  

• Put the array designator on the variable, not on the type:

  Visual Basic

  Dim letters3() As String = {"a", "b", "c"}
  
  

  Rather than this:

  Visual Basic

  Dim letters4 As String() = {"a", "b", "c"}
  
  

• Use the { } syntax when declaring and initializing arrays of basic data types:

  Visual Basic

  Dim letters5() As String = {"a", "b", "c"}
  
  

  Rather than this:

  Visual Basic

  Dim letters6(2) As String
  letters6(0) = "a"
  letters6(1) = "b"
  letters6(2) = "c"
  
  

When using a series of calls to one object, consider using the With keyword:

With orderLog
  .Log = "Application"
  .Source = "Application Name"
  .MachineName = "Computer Name"
End With

Allow type inference to determine the type of the loop range variable.

Following is an example of using type inference in a For statement:

For count = 0 To 2
  MsgBox(names(count))
Next

Following is an example of using type inference in a For Each statement:

For Each name In names
  MsgBox(name)
Next

• Do not use On Error Goto.

• To handle exceptions, use a Try...Catch statement:

  Visual Basic

  Dim conn As New SqlConnection("connection string")
  Try
    Conn.Open()
  Catch ex As SqlException
  
  Finally
    Conn.Close()
  End Try
  
  

• The Using statement combines a Try...Catch statement with a call to the Dispose method and simplifies the code. If you are using a Try...Catch statement and the only code in the Finally block is a call to the Dispose method, use the Using statement instead:

  Visual Basic

  Using redPen As New Pen(color.Red)
    ' Insert code here.
  End Using
  
  

Use the IsNot keyword in preference to Not...Is Nothing.

To avoid exceptions and increase performance by skipping unnecessary code, use AndAlso instead of And and OrElse instead of Or when you perform comparisons:

' Avoid a null reference exception. If the left side of the AndAlso 
' operator is False, the right side is not evaluated and a null 
' exception is not thrown.
If nullableObject IsNot Nothing AndAlso nullableObject = testValue Then

End If

' Avoid an unnecessary resource-intensive operation. If the left side
' of the OrElse operator is True, the right side is not evaluated and 
' a resource-intensive operation is not called.
If testCondition OrElse ResourceIntensiveOperation() Then

End If

Use Form1.ShowDialog rather than My.Forms.Form1.ShowDialog.

• Use short instantiation:

  Visual Basic

  Dim employees As New List(Of String)
  
  

  The preceding line is equivalent to this:

  Visual Basic

  Dim employees2 As List(Of String) = New List(Of String)
  
  

• Use object initializers for new objects instead of the parameterless constructor:

  Visual Basic

  Dim orderLog As New EventLog With { _
      .Log = "Application", _
      .Source = "Application Name", _
      .MachineName = "Computer Name"}
  
  

• Use Handles rather than AddHandler:

  Visual Basic

  Private Sub ToolStripMenuItem1_Click() Handles ToolStripMenuItem1.Click
  End Sub
  
  

• Use AddressOf, and do not instantiate the delegate explicitly:

  Visual Basic

  Dim closeItem As New ToolStripMenuItem( _
      "Close", Nothing, AddressOf ToolStripMenuItem1_Click)
  Me.MainMenuStrip.Items.Add(closeItem)
  
  

• When you define an event, use the short syntax and let the compiler define the delegate:

  Visual Basic

  Public Event WhatHappened(ByVal source As Object, _
                            ByVal e As WhatHappenedEventArgs)
  
  

• Do not check to see whether an event is Nothing (null) before calling the RaiseEvent method. RaiseEvent checks for Nothing before it raises the event.

Call Shared members by using the class name, not from an instance variable.

Use MsgBox instead of MessageBox.Show or Console.WriteLine. In environments that do not support the MsgBox function, such as Silverlight, use an appropriate alternative.

Use My features in preference to the .NET Framework class library or the Visual Basic run-time library. For more information, see Objects (Visual Basic).

XML literals simplify the most common tasks that you encounter when you work with XML (for example, load, query, and transform). When you develop with XML, follow these guidelines:

• Use XML literals to create XML documents and fragments instead of calling XML APIs directly.

• Import XML namespaces at the file or project level to take advantage of the performance optimizations for XML literals.

• Use the XML axis properties to access elements and attributes in an XML document.

• Use embedded expressions to include values and to create XML from existing values instead of using API calls such as the Add method:

  Visual Basic

  Private Function GetHtmlDocument( _
      ByVal items As IEnumerable(Of XElement)) As String
  
    Dim htmlDoc = <html>
                    <body>
                      <table border="0" cellspacing="2">
                        <%= _
                          From item In items _
                          Select <tr>
                                   <td style="width:480">
                                     <%= item.<title>.Value %>
                                   </td>
                                   <td><%= item.<pubDate>.Value %></td>
                                 </tr> _
                        %>
                      </table>
                    </body>
                  </html>
  
    Return htmlDoc.ToString()
  End Function
  
  

• Use meaningful names for query variables:

  Visual Basic

  Dim seattleCustomers = From cust In customers _
                         Where cust.City = "Seattle"
  
  

• Alias elements in a query to make sure that property names of anonymous types are correctly capitalized using Pascal casing:

  Visual Basic

  Dim customerOrders = From customer In customers _
                       Join order In orders _
                         On customer.CustomerID Equals order.CustomerID _
                       Select Customer = customer, Order = order
  
  

• Rename properties when the property names in the result would be ambiguous. For example, if your query returns a customer name and an order ID, instead of leaving them as Name and ID in the result, rename them:

  Visual Basic

  Dim customerOrders2 = From cust In customers _
                        Join ord In orders _
                          On cust.CustomerID Equals ord.CustomerID _
                        Select CustomerName = cust.Name, _
                               OrderID = ord.ID
  
  

• Use type inference in the declaration of query variables and range variables:

  Visual Basic

  Dim customerList = From cust In customers
  
  

• Align query clauses under the From statement:

  Visual Basic

  Dim newyorkCustomers = From cust In customers _
                         Where cust.City = "New York" _
                         Select cust.LastName, cust.CompanyName
  
  

• Use Where clauses before other query clauses to make sure that later query clauses operate on the reduced, filtered set of data:

  Visual Basic

  Dim newyorkCustomers2 = From cust In customers _
                          Where cust.City = "New York" _
                          Select cust.LastName, cust.CompanyName
  
  

• Use the Join clause to explicitly define a join instead of using the Where clause to implicitly define a join:

  Visual Basic

  Dim customerList2 = From cust In customers _
                      Join order In orders _
                        On cust.CustomerID Equals order.CustomerID _
                      Select cust, order
  
  

Use the Visual Basic run-time library in preference to the .NET Framework class library.

• Follow the design guidelines in Design Guidelines for Class Library Developers.

• Specify the prompt and title of MsgBox calls.

• Use resource files when appropriate.

• Use Option Strict On, either in each file, or as a project setting.

• Compile with all warnings on.

• Define only one Class, Structure, or Interface in a file.

• Use the default encoding to save files.

• Use the AutoSize property where possible.

• Do not hide or overlap controls.

• Do not line up controls to create a sentence.

• Do not build strings by stripping out characters from another string.

• Use culture-neutral graphics.

• Use only Tahoma or MS Sans Serif fonts.

• Use colors from the System tab of the color picker dialog box.

• Use accelerators for all menus, labels, buttons, and so on.

• Set control properties as described in the following table.