Now that might seem a strange question, because list building and email marketing is one area where a lot of new online business owners have a problem. They read so much information that they are not sure what now is relevant to them and what isn’t.

How do you find the information that is going to solve your problem of sending emails to your list? Well, maybe your first comment is to say what list? I would love to have a solution to the email problem, but it isn’t relevant to me as I have no list to start with.

Then, you have come to the right place. You see, true solutions will solve all the problems you are face. The first thing you need to look at is why you have no list, is it simply you haven’t put an opt-in on your website?

We are going to look at the basic problem of having no list. Do you know how important it is to build your list? If you are not sure, then think about how you will keep in contact with buyer and potential buyers if you don’t know who they are.

By having a double-opt-in list builder you will be able to not only get their details, but also they will have to confirm that they want to hear from you. If they then say you didn’t get permission, you will already have all the information including their IP and date of sign up.

You need to then know your marketing strategy to sell to them. What are the problems they are facing, and how can you incorporate the solutions into your newsletters?

These are important things to remember when creating your email marketing solutions. Remember, the key here is solutions. You will need to address the problems but always be offering them a solution.

This will mean that if you find a solution to an everyday problem, then people can’t but buy the solution, and then pass on the information. They will soon be telling everybody they know how to solve the problem, and be directing them to your website.

Once they have arrived there, they see the opt-in form, and will be signing up before they have read the whole sales page, because they are hungry and want to know more. They will be ready to buy whatever you are selling which will solve their problems.

They are prepared to pay for solutions. People know they can find solutions by searching, but often there are the doubts, am I really getting the right answers here, will it work, can I trust the site?

You see, your credibility has grown, because you already have people in your viral network, who know and trust you, and because of that they spread the good news about your site. This is why you need to consider your marketing solutions when you first start your website. What you think is going to be a small list, is going to be a network of people who are ready to join your site, and give you more and more people that are also ready to join your site.

Disney is well known for their beautifully animated fairy tales and the characters from them that have captivated us, just as much as its icon mouse since 1928. Something that many people do not know about our treasured Disney Princess stories from the Walt Disney Company is that many of them were based on already existing works.

Snow White and the Seven Dwarfs

Snow White and the Seven Dwarfs was the first animated feature film produced by Walt Disney in 1937. The film was originally based on the fairy tale by the Brothers Grimm titled ‘Snow White’. The Brothers Grimm, Wilhelm and Jacob Grimm were German academics and were responsible for many popular fairy tales that include ‘Rumpelstiltskin’, ‘Rapunzel’, ‘Hansel and Gretel’ and ‘The Frog Prince’.

Cinderella

Cinderella was released in 1950 and produced by Walt Disney. The story of Cinderella has been recorded in many works throughout history with versions included from Charles Perrault and the Brothers Grimm. Disney’s animated film was most likened to Charles Perrault’s fairy tale. Charles Perrault was a French author and published many fairy tales and his works include ‘Puss in Boots’ and ‘Little Red Riding Hood’.

Sleeping Beauty

Sleeping Beauty was produced by Walt Disney and released to theaters in 1959. The Disney story of Sleeping Beauty was also based on the Charles Perrault works from his fairy tale titled ‘Sleeping Beauty’.

The Little Mermaid

The Little Mermaid was released in 1989. The Disney story of The Little Mermaid was originally based on the Hans Christian Andersen fairy tale titled ‘The Little Mermaid’. Hans Christian Andersen was a Danish author and poet and his works consisted of many well known fairy tales that include ‘The Ugly Duckling’, ‘Thumbelina’, ‘The Princess and the Pea’, ‘The Emperor’s New Clothes’ (of which Disney based their animated feature film ‘The Emperor’s New Groove’) and many more famous stories.

Beauty and the Beast

Beauty and the Beast was released by Disney in 1991. The story of Beauty and the Beast was originally based on the traditional fairy tale titled ‘Beauty and the Beast’ by French author Gabrielle-Suzanne Barbot de Villeneuve and abridged and republished by French author Jeanne-Marie Leprince de Beaumont.

The Disney adaptations of these earlier recognized stories have enabled children to experience the stories through the latest developments and technologies of visual media. Throughout history these stories in their original written and subsequent adapted visual forms have given great enjoyment to children and adults alike.

Microsoft puts it this way at the MSDN site: “The properties and methods of the Collection object provide only the most basic services for collections.” To really get the most from collections, you need to use some of the more specialized classes that inherit from the Collection object. And there’s a bunch of them - too many to detail all of them here. But here’s an introduction.

ArrayList

