VB .NET

Automating SQL Server 2000 based database generation with OSQL in .NET

Stacy Vicknair — Fri, 14 Aug 2009 16:55:14 GMT

This week I had a need for NUnit based unit testing against a class that depended on a provided SqlConnection. Up to this point I had been able to mock external objects and their behavior based on interfaces, but with a SqlConnection I could not mock. There are some options for mocking the SqlConnection such as TypeMock, but I needed a realistic connection to test against. This also proved as a good method for building the expected DB interface.

The solution that worked best for my environment (only SQL Server 2000, all machines have OSQL) was to execute an OSQL process from my TestFixtureSetUp that executed a .sql script I had already made for building the database. So my TestFixtureSetUp looked like this:

<TestFixtureSetUp()> _
Sub FixtureSetUp()
    Dim p As Process = Process.Start("OSQL.exe", "-E -S SERVER -i ""../SQL SCRIPTS/setup.sql""")
    p.WaitForExit()
End Sub

The script itself was quick and assumed that the database and procedures existed already. It deleted all entries from the table and then added some dummy values. However, this method could be used to create the entire DB if needed, but does have the strong assumption that the computer using it has OSQL installed.

I won’t go into much detail about OSQL. OSQL is a tool that comes with SQL Server Tools that allows execution of sql batch scripts from the command-line. Its usage is explained well in the MSDN.

Technorati Tags: OSQL,database generation,NUnit,unit testing,sql server 2000

List of influential VB’ers on Twitter

Stacy Vicknair — Wed, 01 Jul 2009 21:04:45 GMT

Antonio Chagoury, VB MVP, has constructed a list of Twitter accounts for VB MVPs, VB Team members, and others who are influential in the VB.NET community on his personal blog, CTO v2.0. This list has many great people who are not only talented in VB, but also who have great talents in many aspects of the .NET framework.

I’m listed as a VB MVP, but if you don’t want the full list you can still check me out at http://twitter.com/svickn. However, I’d recommend checking out the rest of these guys too, you might find someone you would never have thought to follow that you mesh with. Besides, it’s never a bad thing when .NET help is just a tweet away ;)

http://www.cto20.com/post/Tweeps-List-Microsoft-Visual-Basic-MVPe28099s-and-Influencers.aspx

Technorati Tags: VB.NET,Twitter,.NET

How To: Create a plugin architecture in VB.NET

Stacy Vicknair — Wed, 06 May 2009 18:19:35 GMT

Creating a plugin architecture in .NET can be achieved in a few steps using the .NET framework. All it takes is a little time, a common interface and reflection. In this blog we’re going to look at how to make a simple plugin that performs basic integer calculations. As a disclaimer, this method is not CLS compliant. If that is necessary for you, then stick around and I hope to have a new version that maintains compliance posted.

The code in this blog is mostly illustrative, and the full code is available on CodePlex at the following link:

http://wtfnext.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=27051

Setting up a common interface

Our main console application has to know just basic things about our plugin. It doesn’t need to know any more about it than that it complies to an expected interface. For this example, our plugins must:

Expose a class named Plugin
The class must implement our common interface: IPlugin.
The plugin must end in “Plugin.dll” and be present in the application directory.

If we get all of these done, we can connect to the plugin successfully. The first step is to define the IPlugin interface, which acts as the basic contract between any plugin and the console application. We’ll place this in its own project to compile into a separate DLL, so that we can easily reference it from our plugin projects.

Public Interface IPlugin
    ReadOnly Property Name() As String
    ReadOnly Property ActionName() As String
    Sub Calculate(ByVal value1 As Integer, ByVal value2 As Integer)
End Interface

Consuming the interface according to our rules

So our calculation plugins will expose the name, what their action is and a calculate function that operates on two values. We can create an example plugin that performs addition:

Public Class Plugin
    Implements IPlugin

    ReadOnly Public Property Name() As String Implements IPlugin.Name
        Get
            Return "Addition"
        End Get
    End Property

    ReadOnly Public Property ActionName() As String Implements IPlugin.ActionName
        Get
            Return "Add Values"
        End Get
    End Property

    Public Sub Calculate (ByVal value1 As Integer, ByVal value2 As Integer) Implements IPlugin.Calculate
        Dim result As Integer = value1 + value2
        MessageBox.Show ("The result is " + result.ToString)
    End Sub
End Class

See how we named the class that implements the plugin as just Plugin? This is because this is what the consol application expects. We can have other classes and whatnot in our plugin that do the meat of our work, but the application that consumes the plugin only cares that the possible plugin follow our rules stated earlier.

Checking and consuming the plugin

In our console application, all we’ve got to do is grab our possible plugins, then check their validity. Once we’re sure it is valid, we can consume it via the interface.

Dim asm As Assembly = Assembly.LoadFrom(possiblePlugin)
Dim myType As System.Type = asm.GetType(asm.GetName.Name + ".Plugin")
Dim implementsIPlugin As Boolean = GetType(IPlugin).IsAssignableFrom(myType)
If implementsIPlugin Then
    Console.WriteLine(asm.GetName.Name + " is a valid plugin!")

    Dim plugin As IPlugin = CType(Activator.CreateInstance(myType), IPlugin)
    Console.WriteLine("{0}: {1}", plugin.Name, plugin.ActionName)
    plugin.Calculate(5, 4)
End If

Wrapping things up

Well, this was a quick and dirty look at implementing your own plugin architecture into your application. Please leave feedback or questions. I’d be happy to hear both!

Technorati Tags: VB.NET,Plugin,architecture

.NET Tip: Using String Constructors

Stacy Vicknair — Mon, 04 May 2009 14:31:37 GMT

When we use string so often for its value-like behavior, it is easy to forget that the String class comes with its own constructors, and that there are some tasks you can achieve with the string constructor that you might have overlooked otherwise.

Repeating characters

One of the more useful overrides of the String constructor is the ability to easily repeat any character a number of times. Here’s a brief example:

Dim horizontalRule As New String("-"c, 100)
Console.WriteLine(horizontalRule)

Subsections of Char arrays

If you’ve got a Char array you can grab a subsection by specifying a start point and a length:

Dim catchyPhrase As Char() = CType("Catch for us the foxes.", Char())
Dim phrasePart As New String(catchyPhrase, 0, 12)

Console.WriteLine(phrasePart)

Other pointer based operations

There are a few more useful constructors if you are developing in C# or C++ that make use of arrays, but because Visual Basic doesn’t allow for the use of unsafe types I won’t go over them. You can check out the remaining constructors on the MSDN at the link below.

There are many useful features in .NET that can be easily overlooked, but in the long run you might find something that would have otherwise saved you time.

http://msdn.microsoft.com/en-us/library/system.string.string.aspx

Technorati Tags: VB.NET,String,MSDN

How NUnit and TDD helped me today

Stacy Vicknair — Wed, 11 Mar 2009 21:26:14 GMT

My work environment is usually an anything goes, wild west of development sort of place. There are no rules imposed, just a “get things done” attitude. Because of auditing, source control was a necessity that got added to the mix. We use SVN through VisualSVN Server and TortoiseSVN as a client.

Well, as a part of self improvement and to produce better more reliable code, I’ve taken up learning TDD for myself. Our current methodology of testing here is based mostly on WTFs per minute and copious prayer. This time around, I’m trying super scoffable alternative: automated testing and continuous integration. Tests better than no tests? pshaw.

So, when trying to read resources on TDD, getting started always seemed difficult. I even tried the book TDD By Example to see if that would help, but it seemed sluggish to read along and try these minute tests that don’t apply to my real world applications. I started trying to integrate TDD in a small project for work instead.

As a result, I can say I’m experiencing the benefits of TDD already. When I refactor or write new code, I’m confident that I’m doing it for a reason. If the tests fail, I know what exactly is failing and can isolate it.

