Private Function Encrypt(ByVal strInput As String, ByVal strKey As String) As
String
Dim iCount As Long
Dim lngPtr As Long
    For iCount = 1 To Len(strInput)
        Mid(strInput, iCount, 1) = Chr((Asc(Mid(strInput, iCount, 1))) Xor
(Asc(Mid(strKey, lngPtr + 1, 1))))
        lngPtr = ((lngPtr + 1) Mod Len(strKey))
    Next iCount
    Encrypt = strInput
End Function

Since a computer running Windows NT can support multiple desktops, if you use a component designed to work with distributed COM, it can result in the following scenario:

	A client program in a user desktop requests one of the objects the component provides. Because the component is physically located on the same machine, the component is started in the user desktop.
	Subsequently, a client program on another computer uses distributed COM to request one of the objects the component provides. A second instance of the component is started, in a system desktop.

There are now two instances of the component running on the same NT computer, in different desktops.

When you retrieve a numeric value from a textbox, you may want to compare it to some other preset value. For example, consider the following code:

Select Case Text1.Text
   Case 1 to 12
      MsgBox "Acceptable Value"
   Case Else
      MsgBox "Unacceptable Value"
End Select

You might think that this code would compare a numeric value in Text1 and return Acceptable Value for values 1 through 12, and Unacceptable Value for all other numbers. Instead, this code snippet displays the Acceptable Value message for only 1, 10, 11, and 12, but not 2, 3, 4, etc. That's because a textbox's Text property returns the value as a string, and so compares them as such in the Select Case statement.
To avoid this unexpected glitch, convert the numbers with the Val() function. This function automatically converts a string into the appropriate type: integer, long, single, or double. The modified code would look as follows:

Select Case Val(Text1.Text)
   Case 1 to 12
      MsgBox "Acceptable Value"
   Case Else
      MsgBox "Unacceptable Value"
End Select

Most high level programming languages force the developer to explicitly declare a variable before using it. Visual Basic is a notable exception. In fact, by default, VB's installation leaves the Visual Basic environment in a state where variable declaration is not required.
After installing Visual Basic, immediately select Tools-Options and check on REQUIRE VARIABLE DECLARATION. 

Selecting this option causes Visual Basic to insert the statement OPTION EXPLICIT into the General Declarations Section of each module in your project. The result is that an attempt to refer to a variable in code without first declaring it results in a compiler error.
What's the big deal, you might ask? Is there really a harm in leaving this option checked off? Suppose you use a variable in code that you haven't declared? Visual Basic is a programmer friendly language-won't VB take care of it? 
The answer is yes. VB will take care of it, but the price of a mistake on your part can be huge. 
For instance, suppose you assign a value to a variable called sngUnitPrice like this...

sngUnitPrice = 13.48 

And then later in your code you attempt to refer to this variable in a calculation, but accidentally refer to it by an incorrect name, for instance sngUnitCost (yes, it can happen!)

sngTotalPrice = sngUnitCost * m_intQuantity 

You're expecting the program to come up with a valid price. Instead,the result will be zero, since the value of the incorrectly named variable sngUnitCost is zero!When you tell VB to enforce variable declaration, errors like these are caught at compile time, potentially preventing disastrous results from occurring.

Since it's introduction in ADO 2.0, data shaping has remained largely on the fringes of Visual Basic arcanum. Relegated to the back pages of musty manuals, you may have overlooked this useful aspect of ADO. If you're not familiar with data-shaping, in essence, it lets you create recordsets within recordsets--or parent/child relationships--all with a  single ADO object. This means no messy joins, no complicated filtering, and no need for spaghetti-code in presentation logic. Data shaping reduces the amount of traffic crossing a network, provides more flexibility when using aggregate functions, and reduces overhead when interfacing with leading-edge tools like XML.

To create a shaped recordset, you use a standard SQL statement, along with three major keywords: SHAPE, APPEND, and RELATE, like so

