Pretty Printers / Format Code / for C# VB.NET

In my past life I spent a few eons writing Java code. And it wasn't bad. We had nice tools like Jalopy! that allowed us to have
code in a very standard way.

And I missed that. I've been looking around for something similar but I havent found anything like that :(

Until I found a great post from Chris Eargle, he improved the original solution from Kelvinpinch

Well here's the code.

Public Sub FormatSolution()
     Dim sol As Solution = DTE.Solution
     For i As Integer = 1 To sol.Projects.Count
          FormatProject(sol.Projects.Item(i))
     Next
End Sub 

Private Sub FormatProject(ByVal proj as Project)

     For i As Integer = 1 To proj.ProjectItems.Count
          FormatProjectItem(proj.ProjectItems.Item(i))
     Next
End Sub

Private Sub FormatProjectItem(ByVal projectItem As ProjectItem)

     If projectItem.Kind = Constants.vsProjectItemKindPhysicalFile Then

          If projectItem.Name.LastIndexOf(".cs") = projectItem.Name.Length - 3 Then
               Dim window As Window = projectItem.Open(Constants.vsViewKindCode)
               window.Activate()
               projectItem.Document.DTE.ExecuteCommand("Edit.FormatDocument")
               window.Close(vsSaveChanges.vsSaveChangesYes)
          End If
     End If

'Be sure to format all of the ProjectItems.
     If Not projectItem.ProjectItems Is Nothing Then
          For i As Integer = 1 To projectItem.ProjectItems.Count
               FormatProjectItem(projectItem.ProjectItems.Item(i))
          Next
     End If

'Format the SubProject if it exists.

     If Not projectItem.SubProject Is Nothing Then
          FormatProject(projectItem.SubProject)
     End If
End Sub

To use it perform the following steps:

•  Go to the VS IDE Tools Option
  
• Then Select the Macros option and select Macros IDE...
  
• This will open the macros IDE
  
• In the Macros IDE navigate to the Module1, and Insert the code
  

To run the Macro go to Tools\Macros\Macro Explorer

And select FormatAll :)

And last but not least if you want to runit from the command line just do:

devenv /command "Macros.MyMacros.Module1.FormalAll" MyProject.csproj or

devenv /command "Macros.MyMacros.Module1.FormalAll" MySol.sln or

ActiveX exceptions when running in .NET

During migration to C# or .NET it is easier to keep the same ActiveX.
The VBCompanion does a great work in migrating the ActiveX control using the .NET ActiveX wrappings and fixing all method calls. 
Sadly sometimes those ActiveX do not work properly in .NET.

Well we have good news.
Recently my friend Jose David (who we keep bothering because he is now 
a Project Manager and now he only programs in MS Excel and MS Project, I added the MS by his request :P) fixed a curious bug
we had with an aplication we migrated from VB6 to C#.

The thing is that the aplication had an ActiveX control with a strange runtime behaviour.
We migrated the application keeping the ActiveX control and in most ocasions it worked ok.

But randomly it started throwing exceptions.

During the testing he discovered that if he repeated the steps slowly the bug did not reproduced.

So his idea was that it was due a garbage collection issue. And SURPRINSINLY he was right :P

He added this:

System.GC.Collect();

System.

GC.WaitForPendingFinalizers();

 And the application started to work.

It seems like some of the COM objects needed a little more time for releasing all references :)

IsMissing migration in VB.NET or C#

Recently  we added some support for migrating the IsMissing function to VB.NEt or C#

The thing is. In VB6 the IsMissing Function is TRUE only if you have something like:

Public Sub Foo(Optional str)

Where you dont specify the variable type, or if you have

Public Sub Foo(Optional str as Variant)

And is IsMissing is FALSE for any other case. Including Optional variables whose definition type is not Variant.

So let's see some examples to illustrate the idea:
 Example 1:

Public Sub Foo(str, a As Integer, b As Integer, Optional c As Integer)
    MsgBox (str & "Foo Is missing a " & IsMissing(a))
    MsgBox (str & "Foo Is missing b " & IsMissing(b))
    MsgBox (str & "Foo Is missing c " & IsMissing(c))
End Sub

It occurs that IsMissing is really FALSE in all cases. So it is equivalent to:

Public Sub Foo(str, a As Integer, b As Integer, Optional c As Integer)
    MsgBox (str & "Foo Is missing a " & false)
    MsgBox (str & "Foo Is missing b " & false)
    MsgBox (str & "Foo Is missing c " & false)
End Sub

Example 2:

Public Sub Goo(str, a As Integer, b As Integer, Optional c As Object, Optional d As Byte, Optional e)
    MsgBox (str & "Goo Is missing a" & IsMissing(a))
    MsgBox (str & "Goo Is missing b" & IsMissing(b))
    MsgBox (str & "Goo Is missing c" & IsMissing(c))
    MsgBox (str & "Goo Is missing d" & IsMissing(d))
    MsgBox (str & "Goo Is missing e" & IsMissing(e))
End Sub

All cases EXCEPT "e" are equivalent to FALSE

Public Sub Goo(str, a As Integer, b As Integer, Optional c As Object, Optional d As Byte, Optional e)
    MsgBox (str & "Goo Is missing a" & false)
    MsgBox (str & "Goo Is missing b" & false)
    MsgBox (str & "Goo Is missing c" &false)
    MsgBox (str & "Goo Is missing d" & false)
    MsgBox (str & "Goo Is missing e" & IsMissing(e))
End Sub

So if you are migrating your VB6 Code to C# put attention to these little details it can save you a lot of time.And remember that this is just one feature of VBCompanion tool ;)

Case Sensitive SQL Server

The only thing wrong was the the case. For example he had COLUMN1 instead of Column1. I had never seen that problem in SQLServer.
I had seed that in Sybase but not in SQLServer. He solved that by changing the database collating sequence to something like this:

alter database database1 collate SQL_Latin1_General_CP1_CI_AI

the CI in the collating indicates Case Insensitive

For more information on SQL Server collations check: http://msdn2.microsoft.com/en-us/library/aa258233(SQL.80).aspx

And you determine your current database collation use a code like this: