Usually everything will go smoothly, that is until you want to accept an empty string as input. The InputBox returns an empty string when the user hits the Cancel button, so how can you tell the difference between Cancel and OK with a blank string?

Well here’s a neat trick. I tested this to work in VB.NET 2005, but I’m sure it’ll work in other versions.

Dim ret As String
Dim dlgRes as DialogResult

ret = InputBox("Input a value:", "Input")
If ret Is String.Empty Then
    dlgRes = DialogResult.Cancel
Else
    dlgRes = DialogResult.OK
End If

This works because Strings aren’t values, but are instead a reference to a character array in memory. As long as the string is unchanged, only the reference is passed around. InputBox will return String.Empty when you click the Cancel button, and you can check if the return value references the same object by using the Is keyword. If it matches, then Cancel was clicked.

Whenever you click OK, the InputBox returns an empty string, but never the empty string, String.Empty. Even if you try passing it String.Empty as the initial value, the return value is still a reference to a new, different empty string.

That’s it. Easy as pie!

I had a lot of data that I wanted to dump from a wide range of flat text file databases. I already had classes that stored the schema for the tables and some of the formats were weird (i.e. custom date stored as a single), and rather than setting up a bulk insert in SQL Server, I decided I’d just import directly using my classes. They’re optimized to load, cache, and interpret the data but I just needed a way to get it quickly over to the SQL table.

If you have a similar situation or your program is generating a lot of data (over a couple thousand rows) that needs to be dumped into a table, SqlClient.SqlBulkCopy is the way to go.

Slower Methods

Before I used bulk insert, I was using a SqlCommand with parameters (e.g. “INSERT INTO MyTable VALUES (@KeyValue, @Value1, @Value2)“). From what I understand, SQL Server compiles these and so long as the command text doesn’t change (not even character casing), it doesn’t have to compile it again between calls.

While this method was definitely faster than composing an INSERT for each row, I was averaging only a couple or few hundred records a second and I had hundreds of thousands of records.

I got a little performance boost when I waited until the end to add my primary key index, but of course that takes some time depending on the number of rows you have.

With using SqlBulkCopy, my performance jumped tenfold to a couple or few thousand a second. At first I tried caching all the data in a DataTable (about 630,000 records), and the bulk insert at the end took about 25 to 35 seconds. However, the DataTable just ate through memory, taking over a GB when everything was loaded. It would also pause frequently near the end when allocating more memory and causing use of the swap file.

Here’s the code for after the DataTable (dt) has been filled. Also, c represents an open connection, but you can also use a connection string.

Dim bc As SqlBulkCopy
bc = New SqlBulkCopy(c, SqlBulkCopyOptions.TableLock, Nothing)
bc.DestinationTableName = String.Format("[{0}].[dbo].[{1}]", database, tableName)
bc.BatchSize = 1000
bc.BulkCopyTimeout = 300
bc.WriteToServer(dt)
bc.Close()

• BatchSize - Can be the full number of rows, but it seems like performance is a little better when you give the server a chance to process the records as they come in.
• BulkCopyTimeout - The default is 30 seconds. If you have a lot of records you’ll blow past this so make sure to set it higher.
• dt.Dispose(): GC.Collect() – You should consider calling this once you’re done to free up some memory from your DataTable.

Fastest

My final, fastest solution was to create a class that implemented the IDataReader interface and that consumed my data. It would load my data from disk as requested by SqlBulkCopy which was then sent to the server. Memory usage was minimal, maybe from 50 to 70MB according to Task Manager and performance was even better since there was no memory allocation hiccups.

Dim bc As SqlBulkCopy
bc = New SqlBulkCopy(c, SqlBulkCopyOptions.TableLock, Nothing)
bc.DestinationTableName = String.Format("[{0}].[dbo].[{1}]", database, tableName)
bc.BatchSize = 1000
bc.BulkCopyTimeout = 3000
bc.WriteToServer(New RecBaseDataReader(rec, recsToExport))
bc.Close()