ArrayList, in spite of the name, actually inherits from the Collection object. The next version of the Signature Block program uses one. ArrayList might be thought of as a better array. One principal advantage is that it’s size is dynamic. And you can sort it! (You can sort regular arrays too, but the code to do it is, again, different.)

Here’s an example:

Dim myArrayList As New ArrayList
myArrayList.Add(”Sam”)
myArrayList.Add(”George”)
myArrayList.Add(”Allen”)

For Each name As String In myArrayList
Debug.WriteLine(name)
Next name
‘ The result is in the same order they were added:
‘ Sam
‘ George
‘ Allen

myArrayList.Sort()

For Each name As String In myArrayList
Debug.WriteLine(name)
Next name
‘ Now the result is sorted:
‘ Allen
‘ George
‘ Sam

Stacks and Queues

A Stack is a last-in, first-out (LIFO) collection.

A Queue represents a first-in, first-out (FIFO) collection. These are ideas that go way back in software. Some early mainframe computers were designed as “stack machines” because the instructions that were executed were stored in stack arrays.

Stack and Queue work pretty much like other collections except they have the Push, Peek, and Pop methods to manage the elements. Here’s an example

Dim myStack As New Stack
myStack.Push(”George”)
myStack.Push(”Allen”)
myStack.Push(”Sam”)
Debug.WriteLine(myStack.Peek)
Debug.WriteLine(myStack.Pop)
Debug.WriteLine(myStack.Pop)
‘ Here’s the result. Peek doesn’t change the Stack
‘ Sam
‘ Sam
‘ Allen

Dictionary and Hashtable

Dictionary collections are pretty much what you might expect. This technique is available in VB 6 and even VBScript. The main thing that has changed is the number and sophistication of the methods and properties available.

The main benefit of dictionary objects and Hashtable is performance in large collections. Consider a collection of, for example, 50,000 elements. Suppose you want the element that has the key “D479H431″. If the elements in the collection are in random order, the only way a specific one can be found is by starting at the beginning and looking at each element until the right one is found.

The idea behind Hashtable is to convert a key into a hashcode and then use the hashcode as an actual key to save values in the collection. The hashcode gives the software a head start in finding the objects and speeds up the process considerably. (Consult volume 3 of Don Knuth’s “Art of Computer Programming” for the details.)

Hashtables also go way back in software and have been used for a long time. A hashtable is basically a lookup table except that the key value used for looking up something else is a calculated value known as a hashcode that is based on the value being saved in the table. The hashcode value is calculated so that it’s unlikely, but not impossible, for some other text string to result in the same hashcode value. But the calculation guarantees that the same string will always produce the same hashcode value. Think of the hashcode as being a nickname for the entire string.

Here’s an example of how the SortedDictionary object is used in code:

Dim myDict As New SortedDictionary(Of String, String)

myDict.Add(”txt”, “notepad.exe”)
myDict.Add(”bmp”, “paint.exe”)
myDict.Add(”dib”, “paint.exe”)
myDict.Add(”rtf”, “wordpad.exe”)

Other collections of objects are in the System.Collections namespace to provide some really advanced functions like sorting, fast retrieval even with large objects, and LIFO and FIFO access to the collection.

In general, the way you work with a collection is quite different than an array. As a starting example, you add something to an array using the simple assignment operator:

Dim myStudentArray(10) As String
myStudentArray(5) = “George”

With a collection, you must use the Add method (and the Remove method to delete an element again).

Dim myStudentColl As New Collection
myStudentColl.Add(”George”)

But notice a few other differences!

First, we didn’t have to tell VBE how big the collection is. If you use an array and then change the size, you have to use the ReDim statement if the number of elements in the array ever gets bigger than the initial declaration.

But collections are inherently variable in size.

Second, we didn’t have to tell VBE that the collection would hold String members. Collections are “weakly typed”. So we can use a variety of different data types together in the same collection.

Here’s an example:

Dim myStudentColl As New Collection
myStudentColl.Add(”George”)
myStudentColl.Add(1234567)
Debug.WriteLine(myStudentColl(1))
Debug.WriteLine(myStudentColl(2))

Notice also that the index of the first element is 1 for collections and 0 for arrays. (For reasons that have never made sense to me! Space is allocated for the zero element of a collection, but you can’t use it. See the illustration below.)

All collection elements are saved as an Object type. This goes back to the concept used in VB 6 where most data was a Variant data type. As a result, Collections aren’t as fast as arrays and don’t protect you from using data that isn’t in the correct type. But using both arrays and collections, you can take advantage of another VB.NET idea to keep different types of data in the same grouping: structures. A structure plays a key role in the Signature Block program.

