Class: NumberMuliplier
Method: howMany
Parameters: Integer, Integer
Returns: Integer
Method signature: Public Function getProduct(x As Integer, y As Integer) As Integer

Public Class NumberMultiplier

  Public Function getProduct(x As Integer, y As Integer) As Integer
	
	'Begin actual code...
	return x * y
	'End actual code.

  End Function

End Class

System.Console.Write("x=" & x)

public sub processGrid(grid() as String)

	dim x, y as integer
	dim myGrid(2,2) as integer
	dim temp() as string

	for y = 0 to 2
		temp=split(grid(y)," ")
		for x = 0 to 2
			myGrid(x,y) = val(temp(x))
		next
	next

end sub

	dim myReturn(2) as integer
	'put some values in myReturn
	return myReturn

	dim myReturn(-1) as integer
	'myReturn has no elements, but we MUST return it anyway - never return nothing!
	return myReturn

  imports System
  imports Microsoft.VisualBasic
  imports System.Collections
  imports System.Text

  Public Class myComparer : Implements IComparer
    Public Function Compare(ByVal x As Object, ByVal y As Object) As Integer
    Implements System.Collections.IComparer.Compare
      If x < y Then Return -1
      If x > y Then Return 1
      Return 0
    End Function
  End Class

  dim al as new ArrayList, comp as new myComparer
  al.add("A")
  al.add("B")
  al.add("a")
  al.sort(al,comp)

• Avoid using the "+" operator for string appends. Use "&" instead in order to avoid accidentally adding instead of appending. "5" + 4 = 9. "5" & 4 = 54.
• Avoid using "/" when dividing integers and taking an integer result (for example, when you know the number is evenly divisible). The "/" operator will convert all of the values involved into doubles. Not only is that slower, but you may lose precision when working with longs (and thus get a wrong result). Use the "\" operator instead; it does integer based division. Similarly, avoid using "\" when doing operations with doubles - unless you want 5\2 to equal 2 instead of 2.5.
• Use the new bit shift operators "<<" and ">>" where appropriate to speed up multiplications, exponents and divisions with powers of 2. Instead of "2^5", use "1<<5".
• Be careful when using "and" and "or" as bitwise operators, especially around "=" signs. For example, "5 and 4 = 4" evaluates to "5" - and that can be a tricky bug to track down. What you probably wanted to say was "(5 and 4) = 4", which evaluates to "true". The safest practice is to add brackets until there's no chance of ambiguity.
• The "mod" operator returns the remainder of a division. For example, 27 mod 10 = 7.
• The "andalso" and "orelse" logical operators work just like "and" and "or", except that they "short circuit". This speeds up execution, and makes certain expressions cleaner. For example, consider the code "if myArray.length=0 or myArray(0)=1 then ...". That's not going to work, as if the array has no elements it will error out when it tries to evaluate myArray(0). With the "orelse" operator, the second part of the expression isn't checked at all if the array is zero length - saving you an error.
• Instead of writing "i=i-1", you can use the shortcut "i-=1". There are a bunch of similar "assignment operators" ("*=", "\=", ">>=", etc..), each of which serves as a shortcut for the respective regular operator.
• The "iif" function is similar to the "?:" operator in C. It takes 3 parameters: a condition, a value "if true" and a value "if false" - and it can be a lot quicker to write than a full "if/else" statement. For example, instead of writing

  if a=b then
    myCompareString="Same"
  else
    myCompareString="Different"
  end if
  

  Try writing:

  myCompareString = iif(a = b, "Same", "Different")