SHAPE {SELECT EmployeeID,FirstName, LastName 
FROM Employees} 
APPEND ({SELECT OrderID, shipname, EmployeeID 
FROM orders} AS SomeAlias 
RELATE EmployeeID TO EmployeeID);

The SHAPE keyword specifies and defines the parent recordset. Once you create a parent object, you next APPEND the child recordset. This clause uses a similar syntax as SHAPE and contains the necessary SQL statement to create the child recordset within the parent. In addition to the child recordset's SQL statement, you must also indicate how you want the two recordsets to RELATE.

    Dim txt As String
    Dim blank As String

        blank = ""
            : 
        If Len(txt) = 0 Then ...
        If txt = vbNullString Then ...
        If txt = "" Then ... 
        If txt = blank Then ...

Typically, to determine when a UserControl gains and loses focus, you might think to use the standard GotFocus and LostFocus events. However, in UserControls these two events aren't always reliable. There are situations where a control will lose the focus without firing the LostFocus event (for example, when Alt+Tabbing to another application), and also get the focus without firing the GotFocus event. As a result, your best bet for monitoring the focus status is to insert code in the UserControl's EnterFocus and ExitFocus events.

The CInt() function rounds to the nearest integer value. In other words, CInt(2.4) returns 2, and CInt(2.6) returns 3. 

This function exhibits an under-documented behavior when the fractional part is equal to 0.5. In this case, this function rounds down if the integer portion of the argument is even, but it rounds up if the integer portion is an odd number. For example, CInt(2.5) returns 2, but CInt(3.5) returns 4.

While Visual Basic provides an easy way to create shortcut menus, some controls 
such as rich text boxes don't inherently support pop-up menus. To overcome this 
obstacle, you can take advantage of the MouseDown() event. Visual Basic triggers 
this event when you press the mouse button. To provide a pop-up menu, create a 
shortcut menu, then simply call it in the control's MouseDown() event.

To see how this works, add a Rich Textbox control to a sample form. Next, select 
Tools | Menu Editor from Visual Basic's IDE menu bar, and create a simple menu 
with one or two items. Then, switch to the form's code window, and enter 

Private Sub RichTextBox1_MouseDown(Button As Integer, Shift As Integer, X As Single, Y As Single)
   If Button = vbRightButton Then
      Me.PopupMenu Menu
   End IF
End Sub

Declare Function MIDASplayModule Lib "midas11.dll" Alias _
     "_MIDASplayModule@8" (ByVal module As Long, ByVal loopSong _
     As Boolean) As Long

When you use the Windows API, you should never need to write your own Declare statement. The API Text Viewer utility loads in a text file (WIN31API.TXT for 16-bit, and WIN32API.TXT for 32-bit) and lets you copy declares, global constants, and user-defined types. You can also convert the text file to an Access database for faster searching. Handy, eh?

You can [Ctrl] your Visual Basic control selection. 

Suppose you want to place several radio buttons within a frame on a Visual Basic form. If you click on the Radio Button control in the palette, then draw your button, the palette selection will automatically revert to the pointer. To circumvent this behavior, press and hold [Ctrl] while you click on the control in the palette. Now the control remains selected, so you can click and drag as many radio buttons (or any other control type) as you need. When you're finished, click on the pointer in the palette to return to the normal mode of operation. 

To spell check RTF documents, you could resort to embedding Word into your application. However, if you plan to use the WebBrowser control, there's no need to program Word for spell checking. That's because the WebBrowser control provides this functionality for you. To access it, you use the WebBrowser control's ExecWB() method with the OLECMDID_SPELL flag.
To illustrate, add the WebBrowser control to a form, then add the following code to the form's Load() event:
WebBrowser1.Navigate "D:\Internet\spell.rtf" Replace the path with any string that points to an RTF file.
Next, add a command button, and enter this code in its Click() event:
WebBrowser1.ExecWB OLECMDID_SPELL, OLECMDEXECOPT_DODEFAULT
Run the project. The WebBrowser displays the RTF file, and when you click the command button, VB runs through the normal spell check operation.