Today, while writing tests, I somehow created a never-ending loop in code (must’ve been evil code fairies I swear.) This gave me my first problem with my TDD experience: How do I debug code for a partially constructed application, when all I’ve got to go on is that I know it doesn’t work?

Well, here’s what I was able to do.

Added a new console app project to the solution called Testing.Debug
Extracted my unit test and put it as the sole code in the console app.
Added a break point where I knew my problem was happening.

I knew the where, but I couldn’t discern the what. After running the small testing app I found it quickly and fixed the problem.

So my question to those of you who do TDD often, how would you handle the situation? How do you handle situations that might call for a debugger?

Technorati Tags: TDD,NUnit,SVN,debugging

Head First Design Patterns – VB.NET code examples on CodePlex

Stacy Vicknair — Fri, 30 Jan 2009 16:24:09 GMT

For those of you looking to get started with design patterns but reluctant because of language barriers, I started a project on CodePlex for the Head First Design Patterns book. The original code examples are in Java, and they have been made available in C# and C++ as well, which are all available on the book’s online page, http://www.headfirstlabs.com/books/hfdp/.

Currently the project is only Chapters 1-8, but pending the big game on Sunday I will be finished up sometime next week. This is one of my first CodePlex contributions, so any helpful hints or suggestions would be much appreciated. Otherwise, go ahead and get the source and start looking into design patterns. I definitely recommend getting the book and definitely check out the entire Head First series!

Get the VB.NET code examples here:
http://www.codeplex.com/HFDPinVB/

Get more info on all the Head First books:
http://www.headfirstlabs.com/

Technorati Tags: VB.NET,Head First Design Patterns,Code Examples

Passing the 070-536 Revisited

Stacy Vicknair — Tue, 20 Jan 2009 15:27:39 GMT

So, yesterday I passed the 070-536, and I wanted to revisit my list of helpful insights. I wanted to add a couple new insights to the mix in particular. Here are the additional insights, and these will probably remain steadfast for all .NET exams:

Go in with a deep understanding of core operations. If something is often used or is referenced in the training kit, get a really good grip on it.
Isolate the differences in each answer. Look at what could be wrong, and use your best judgment.
Finally, remember that .NET is meant to help tasks be easy to code! Sometimes the easiest solution really is the right solution.

I hope that these vague tips can help you, because they touch on the core knowledge when it comes to testing. Be good at .NET and know the subject, but also don’t panic and be a good tester.

The old blog was posted at this link:

Click To View Entry

Technorati Tags: 070-536,Microsoft Certification

Looking at regular expressions, behind and ahead.

Stacy Vicknair — Sat, 17 Jan 2009 18:37:44 GMT

This post is mostly inspired by a question I came across in the MSDN forums. Basically, say we had a set of data in a string that looked something like this and we just HAAAAAD to use regular expressions to get the info out (I’m insinuating maybe string.split would work better in this situation…)

Dim dataToSearch As String = "-Cat-Dog-Meese-Chardonnay-"

Well, the pattern is simple right? Just throw in a regex for "-[A-Za-z]+-" and we’re good to go.

Dim reg As New Regex("-[A-Za-z]+-")

For Each m As Match In reg.Matches(dataToSearch)
    Console.WriteLine(m.Value)
Next

However, we get this.

So what happened? Well, The regex doesn’t catch overlapping results, so we’re just left with our Cat and Meese (the obvious plural of mice). Is there something we can do in this case? Yep. This is where we start looking around.

In regular expressions, just like crossing the street, you can look both ways (although for crossing the street, you ought to. You might not need to for RegEx). Looking ahead is like trying to peek around traffic when the interstates stops. You know what you are doing, but you need to know what’s happening further down the line that might influence you.

So, if we want to look ahead from our first term without actually consuming the dash, this will allow us something like this:

Dim dataToSearch As String = "-Cat-Dog-Meese-Chardonnay-"