• RecBaseDataReader is my custom class. I pass it rec which is used to load data and recsToExport which is a list of records that it can iterate through.
• BulkCopyTimeout - Note that it’s much higher than when we pass in a DataTable because of the extra time that we take loading the data in the IDataReader.

You can set up your IDataReader class any way that works best for you. The following routines are used by SqlBulkCopy and must be implemented. You can just put a Stop in the rest of the routines just in case anyone tries to use them.

• System.Data.IDataRecord.FieldCount – Should return the number of fields in your record.
• System.Data.IDataRecord.GetOrdinal – Should return the ordinal for the given field.
• System.Data.IDataReader.Read – Should advance the read cursor to the next record and load it. Make sure it’s set up so the first call of Read will return the first record.
• System.Data.IDataRecord.GetValue – Should return the value of the column specified by the given ordinal.

Here’s a skeleton implementation: MyCustomDataReader.zip

Notes

• Destination table name is kind of finicky. When I used just the table name, it threw an error so I just went ahead and used the full table name.
• If you have computed columns on your source or destination, you’ll need to set up column mappings to specify which columns should actually be inserted. A straightforward .ColumnMappings.Add(col.ColumnName, col.ColumnName) worked for me. Others have suggested that you can use an intermediate table which provides a little protection if the bulk insert fails for some reason.
• For the method where I loaded all the data into a DataTable, I set up columns and column types, but didn’t set up MaxLength for varchar columns. This caused an error so make sure these are set up correctly. If you’re using a strongly-typed DataTable generated from the destination table you shouldn’t have to worry about this.
• Check out SqlBulkCopyOptions (specified in the constructor) for more settings on things like how identity columns are handled, how null values are copied to the new table, etc.
• Apparently column names are case-sensitive in SqlBulkCopy. I didn’t encounter any issues with this because I was creating the table at the same time I was setting up column mappings so the casing matched anyways.
• Some are saying there’s a bug in .NET 2.0 where a quote character in the column name will prevent you from using SqlBulkCopy so heads up.

2011-07-27 Edit: Uploaded skeleton class as a zip file to avoid 404 error because of “.vb” extension.

However, if you’re just looking for a lightweight way to add a description to your enums, this blog post posits a simple, elegant way to add and use a description. It requires .NET 3.5 or higher since it uses extension methods.

Custom MSBuild targets to the rescue! Just add the following to your project file and it will prevent a publish when the DEBUG constant is defined. Place it at the bottom of your project file right before the </Project> tag. (For an example of editing your project file, see my post on Obfuscating a ClickOnce Publish.)

  <!-- The following makes sure we don't try to publish a configuration that defines the DEBUG constant -->
  <Target Name="BeforePublish">
    <Error Condition="'$(DefineDebug)'=='true'"
           Text="You attempted to publish a configuration that defines the DEBUG constant!" />
  </Target>

By the way, the DEBUG constant is the constant that you use in your code as a compiler constant, for example #If DEBUG Then. It can be found in the ‘Compile’ tab under ‘My Project’ by clicking ‘Advanced Compile Options…’:

Define DEBUG Constant

Edit: It looks like some people have had issues with the way I got things working. I was using a VB.Net forms application in VS2005 (and I think I tested in 2008 as well). The key is to find which constant works best for your situation. Drew Mcpherson says that DebugSymbols worked for him rather than DefineDebug.

If you want even more control, another way of choosing a compiler constant is to define your own. You’ll notice that below the “Define DEBUG Constant” box there is a textbox for defining custom constants. If, for example, you have three configurations, such as Debug, Release, and Publish, you could define a constant on the Publish configuration to prevent any other from allowing a publish.

Here are a couple of great links that I used to figure out the mysteries of the fn key:

• MacBook Pro Keyboard Mapping (great summary table at top of page)
• Boot Camp: MacBook Pro built-in keyboard mapping in Windows

Right-Click Drag