Here’s the way a structure would be used with arrays:

‘ This block must be coded before
‘ the Sub or Function statement
Structure StructObj
Dim StringItem As String
Dim NumberItem As Integer
Dim DateItem As Date
End Structure

Dim myStudentArray(10) As StructObj
myStudentArray(5).StringItem = “George”
myStudentArray(5).NumberItem = 123456
myStudentArray(5).DateItem = #12/7/1941#

And here’s the same idea with a collection:

Dim myStudentColl As New Collection
Dim myStructObj As StructObj
myStructObj.StringItem = “George”
myStructObj.NumberItem = 123456
myStructObj.DateItem = #12/7/1941#
myStudentColl.Add(myStructObj)

The bottom line is that collections are for the more demanding tasks in your program. So let’s see some of the new tricks offered by collections!

Note that each member of the collection also has a key (whether you want it or not). You can access collections like a simple database using a key value. The key must be a string and it must be unique. So if you run this code:

Dim myStudentColl As New Collection
myStudentColl.Add(”George”, “ID-1″)
myStudentColl.Add(”Mary”, “ID-2″)
myStudentColl.Add(”Sam”, “ID-3″)
myStudentColl.Add(”Tom”, “ID-4″)
Debug.WriteLine(myStudentColl.Item(”ID-3″))

The result is “Sam”. (Item is the default property so it’s often not coded.)

A subtle point that the new collection coding syntax implies is that you can’t update either. In other words, with an array, you can update the value saved in the sixth element like this:

myStudentArray(5) = “George”
myStudentArray(5) = “Mary”

But you can only Add or Remove the elements in a collection. There is no “update” or “change” method.

If you want to iterate over all of the elements in a collection, use the For Each syntax:

For Each student As String In myStudentColl
Debug.WriteLine(student)
Next student

VSTO presents technical traps for the unwary right from the initial installation. You must install Visual Studio.NET 2003 first because VSTO requires some internal components of VS.NET. Then, you should install Office 2003 next so the VSTO install can configure itself using those systems. Finally, you install VSTO last. If you do it in the wrong order, VSTO very likely won’t work.

Once you get VSTO working, you discover more technical traps.

Although VSTO gives you full access to the Word and Excel object models and IntelliSense statement completion for those models, the IntelliSense suggestions for VSTO might not work with the IntelliSense suggestions for VB.NET and this can lead to some confusion. For example, in the example “Hello About Visual Basic” program below, you might try assigning the color Red to the text in the Excel spreadsheet with a statement like this. (I did.)

myRange.Font.Color = System.Drawing.Color.Red

Intellisense suggests methods and properties for both the left and right sides of the statement. No syntax errors are created and when you run the code, no errors are shown. But it doesn’t work. The problem is that the left side is the Excel object model and the right side is the VB.NET object model. And when a run time error is generated by VB.NET, Excel COM (which is actually in control and calls the VB.NET Assembly) just ignores the error.

It’s like being at a party with both English and Americans. If someone says, “I’ve got rocks in my boot and I can’t raise my bonnet!” You still don’t know for sure whether the subject is automobiles or wearing apparel. Furthermore, both sides of the conversation are very polite and nobody speaks up and says, “Hey! I’m not sure I understand that.”

Here’s a very simple “Hello About Visual Basic” application built with VSTO and Excel just to give you a flavor of how VSTO works. When you run it, you get the result shown when you click Here. Click the “Back” button in your browser to return.

This example, by the way, is an adaptation of an example for VSTO provided by Microsoft MSDN but spiced up a little to show the manipulation of properties and Range selections. Notice also that the VSTO code is enclosed in a Try … Catch block. That’s the only way you can detect an error with VSTO - even in Debug mode. Although this code is left justified here, copy and paste it into Visual Studio .NET and it will be formatted correctly.

Imports System.Windows.Forms
Imports Office = Microsoft.Office.Core
Imports Excel = Microsoft.Office.Interop.Excel
Imports MSForms = Microsoft.Vbe.Interop.Forms
‘ Office integration attribute.
‘ Identifies the startup class for the workbook.
‘ Do not modify.

"OfficeStartupClass,Version=1.0,Class=ExcelProject1.OfficeCodeBehind")>

Public Class OfficeCodeBehind
Friend WithEvents ThisWorkbook As Excel.Workbook
Friend WithEvents ThisApplication As Excel.Application

#Region “Generated initialization code”