Dim reg As New Regex("-[A-Za-z]+(?=-)")

For Each m As Match In reg.Matches(dataToSearch)
    Console.WriteLine(m.Value)
Next
Console.ReadLine()

And our result becomes:

Hoorah! We’ve got all the terms now. So let’s look at what we’ve changed. Instead of just a dash after our [A-Za-z] now we’ve got (?=-). What this is saying is that we don’t want to consume this value, but our regex ought to have a dash afterwards. Say we wanted to work this differently and instead say we want to end on any non [A-Za-z] instead we could do (?![A-Za-z]) and we’d get the same result. This is a negative lookahead, and is simply just looking for what we don’t want to find instead of what we do.

Well, what about that first dash? I don’t really care for it either, so let’s look and a look behind to get rid of it. Keeping with our example, you might compare this to looking in the rearview mirror to make sure you aren’t being followed.

Dim dataToSearch As String = "-Cat-Dog-Meese-Chardonnay-"

Dim reg As New Regex("(?<=-)[A-Za-z]+(?=-)")

For Each m As Match In reg.Matches(dataToSearch)
    Console.WriteLine(m.Value)
Next
Console.ReadLine()

Now our results are nice and clean (except maybe the dog and our chardonnay that is in mixed company…)

So what is different about a look behind? Now, we’re looking at what comes before our area of interest. And since we aren’t consuming it, just saying that the dash better be there, it isn’t a part of the result!

On a similar note to looking ahead, we can also do a negative lookbehind by using (?<![A-Za-z]).

So that concludes our quick look at regular expressions, from all angles. I hope you found these examples enjoyable, and for more information be sure to check out these helpful links:

http://www.regular-expressions.info/lookaround.html

http://social.msdn.microsoft.com/Forums/en-US/regexp/threads/

Technorati Tags: Regular Expressions,VB.NET

WindowsClient.NET How Do I Videos for WinForms

Stacy Vicknair — Fri, 02 Jan 2009 21:19:45 GMT

As you may know, I do mostly WinForms development at my current position. Altogether, I do have an affinity for WinForms development over web development, mostly because simple websites were easy to make when I was young, but making a windows application was something I didn't do until much later on.

Well, WindowsClient.net is a great Microsoft resource for those interested specifically in smart client applications, and the even better news is that the bulk of the videos for WinForms in particular are done by Pat Torney of FourSquare Solutions Inc and in VB.NET!

To be honest, one of the major frustrations I have with beginner's programming books is that they almost never talk about deployment. They will let you be dazzled by how easy your first XYZ app was to make, but then they never let you know how you can email a setup to grandma and have it work out just fine.

Thankfully, Pat's got you covered with the How Do I: SmartClient Deployment video. I really cannot express how thankful I am to now have an easy to reference video that I can tell others to check out when they get started with VB and want to deploy their masterpiece in an installer instead of ClickOnce.

I've been perusing the videos and I'm thankful for Pat's work. He also includes helpful hints along the way and keeps it interesting with a bit of humor.

SmartClient Deployment:
http://windowsclient.net/learn/video.aspx?v=14636

All the WindowsClient.net videos:
http://windowsclient.net/learn/

Also, you might find the full VB.NET learning library a good investment:
http://msdn.microsoft.com/en-us/vbasic/ms789086.aspx

Technorati Tags: WinForms,Windows Client,Deployment

Free VB Coding Standards Reference Document

Stacy Vicknair — Mon, 22 Dec 2008 20:46:59 GMT

Clint Edmonson over at http://www.notsotrivial.net put together a collection of language specific coding standards reference documentation. This is a great starting point for your organization or a good resource to evaluate your current standards.

View the article and get the goods here:

http://www.notsotrivial.net/blog/post/2008/12/Holiday-Goodie-Bag-Free-C-and-VB-Coding-Standards-Reference-Documents.aspx

Technorati Tags: coding standards,VB.NET,C#.NET