The tough thing is to figure out how to right-click drag. You can usually find some other way of accomplishing a right-click drag task, but sometimes you just can’t. If I want to share one folder to another in SourceSafe, there’s just no other practicable way.

When I need to, I activate System Preferences->Trackpad->Secondary Click and choose ‘Bottom-Right Corner’. Then you can simply click the big button in that corner with your right index finger and use your left index finger to move the item around. When you’re ready to drop, let go with your right finger. I always turn this setting off when I’m done because I end up right-clicking when I don’t want to.

Funtion Keys

The function keys are relatively useless on a MacBook Pro since most of the commands can be accomplished more easily by trackpad gestures. You usually use the alternative functions of the keys like volume and brightness controls.

The opposite it true on a PC, especially for thing like search where you keep hitting F3 or debugging in Visual Studio where you’re hitting F9 through F11 over and over. It gets to be a real pain to keep hitting that Fn key.

Fortunately, there’s an easy way to reverse the functionality of the Fn key so that the function keys are fired without pressing anything else and the volume, brightness, etc. controls are the ones enabled by pressing Fn.

Just go to System Preferences->Keyboard and check the box called Use all F1, F2, etc. keys as standard function keys. Here’s an example of the setting turned on.

When you’re done, then go ahead and uncheck the box. Ideally, you could create a script to quickly set and unset the setting for daily usage, but it’s really not too much to remember it.

Insert Key

Sometimes, when running Windows, you’ll need to use the Insert key. None of the keyboard mappings I’ve seen have indicated what to use except the Insert key on a full keyboard (duh!).

On a MBP, it’s simply:  Fn+Enter

So I shopped around for an obfuscating (et al.) program. I looked at the industry-standard, Dotfuscator, since a free version even ships with Visual Studio. But the free version is worthless since it only renames public members (again, don’t take my word and just peek into it yourself). The commercial version of Dotfuscator very easily supports obfuscating a ClickOnce publish (see this handy demo) and additional hardening techniques, but the price is $4950 or $5940 depending on which edition you choose. They have a special deal for companies less than 40 employees, but the price is still $2500. I figured it was worth some shoe leather to find a less expensive solution.

After some hunting around and having mixed results with various other products, I found a program called .Net Reactor. I like it because it’s straightforward, fully-featured, has comprehensive command-line support, and is very reasonably priced at $179.

Now that I had an obfuscation tool, I had to figure out how to make it work with ClickOnce. I was initially hopeful seeing the post-build command-line property in the project properties. However, if you simply add the obfuscation to the post-build event, the published exe is not obfuscated. It turns out your exe is compiled into an intermediate directory (e.g. “obj\Release”) and then copied to your build output path and/or used to create a ClickOnce publish. The post-build event is too late to affect the publish.

To hook in before the publish, you have to turn to MSBuild, the compile tool used in the background by Visual Studio to consume and compile a .Net project. It turns your project file (.vbproj or .csproj) are actually MSBuild files that you can edit directly for more features than are supported through the IDE.

(Forgive me if I’ve violated MSBuild best-practices in my tasks and properties, but there just isn’t a lot of help out there and the MSBuild syntax seems pretty sloppy to begin with.)

Steps

1. Download this file and place it in the same directory as the project file of the project you want to protect.
   
   

   Obfuscation.targets

   
   This file is analogous to the .Net provided .targets files that are also included with your project by default. This file will override or add to tasks that are handled by those files.
   Note: You will have to modify this file to suit your particular situation. Search the targets file for MergeAssembliesList (to use a separator other than “/”), MergeAssembliesArg, ObfuscatorName, ObfuscatorLocation, and ObfuscatorLocation. Also, for .Net Reactor, the merging application is built into the obfuscator. If you are using a separate merging app, you’ll have to add a call to that program. You should be able to figure it out from how this targets file is formatted.