‘ Called when the workbook is opened.
Private Sub ThisWorkbook_Open() _
Handles ThisWorkbook.Open
‘ Visual Basic
Dim str As String
str = “About Visual Basic”
Dim mySheet As Excel.Worksheet
Dim myRange As Excel.Range
Try mySheet = _
CType(Me.ThisApplication.Sheets.Item(1), _
Excel.Worksheet)
CType(mySheet.Cells.Item(2, 2), Excel.Range).Value _
= “Hello From”
CType(mySheet.Cells.Item(3, 2), Excel.Range).Value _
= “About Visual Basic”
myRange = mySheet.Range(”B2:B3″)
myRange.Font.ColorIndex = 3
myRange.Font.Bold = True
myRange.Font.Size = 18
Catch ex As Exception
MsgBox(”something didn’t work: ” & ex.Message)
End Try
End Sub
End Class

After all this, you might think that VSTO should be avoided at all costs. Not at all. Like nearly every new Microsoft technology, the rough edges in version 1 will get smoothed off in later versions until it shines like a pearl. And it does work today! Now is the time to start your transition if you have existing VBA code, or to start learning the technology. This one is a keeper.

The secret to Microsoft’s success has often been rolled up into one phrase, “They own the desktop!” By that, people mean that the terrible trio of Windows, Office, and Internet Explorer are what most people use on their desktop computers. None of this happened quickly or by accident. It happened because Microsoft has followed a long term architecture for their software that emphasized integration and the ability to develop cross-platform applications.

In practice, Microsoft’s successful architecture model has meant

* A version of Visual Basic (VB 6, VBScript, VBA)
* COM components
* Windows

But when Microsoft introduced .NET, everything changed.

Bill Gates was quoted at the time as saying that they had “bet the company” on .NET and that’s no exaggeration. If .NET had failed, Microsoft itself might have failed as well.

One of the things that changed was COM. (COM used to mean “Component Object Model”, but the technology has expanded so much that a description that limiting is just inaccurate … so it just means “COM” today.) .NET has replaced COM and it’s reliance on the Registry as a central catalog of what is on your computer and how to use it.

Except … for Office.

Office, even the latest version, Office 2003, still depends on COM. And it still uses good ol’ Visual Basic 6 as the software base. (Well … technically, VBA 6.3, but the differences aren’t that great.) Microsoft was willing to “pull the rug” out from under all of the professional developers with .NET … but not their desktop users. The problem is that Office just makes too much money and not even Microsoft could take that much risk all at once.

If you work through the About Visual Basic Complete Course up to this lesson, you can consider yourself “promoted” to Intermediate Programmer. There is nothing that illustrates the difference between the “Hello World” level of programming and higher levels of ability more than understanding how to work with Arrays and Collections. There is a huge world of tricks and techniques that we can use once we understand this key part of VB.NET.

The subtitle of this lesson, “the next best thing to a database” is actually only partly true. You can get a real feeling for what a database does by studying how arrays and collections are used, but they’re really targeted at different requirements.

A database is for storing huge amounts of information where the relationships between things are critical. If “automobile” is one type of data in the database and “person” is another, then “person owns automobile” is a relationship. That kind of thing would be difficult to do with arrays and collections.

While reading this chapter, you might want to remember the things that were covered in Chapter 7, Using Loops and Timers. The main reason for using arrays and collections is to use iterative processing with them, that is, process them with various types of program loops. (The text used in this course covers a new one, For Each, that is designed just for collections.)

Clever programming techniques involving arrays generally fall into the category of manipulating the array indexes. In this lesson, I’ll show you an example that goes “Beyond the Book”.

The programming techniques for collections, however, are mainly in defining (or discovering) collections with useful properties and methods. If you just want to keep track of a set of values, use an array. But if each value has attributes (properties) or actions (methods) associated with it, use a collection. The course text book covers an important collection, the collection of objects on a Form, but as you advance in your programming skill, you’ll discover that .NET and systems written to work with .NET are all filled with collections to add performance and power to the systems you build.

When coding a loop, the condition that controls whether the statements inside the loop are executed again can be:

* While
* Until
* To (in: For counter= start To end)

Virtually any program statements can be inside the loop (including more looping statements). The next chapter (which covers program debugging) in the Complete VB.NET Course (see above) shows you a debugging statement that the book doesn’t cover, Debug.WriteLine, that will help you understand what the loop does.

The While and Until conditions that control whether the statements inside the loop are executed again can be found either at the beginning of the loop or at the end.

The code you would use is shown below.

The While and Until conditions that controls whether the statements inside the loop are executed again can be found either at the beginning of the loop or at the end. In other words, you can code:

Do While condition… Loop

or

Do … Loop While condition

But you can’t have the condition at both the beginning and at the end.