In this article we’ll be creating a class to generate CAPTCHA graphics that you can use on web sites to help authenticate users as being human and not an automated process.

What Is CAPTCHA

CAPTCHA is an abbreviation for Completely Automated Public Turing test to tell Computers and Humans Apart. This method uses images of words or numbers that are, in theory, distorted and jumbled enough so that an optical character recognition program can’t read them but a human should be able to do so easily.

I’m not a big fan of this method myself since I think it interferes with the user experience. However, there is plenty of demand for them to be placed into systems that interact with the public on the Internet.

The CAPTCHA Class

You can download the CAPTCHA class source code here.

This class is a simple one that builds a 5 character numeric string and places it on a grid background with random ‘noise’. Our properties include the height, width, and font along with the randomly generated value between 10000 and 99999 and the matching bitmap. The new method is available as a parameterless version for subclassing and one that allows you to pass in the height, width, and font.

The core routine is the GenerateNewCaptcha shown here:

    Public Sub GenerateNewCaptcha()
        If _captchaFont Is Nothing OrElse _captchaHeight = 0 OrElse _captchaWidth = 0 Then
            Exit Sub
        End If
        _captchaCode = RandomValue.Next(10000, 100000).ToString
        _captchaImage = New Bitmap(_captchaWidth, _captchaHeight)
        Using CaptchaGraphics As Graphics = Graphics.FromImage(CaptchaImage)
            Using BackgroundBrush As New Drawing2D.HatchBrush(Drawing2D.HatchStyle.SmallGrid, Color.DimGray, Color.WhiteSmoke)
                CaptchaGraphics.FillRectangle(BackgroundBrush, 0, 0, _captchaWidth, _captchaHeight)
            End Using
            Dim CharacterSpacing As Integer = (_captchaWidth \ 5) - 1
            Dim HorizontalPosition As Integer
            Dim MaxVerticalPosition As Integer
            For Each CharValue As Char In _captchaCode.ToCharArray
                MaxVerticalPosition = _captchaHeight - Convert.ToInt32(CaptchaGraphics.MeasureString(CharValue, _captchaFont).Height)
                CaptchaGraphics.DrawString(CharValue, _captchaFont, Brushes.DimGray, HorizontalPosition, RandomValue.Next(0, MaxVerticalPosition))
                HorizontalPosition += CharacterSpacing + RandomValue.Next(-1, 1)
            Next
            For Counter As Integer = 0 To 24
                CaptchaGraphics.FillEllipse(Brushes.DimGray, RandomValue.Next(1, _captchaWidth), RandomValue.Next(1, _captchaHeight), RandomValue.Next(1, 4), RandomValue.Next(1, 4))
            Next
            For Counter As Integer = 0 To 24
                CaptchaGraphics.FillEllipse(Brushes.WhiteSmoke, RandomValue.Next(1, _captchaWidth), RandomValue.Next(1, _captchaHeight), RandomValue.Next(1, 4), RandomValue.Next(1, 4))
            Next
        End Using
    End Sub

Let’s look at some of the details of this routine.

First, notice that we’re generating random numbers in several places, most notably to generate the main code value. We also use random numbers to place the numbers and the noise bits.

The HatchBrush object is used to draw the grid background. This style could be changed to a different pattern. There are several variations you could try to get a unique effect. You could even randomize the background.

The characters from the randomly generated number are drawn onto the graphic one character at a time and are randomly placed along the vertical axis and slightly off kilter on the horizontal one.

The FillEllipse method of the Graphics object is used to create the noise at 50 different random points on the graphic. These little marks help obscure the actual characters from OCR’s and sometimes from humans as well.

Using the Class

Using the class is simple. You just create the class, display the graphic from it and verify user input against the value stored in the class. You can also regenerate the value if the user requests it. Remember that you will need to save the generated bitmap to disk in order to display it to a web user in an ASP.NET application.

More You Can Add

There are several things you could add to this class to enhance it. You could:

- Add the ability to accept strings
- Add the ability to dynamically size the strings and the resulting bitmap
- Add more distortion by using Graphics method to twist the output
- Add more background noise options

That’s all for this example. Let me know if you have any questions or observations by this example by leaving me a comment.

As a follow-up to my previous article, How To Create Application Plug-ins In VB.NET, Karl Stoney asked for a more complete example. Hopefully this update will help.

Tips and Tricks

One trick you can use to make your development of these plugins easier is to have multiple projects in your solution. In the case of the demo app I added the main demo project, the interface project, and the two plugin projects to the solution. If I wanted to have another plugin, I would just add it to this solution. This makes debugging easier and saves system memory somewhat vs. running separate instances of Visual Studio

Another trick is to change the compile output folder to a common folder. This puts all of the executable in the same folder, once again for easy debugging. Remember that your plugins when deployed must be in the same folder as the calling application.

The Demo

In this code example, we have a PluginDemo application that can call various plugins that conform to the IMyPlugIn interface. We also have a PlugIn1 and a PlugIn2 projects that implement the interface in different ways. PlugIn1 uses a standard message box while PlugIn2 uses a custom form.

The core code itself isn’t any different from the code presented in the previous article. The LoadPlugIn routine is the key to using Reflection to load the plugin. To get a better understanding of how it all comes together I recommend stepping through the process as it runs.

The zip file contains the project code but I excluded the executables. After unzipping the project you will need to first build the PlugInInterface project by itself. This will create the DLL that the other 3 projects need to reference. Once you’ve done this, do a Build Solution and it should be ready to run.

Here’s the demo zip file: VB.NET Application Plugin Demo

Let me know if you have any questions about this demo or application plug-ins in VB.NET.

I took about a week hiatus from VB Notebook For .NET while I was working on my other, general topic, blog, OpTempo, and another yet-to-be-released web project but I’m back working on this site now. I just need to figure out a good way to do ‘re-runs’ the next time I take a break or work on other projects.

Coming Up This Week

I’ve got my follow-up article on coaching that I should publish this week as well as a few follow-up and new article and demos. If you have a topic you would like for me to cover, let me know in a comment or email.

Previous Installments: #1,  #2,  #3,  #4 , #5

Feel free to add a comment with your answers. Try to answer them before looking at the comments or searching MSDN or Google for an extra challenge.

True Or False

1. Base-class constructors are not inherited by derived classes.

2. A class may only implement a single interface.

3. A checkbox may have either a square or circular appearance.

4. HttpSessionState can only store string values.

5. A page object’s IsPostBack property is used to determine if the page is being loaded due to a postback. 

General VB.NET Questions

1. Should you throw exceptions in the Finally block? Why or why not?

2. How do you create a scrolling region on a form?

3. What are some differences between CType and DirectCast?

4. Should you use a "sp_" prefix on SQL Server stored procedures? Why or why not?

5. If you have an ASP.NET application with a Master Page how can you change meta data from child pages?

Tough General Interview Questions

1. How do you think your previous experience will help you perform your work here?

2. Would you say that you’re a competitive person? Why or why not?

3. Why did you decided to get a degree in [job candidates college major]?

4. Why do you want to work at [insert company name here]?

5. Give an example of how you applied creativity in your current/former job?

Open Ended Questions

1. Describe what you consider to be best practices for creating a testing environment.

2. You are given the task of developing an interface to a vendor’s web service. The documentation is very minimal for it and may be outdated. What approach would you take to developing this interface? 

Have fun with these and let me know what you think about them by leaving a comment or answering the questions.

One problem some programmers new to VB.NET and object oriented programming in general have is understanding interfaces and how they related to classes. In this article, we’ll take an introductory look at interfaces and some of the ways you can use them in your VB.NET applications.

What is an Interface?

To put it in simple terms, an interface is a definition of methods and properties. Sometimes this is referred to as a ‘contract’. If a class agrees to implement an interface it must implement all of the properties and methods defined.

One difference you’ll see in an interface vs. a class is that there is no code, only the templates, aka contracts, for the properties and methods. You’ll also notice that there is no access level defined. It’s always considered public.

Here’s an example interface:

Public Interface IPerson

    Property ID() As Integer

    Property FirstName() As String

    Property LastName() As String

End Interface 

This means that if a class implements the IPerson interface it will have to implement these routines. Here’s an example of a class implementing this interface:

Public Class Customer    Implements IPerson

    Protected _id As Integer
    Protected _firstName As String    Protected _middleName As String
    Protected _lastName As String

    Public Property ID() As Integer Implements IPerson.ID
        Get
            Return _id
        End Get
        Set(ByVal value As Integer)
            _id = value
        End Set
    End Property

    Public Property FirstName() As String Implements IPerson.FirstName
        Get
            Return _firstName
        End Get
        Set(ByVal value As String)
            _firstName = value
        End Set
    End Property

    Public Property MiddleName() As String
        Get
            Return _middleName
        End Get
        Set(ByVal value As String)
            _middleName = value
        End Set
    End Property

    Public Property LastName() As String Implements IPerson.LastName
        Get
            Return _lastName
        End Get
        Set(ByVal value As String)
            _lastName = value
        End Set
    End PropertyEnd Class 

As you can see, each of the properties above, except for MiddleName, has an Implements statement that defines how it will fulfill the Interface contract. The rule is that you can add to the interface inside the implementing class but you can’t take away.

Remember that implementing an interface isn’t the same as creating an instance of a class or creating a subclass. All you’re doing is defining how the external interface should look, not what goes on inside. People do get confused over that point.

Coding Interfaces

Interfaces can be very simple or complex. Most current OOP thought suggests that interfaces be limited to a single method. For example, you might have an IUpdate interface that defines a single Update function and you might have another interface called ICreate that defines a single Create function. You would then combine them into classes that needed to implement them, as in this example:

Public Interface ICreate
    Function CreateNew(ByVal id As Integer) As Boolean
End Interface

Public Interface IUpdate
    Function Update(ByVal id As Integer) As Boolean
End Interface

Public Class Customer
    Implements IPerson, IUpdate, ICreate

As you can see, a class can implement multiple interfaces. Whether it’s better to design with a lot of different interfaces or to group them into logical sections is really up to your own needs. My own take is a bit of a compromise in that I keep them simple with just a few tightly related methods or properties but I don’t religiously limit each interface to a single item.

Another use for interfaces is in defining a common interface for a plug-in architecture as I mentioned in this previous article: How To Create Application Plug-ins In VB.NET. In this case, you will want to have a more complex interface design in most cases since your main app will need a stronger connection to the plug-in.

Do you have any questions about using Interfaces in VB.NET? Please feel free to leave a comment and ask about it.

Previous Installments: VB.NET Interview Questions #1, VB.NET Interview Questions #2, VB.NET Interview Questions #3, VB.NET Interview Questions #4

Feel free to add a comment with your answers. Try to answer them before looking at the comments or searching MSDN or Google for an extra challenge.

True Or False

1. You can access variables declared in the Try block inside the corresponding Catch handler.

2. You don’t need to specify a default value for an optional parameter.

3. When updating a bound control, you should call a DataSet’s Clear method before calling the DataAdapter’s Fill method.

4. When a web form is ready for garbage collection the Unload event is raised.

5. The AdRotator control can be bound to a database table. 

General VB.NET Questions

1. Explain the 3 basic tiers found in a well designed web application.

2. Explain the difference between TCP, UDP, and HTTP data transmissions.

3. When would you want to use "Attach To Process" to debug a .NET application?

4. Describe how you would go about validating a social security number entered by a user.

5. Describe methods you could use to avoid deadlock problems in a multithreaded application.

Tough General Interview Questions

1. What habits in other programmers do you find most annoying?

2. How much time do you devote on a monthly basis to improving your skills?

3. Do you see yourself in a management role in the future?

4. Why did you choose programmer as a career?

5. What do you think is important in determining how well you will function with a team of programmers?

Open Ended Questions

1. What criteria would you use to determine if a particular program should be written as a web based ASP.NET application or as a WinForms application?

2. If you needed to create custom web applications for each of a company’s clients that could be quickly brought online and modified as needed what are some of the things you would consider in your design?

Have fun with these and let me know what you think about them by leaving a comment or answering the questions.

Here’s a video tour by the guys who did the Weird US series on the History Channel. It’s a fun video. Watch it and see if your VB6 app has something in common with this house.

I’ve been working hard on my new "anything goes" speed blog, OpTempo, but I’m trying to keep the quality up here as well. I may not post quite as frequently here over the next few weeks, but I’ll make every post count. I’ll at least have one general programming article and two tutorial or code example articles a week plus my weekly VB.NET Interview Questions and Link Round-Up columns.

Most Popular Posts

Here are the 10 most popular posts of the week:

Should You Pursue a Career In Programming?
3 Handy VB.NET String Functions You Can Use
VB.NET Interview Questions #3
Practice, Practice, Practice
How To Pass Data Between Forms in VB.NET
How To Update Controls Using BackgroundWorker in VB.NET
3 More Useful VB.NET String Functions
Introduction to Nullable Types in VB.NET
System.Net.Mail How To
VB.NET Interview Questions #1

Coming Up Next Week

With any luck I’ll publish my follow-up article on coaching on Monday. I also have an overview article on Interfaces that someone requested just about ready as well. If you have a topic you would like for me to cover, let me know in a comment or email.

Once you have data in a generic List or Dictionary you may find that you need to sort it into the order you need. This is fairly easy if you’re using simple data types since .NET provides default comparers but it can get a little trickier if you need to sort objects. In this article we’ll look at how to use Comparer Delegates to do this.

What is a Comparer Delegate?

A comparer delegate is a routine that is used to compare two objects. It returns a 1 if the value of the first object is greater, -1 if the value of the first object is lesser, and 0 if the objects are equal. Since we’re working with objects we can compare multiple values in the two objects to determine which is greater than the other.

Code Example #1

In this example we’ll look at sorting PointF coordinates by their distance from 0,0. First, let’s load up our list and call the Sort method with our comparer that we’ll write in a moment.

Dim CoordinateList As New List(Of PointF)(New PointF() {New PointF(14, 22), New PointF(17, 21), _
                                          New PointF(15, 8), New PointF(15, 20), _
                                          New PointF(16, 7), New PointF(15, 21), _
                                          New PointF(17, 7), New PointF(16, 21), _
                                          New PointF(14, 23)})
CoordinateList.Sort(AddressOf ComparePointF)

Now, let’s code our comparer routine, ComparePointF:

Public Function ComparePointF(ByVal positionOne As PointF, ByVal positionTwo As PointF) As Integer
    Dim DistanceOne As Double = Math.Sqrt((positionOne.X ^ 2) + (positionOne.Y ^ 2))
    Dim DistanceTwo As Double = Math.Sqrt((positionTwo.X ^ 2) + (positionTwo.Y ^ 2))
    If DistanceOne > DistanceTwo Then
        Return 1
    ElseIf DistanceOne < DistanceTwo Then
        Return -1
    Else
        Return 0
    End If
End Function

Here we’re using the Pythagorean distance formula to determine the distance from 0,0 for each point and then comparing the results. The List object handles all of the sorting internally so the performance is quite good.

Code Example #2

In this example, we have an invoice object where we’re wanting to sort the objects first by customer type and then by the total amount of the invoice. Here’s what our comparer delegate would look like:

Public Function CompareInvoices(ByVal invoiceOne As Invoice, ByVal invoiceTwo As Invoice) As Integer
    If invoiceOne.CustomerType > invoiceTwo.CustomerType Then
        Return 1
    ElseIf invoiceOne.CustomerType < invoiceTwo.CustomerType Then
        Return -1
    Else
        If invoiceOne.Total > invoiceTwo.Total Then
            Return 1
        ElseIf invoiceOne.Total < invoiceTwo.Total Then
            Return -1
        Else
            Return 0
        End If
    End If
End Function

As you can see in this function, we first compare the customer type, then the total amount. Of course, you could make this even more complex for your sorting situations. All you have to keep in mind is your integer return value.

I hope these examples have been helpful to you in learning how to use the comparer delegate. If you have any further questions or observations about this subject, please feel free to leave a comment.

Careers

I did run across a few good career related links though, such as this one on Tech Republic: Write a resume that will land you a programming job. It has some very detailed tips on how to write a resume that will get you an interview.

Also, on the career front, there was this good article by Rob Walling called Q & A on Leaving Management for Development. It’s a follow-up on an earlier article he had written on this topic but it has good info all on its own. Also check out the rest of his site for more good stuff.

Architecture and Methods

I found this article, How To Tell If You’re Doing Agile Right, by Ryan Cooper. I think he does a good job of making the business case for Agile development although I’m not sure if that’s what he intended to do.

Niclas Nilsson wrote this piece on Top Ten Software Architecture Mistakes that’s pretty good. Actually he’s just condensing what Eoin Woods had said in this longer, 2 part, article, Avoiding the Icebergs.

Programming

Saptarshi Purkayastha applies a little Eastern philosophy in this article, Programming Lesson: You Are The Bug…. He’s working on some follow-up articles with the same kind of theme so check back with him later as well.

That’s all the links for this week. As always, let me know of any interesting .NET or general software development links by leaving me a comment or dropping me an email.