2. Right-click on the project that you will be publishing and click ‘Unload Project’. (If your project is source-controlled, you may get a warning that says you still have files checked out, but you can just click ‘Continue’ without causing any problems.)
3. Right-click on the project again and click ‘Edit MyApp.vbproj’.
4. Paste the non-highlighted XML into your project file between the highlighted lines. The ‘.targets’ file may have a different file name if you’re using C# but it will still end in ‘.targets’.

     <Import Project="$(MSBuildBinPath)\Microsoft.VisualBasic.targets" />
     <!-- Use the following settings to control how and if the output is obfuscated. -->
     <Target Name="BeforeBuild" Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
       <CreateProperty Value="true">
         <Output TaskParameter="Value" PropertyName="Obfuscate" />
       </CreateProperty>
       <CreateProperty Value="">
         <Output TaskParameter="Value" PropertyName="ObfuscatorOptionsOverride" />
       </CreateProperty>
       <CreateProperty Value="true">
         <Output TaskParameter="Value" PropertyName="ShouldMergeAssemblies" />
       </CreateProperty>
       <CreateProperty Value="">
         <Output TaskParameter="Value" PropertyName="MergeAssembliesArgOverride" />
       </CreateProperty>
     </Target>
     <Import Project="$(MSBuildProjectDirectory)\Obfuscation.targets" />
   </Project>
   

   You can change the ‘true’ or ‘false’ values to control whether or not the obfuscation is done at all and whether or not assemblies are merged when obfuscating. You can also change the configuration from ‘Release’ to some other configuration that you have defined.
   You can use the Overrides to change the arguments to the obfuscator or merging program. This is helpful if your program can’t be obfuscated by your chosen default obfuscation settings or you want to merge only certain assemblies.
   Note: If you don’t intend to merge assemblies, each dll or exe that is included with your project must be separately obfuscated (unless of course it’s a 3rd party include). When obfuscating these includes, make sure NOT to obfuscate their public members or your main assembly won’t be able to use them.

5. After saving your changes, right-click on the project and click ‘Reload Project’. You may get a security warning, but just choose to ‘Load project normally’.
6. If you’re intending to Publish and merge assemblies, there’s one more step required. You must exclude files that are merged into the main assembly and would be normally output with the publish. Otherwise, these unprotected files, though unused, will be available for the world to decompile. (Note: this doesn’t apply if you’re not merging.)
   Go to the ‘Publish’ tab in ‘My Project’ and click on ‘Application Files’. For any dll or exe file listed as ‘Include’ or ‘Include (auto)’, change it to ‘Exclude’. If you have 3rd party files or files listed as ‘Prerequisite’, merging may not be an option and you may have to resort to individually protecting your includes by obfuscation and security checks to ensure usage only by your programs.
7. Change your configuration to ‘Release’ and build or publish. Note: For whatever reason, the IDE sometimes forgets what solution configuration was last selected, so always check that you have the right configuration selected if the obfuscator doesn’t run.

Notes

• When you’re working in XML, don’t forget to properly escape special characters. For example, a ‘<’ should be escaped as <. Also, you must escape quotation marks inside a string literal (using ") but you don’t have to if you’re only inside a tag, like when specifying a property value. Here’s a great thread on XML escape characters.
• To make sure Messages are output, in VS IDE go to Tools->Options->Projects & Solutions->Build & Run and change Output Verbosity from ‘Minimal’ to ‘Normal’. It helps a lot when debugging custom MSBuild configs.
• MSBuild will halt if a program’s exit code is not ’0′. If your obfuscator of choice uses a different exit code or always returns something non-zero, then make sure to trap it in the way I did above and throw an error when appropriate. Actually, the error trapping I did was redundant (I think), but it’s a handy example.
• If you’re using another obfuscator, it should ideally conform to the MSBuild convention of returning 0 (zero) if successful and a non-zero number on an error. If your obfuscator works differently, for example, always returning 1 on success, or if you just want to ignore certain errors, you may use the following convention to trap and interpret exit codes. This example raises an error for all return values other than 0, effectively duplicating the standard MSBuild convention.

  <Exec Command="$(ObfuscatorLocation) -file &quot;$(SourceExe)&quot; -targetfile &quot;$(SecureExe)&quot; $(ObfuscatorOptions) ">
    <Output TaskParameter="ExitCode" PropertyName="ObfuscatorErrorCode" />
  </Exec>
  <Error Condition="'$(ObfuscatorErrorCode)' != '0'"
         Text="Error while executing '$(ObfuscatorName)'. Returned exit code of '$(ObfuscatorErrorCode)'." />
  

2010-05-30 Updated: Refined include method and added support for merging assemblies. Also, included instructions for trapping custom errors.
2011-01-03 Updated: Fixed problem with handling references to COM assemblies (or possibly other reference types) that would generate the following error:

C:\Dev\MyApplication\Obfuscation.targets(27,5): error MSB4096: The item "obj\Release\Interop.SomeCOMClass.dll" in item list "ReferencePath" does not define a value for metadata "ResolvedFrom". In order to use this metadata, either qualify it by specifying %(ReferencePath.ResolvedFrom), or ensure that all items in this list define a value for this metadata.

Also added support for files that are included as prerequisites that would generate the following custom error:

Assemblies set to merge during obfuscation but ClickOnce deployment still lists output dependencies!

2011-06-05 Updated: Updated xml for project file to include all the override arguments options. Also added notes about how the Obfuscation.targets file may need to be modified.

References

• Great Intro to MSBuild
• Built-in MSBuild Targets
• Common MSBuild Project Properties
• MSBuild Exec Task
• MSBuild Property Scoping
• Using Postbuild with ClickOnce (what I started with in created my MSBuild configuration)

ByVal var As IntPtr

and marshalling a string rather than

ByVal bytes() As Byte

Anyhow, the tool is here: http://www.pinvoke.net/index.aspx

But very often you don’t care about the configuration you’re running–what you do care about is distinguishing between you developing the software and the end user using it. In other words, you care whether you’re running in the IDE or not.

An example of when this would matter is if you accidentally publish in Debug mode, then the end user will get all your debug outputs, extra buttons, etc. You can mitigate this risk if your code is protected by a check for the presence of the debugger instead. This call is:

System.Diagnostics.Debugger.IsAttached

Now, the end-user can always load up your EXE in Visual Studio and attach a debugger instance, so don’t assume this call will protect anything super-sensitive in your program. But your code is very susceptible to a decompiler anyways, so always use compiler directives if you don’t want certain sections of your code to make it to the outside world.

So I started hunting about for a quick solution to convert this over (why isn’t this automatic MS?) and found a great solution by Duncan Smart, on his blog here. I’ve modified it to work with VB and tested and ran it in VB 2008. Duncan’s didn’t seem to work right on VB code when iterating through the class members, but there does seem to be little predictability when it comes to using the macro system. I also added some extra error checking and a restore-on-error feature.

Here’s the code for the macro. Instructions for usage are in the comments on the top. Sorry for the sometimes sloppy style–I wrote it quick and dirty.

Imports System
Imports EnvDTE
Imports EnvDTE80
Imports EnvDTE90
Imports System.Diagnostics

Public Module ExtractWinFormsDesignerFile

    ' -------------------------------------------------------------------------
    ' Extract WinForms Designer File Visual Studio 2005/2008 Macro
    ' -------------------------------------------------------------------------
    ' Extracts the InitializeComponent() and Dispose() methods and control
    ' field delarations from a .NET 1.x VS 2003 project into a VS 2005/8
    ' style .NET 2.0 partial class in a *.Designer.VB file. (This tested to work
    ' with VB only.)
    '
    ' To use:
    '  * Copy the methods below into a Visual Studio Macro Module (use
    '    ALT+F11 to show the Macro editor)
    '  * Select a Windows Form in the Solution Explorer
    '  * Run the macro by showing the Macro Explorer (ALT+F8) and double
    '    clicking the 'ExtractWinFormsDesignerFile' macro.
    '
    ' Duncan Smart, InfoBasis, 2007
    ' From: http://blog.dotsmart.net/2008/05/20/converting-visual-studio-2003-winforms-to-visual-studio-20052008-partial-classes/
    ' Modified and updated by Nathan Jones, 2010
    ' See: http://www.nathanpjones.com/
    ' -------------------------------------------------------------------------

    Sub ExtractWinFormsDesignerFile()

        Dim item As ProjectItem = DTE.SelectedItems.Item(1).ProjectItem
        Dim sourceFileName As String = item.FileNames(1)
        Dim sourceDir As String = System.IO.Path.GetDirectoryName(sourceFileName)
        Dim origCode As String
        Dim bareName As String = System.IO.Path.GetFileNameWithoutExtension(sourceFileName)
        Dim newDesignerFile As String = sourceDir & "\" & bareName & ".Designer.vb"

        If IO.File.Exists(newDesignerFile) Then
            MsgBox("Designer file already exists!")
            Exit Sub
        Else
            If MsgBox("You are about to extract designer code from:" + vbCrLf + _
                      vbCrLf + _
                      "    " + sourceFileName + vbCrLf + _
                      vbCrLf + _
                      "To the following file:" + vbCrLf + _
                      vbCrLf + _
                      "    " + newDesignerFile + vbCrLf + _
                      vbCrLf + _
                      "MAKE SURE TO BACK UP FIRST!", _
                      MsgBoxStyle.OkCancel Or MsgBoxStyle.DefaultButton2 Or MsgBoxStyle.Question, _
                      "Confirm") = MsgBoxResult.Cancel Then Exit Sub
        End If
        origCode = System.IO.File.ReadAllText(sourceFileName)

        Dim codeClass As CodeClass
        Dim namespaceName As String

        codeClass = findClass(item.FileCodeModel.CodeElements)
        namespaceName = ""
        If codeClass.Namespace IsNot Nothing Then
            namespaceName = codeClass.Namespace.FullName
        End If

        Dim initComponentText As String
        Dim disposeText As String
        Dim fieldDecls() As String
        Try
            initComponentText = extractMember(codeClass.Members.Item("InitializeComponent"))
        Catch
            MsgBox("Error extracting InitializeComponent!")
            Exit Sub
        End Try
        Try
            disposeText = extractMember(codeClass.Members.Item("Dispose"))
        Catch
            MsgBox("Error extracting Dispose! Will restore source file.")
            System.IO.File.WriteAllText(sourceFileName, origCode)
            Exit Sub
        End Try
        Try
            fieldDecls = extractWinFormsFields(codeClass, initComponentText)
        Catch
            MsgBox("Error extracting field declares! Will restore source file.")
            System.IO.File.WriteAllText(sourceFileName, origCode)
            Exit Sub
        End Try

        Dim finalCode As String

        finalCode = IIf(namespaceName <> "", "Namespace " + namespaceName + vbCrLf + vbCrLf, "") + _
                    "<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _" + vbCrLf + _
                    "Partial Class " + codeClass.Name + vbCrLf + _
                    "    Inherits System.Windows.Forms.Form" + vbCrLf + _
                    vbCrLf + _
                    disposeText + vbCrLf + _
                    vbCrLf + _
                    fieldDecls(0) + vbCrLf + _
                    vbCrLf + _
                    initComponentText + vbCrLf + _
                    fieldDecls(1) + vbCrLf + _
                    "End Class" + vbCrLf + _
                    IIf(namespaceName <> "", vbCrLf + "End Namespace" + vbCrLf, "")

        ' Now write the new designer file

        System.IO.File.WriteAllText(newDesignerFile, finalCode)

        Dim newProjItem As ProjectItem = item.ProjectItems.AddFromFile(newDesignerFile)
        Try
            newProjItem.Open()
        Catch
        End Try
        Try
            DTE.ExecuteCommand("Edit.FormatDocument")
        Catch
        End Try

        MsgBox("Code separated successfully!" + vbCrLf + _
               "You may have residual comments or code regions in the source " + vbCrLf + _
               "class that should be deleted or moved to the new Designer.vb class.", _
               MsgBoxStyle.Information, _
               "Complete")

    End Sub

    Function findClass(ByVal items As System.Collections.IEnumerable) As CodeClass

        For Each codeEl As CodeElement In items

            If codeEl.Kind = vsCMElement.vsCMElementClass Then

                Return codeEl

            ElseIf codeEl.Children.Count > 0 Then

                Dim cls As CodeClass = findClass(codeEl.Children)
                If cls IsNot Nothing Then
                    Return findClass(codeEl.Children)
                End If

            End If

        Next

        Return Nothing

    End Function

    Function extractWinFormsFields(ByVal codeClass As CodeClass, ByVal initComponentsCode As String) As String()

        Dim member As CodeElement
        Dim fieldsCode As String
        Dim components As String
        Dim initComponentsCodeForComp As String = initComponentsCode.ToLower

        fieldsCode = ""
        For i As Integer = codeClass.Members.Count To 1 Step -1

            member = codeClass.Members.Item(i)

            If member.Kind = vsCMElement.vsCMElementVariable Then

                Dim field As CodeVariable = member

                If field.Type.TypeKind <> vsCMTypeRef.vsCMTypeRefArray Then

                    If field.Name.ToLower = "components" Then

                        ' We'll insert this separately
                        components = extractMember(field)

                    ElseIf initComponentsCodeForComp Like ("* Me." + field.Name + " = New *").ToLower Then

                        fieldsCode = extractMember(field) + vbCrLf + _
                                     fieldsCode

                    End If

                End If

            End If

        Next

        Return New String() {components, fieldsCode}

    End Function

    Function extractMember(ByVal memberElement As CodeElement) As String

        Dim memberStart As EditPoint = memberElement.GetStartPoint().CreateEditPoint()
        Dim memberText As String = String.Empty

        memberText += memberStart.GetText(memberElement.GetEndPoint())
        memberStart.Delete(memberElement.GetEndPoint())

        Return memberText

    End Function

End Module

Parallels Desktop 5

• Faster Virtual Disk Access – And this is why it wins for me. Since so much of the performance of the VM is dependent on the virtual hard drive, this puts it way ahead of Fusion especially if you’re running antivirus on your VM.
• Getures – Why can’t Fusion do this? Although I plug in a separate keyboard and mouse, several of my VM’s I use with the naked (so to speak) hardware. I was doing it by habit already so this is a win.
• Serial Ports – To be honest I haven’t gotten the serial port to pipe to work (in about 30 min of trying), but the capabilities are far beyond Fusion, supporting even physical serial ports.
• Configuration Options – It simply has more configuration options. Generally you don’t need them, but they’re there when you need them.
• Better Host Integration Mgmt – Although turning these features off is anything but straightfoward, you have many more levels of integration from folder to MacLook that makes your Windows programs look like Mac programs. Also, there is (new to v5) a checkbox to completely isolate the VM from the host which will turn off all the other integration features.

VMWare Fusion 3

• Workhorse CPU Virtualization – I have a testing program that tests the output of two different DOS programs running in the Windows XP DOS window (NTVDM). On a physical computer, these each consume up to 50% of the CPU. Parallels chokes and can run about .3-.4 units/sec whereas Fusion can test upwards of .6 units/sec. For whatever reason (probably lousy virtual drive performance), this doesn’t translate into overall better performance in Fusion.
• FULL Keyboard Support – Fusion actually captures special keys like F12. I have Cmd+F12 mapped to the Pause/Break key. Parallels won’t allow this-won’t even allow setting it without turning off the OSX shortcut. Even in full screen it will bring up the Dashboard.
• Good Mouse Support – Although it doesn’t support gestures, it did recognized the “Back” and “Forward” buttons on my Logitech mouse, and I don’t have any special Logitech drivers installed on the host or the VM.
• Straightforward Config – Although not sufficient for the power-user, it does strike me as more accessible for the novice user.

These are just a few observations from regular use of both programs. Many of the basic features are identical, but Parallels really has the edge.