Crows Programming » General

I’m Back

crow — Thu, 16 Jul 2009 02:58:14 +0000

Hey guys, sorry I’ve been away for a bit. I’ll try and respond to your questions, especially those over on the C# dynamic web service page.

I’ll be adding a whole lot of new content as well. If anyone has any suggestions on a topic feel free to leave them for me.

See Ya!!

How To Extract A Zip File With C#

crow — Fri, 03 Apr 2009 05:49:51 +0000

The .Net Framework Class Libraries are great and allow you to manipulate many different file formats. Unfortunately they seemed to have left out support for standard Zip files. Thankfully our good friends over at ICSharpCode have released an awesome little library for handling Zip files called the SharpZipLib.

The library is very simple to use and supports several formats including:

Zip
GZip
Tar
BZip2

Using SharpZipLib

Extracting a file with SharpZipLib is really quite simple. First you create a ZipInputStream from an existing FileStream to the zip file.

ZipInputStream zinstream = new ZipInputStream(File.OpenRead(source));

Next you read the entries from the zip file, which could be either a file or directory.

ZipEntry theEntry;
 
while ((theEntry = zinstream.GetNextEntry()) != null)
{
   // if theEntry is a directory then create it on disk
   // otherwise it’s a file so read from zinstream just like
   // you would any other file
}

The ZipEntry represents either a file or directory that must be read and reproduced in the target directory where you are extracting the files to. GetNextEntry will continue to return either the next directory or the next file in the Zip file until no more exist. Here is a complete example of extracting all files (while maintaining directory structure) to a local folder.

The Extraction Function

        public static int ExtractAll(string source, string destination)
        {
            ZipInputStream zinstream = null; // used to read from the zip file
            int numFileUnzipped = 0; // number of files extracted from the zip file
 
            try
            {
                // create a zip input stream from source zip file
                zinstream = new ZipInputStream(File.OpenRead(source));
 
                // we need to extract to a folder so we must create it if needed
                if (Directory.Exists(destination) == false)
                    Directory.CreateDirectory(destination);
 
                ZipEntry theEntry; // an entry in the zip file which could be a file or directory
 
                // now, walk through the zip file entries and copy each file/directory
                while ((theEntry = zinstream.GetNextEntry()) != null)
                {
                    string dirname = Path.GetDirectoryName(theEntry.Name); // the file path
                    string fname   = Path.GetFileName(theEntry.Name);      // the file name
 
                    // if a path name exists we should create the directory in the destination folder
                    string target = destination + Path.DirectorySeparatorChar + dirname;
                    if (dirname.Length > 0 && !Directory.Exists(target)) 
                        Directory.CreateDirectory(target);
 
                    // now we know the proper path exists in the destination so copy the file there
                    if (fname != String.Empty)
                    {
                        DecompressAndWriteFile(destination + Path.DirectorySeparatorChar + theEntry.Name, zinstream);
                        numFileUnzipped++;
                    }
                }
            }
            catch (Exception)
            {
                throw;
            }
            finally
            {
                zinstream.Close();
            }
 
            return numFileUnzipped;
        }

And the DecompressAndWrite method:

        private static void DecompressAndWriteFile( string destination, ZipInputStream source )
        {
            FileStream wstream = null;
 
            try
            {
                // create a stream to write the file to
                wstream = File.Create(destination);
 
                const int block = 2048; // number of bytes to decompress for each read from the source
 
                byte[] data = new byte[block]; // location to decompress the file to
 
                // now decompress and write each block of data for the zip file entry
                while (true)
                {
                    int size = source.Read(data, 0, data.Length);
 
                    if (size > 0)
                        wstream.Write(data, 0, size);
                    else
                        break; // no more data
                }
            }
            catch(Exception)
            {
                throw;
            }
            finally
            {
                if( wstream != null )
                    wstream.Close();
            }
        }

Pretty neat huh? I love how simple it is.
If those methods are placed into a class called Zip, then extracting a Zip file is as easy as:

Zip.ExtractAll(myZipFile, myDestinationFolder);

I’ve put together a sample project that uses the SharpZipLib to extract the contents of a zip file. It basically just allows you to select the zip file and the destination from a form and uses the methods above. You can find it below.

DOWNLOAD SAMPLE APPLICATION

Let me know if you find this useful or need any help!!!

Documentation Template Via Visual Studio Macro

crow — Thu, 02 Apr 2009 06:50:51 +0000

Consistency is the key when working on computer software, especially if you are developing a large system with multiple programmers. You should be consistent with the layout and format of your source code. Unfortunately this can be difficult to achieve when time is precious – and isn’t it always. However Visual Studios macro system makes it a breeze to automate this task with little to no work. Here is a simple way to implement this in C#.

What I would like to be able to do is execute a simple macro and see a dialog box that lets me enter information specific to the source file I am working with. That information will then be inserted into the file using a predefined template. The dialog will look something like this:

To accomplish this task we need to things; a .Net class library that implements the dialog and the macro to launch it and interact with Visual Studio using its automation model.

Creating the dialog is easy. Simply create a class library in the .Net language of your choice and add a form to it. Then make sure it has public properties that contain the information entered by the user so the macro can consume it. Once you have built your library you will have a .DLL file. This file needs to be copied to:
“C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PublicAssemblies”
for Visual Studio 2008. For earlier versions the location will be similar. This will make your dialog type available to your macro.

Next comes the macro. To do this open the Macros IDE using Tools->Macros->Macros IDE. Right click MyMacros in the IDE and select Add->New Module. Name the new module AutoDocCSharpSourceFile. Right click MyMacros again and select add reference. Add a reference to your class library. In your new macro add the following code:

Imports System
Imports EnvDTE
Imports EnvDTE80
Imports System.Diagnostics
Imports System.Text.RegularExpressions
 
Public Module AutoDocCSharpSourceFile
    Sub AutoDocCSharpSourceFile()
        ' This is the main entry point for the macro
        ' it will automatically document the c# source file selected
        ' by the user in the custom dialog using the custom template
        ' This should be used on new files only as it will not retain the
        ' existing code

        ' note that we only acknowlege Windows line endings (carrige return/line feed)
        ' if your source file is using a LF only you will have to replace all "\r\n" with "\n"

        ' also there is no error handling. You can catch any exceptions thrown and handle them
        ' nicely or you can just let Visual Studio catch them and show them to you

        ' make sure Visual Studio has a document open... of course this may not be a C# file
        If DTE.ActiveDocument Is Nothing Then
            MsgBox("Cannot Continue Because No Documents Are Open", MsgBoxStyle.OkOnly)
            Return
        End If
 
        ' first grab the text for the entire source file
        Dim sel As TextSelection = DTE.ActiveDocument.Selection
        sel.SelectAll()
        Dim documentText As String = sel.Text
 
        ' now extract the namespace name and the class name so
        ' we can populate the dialog for the user
        Dim namespaceName As String = GetNamespaceName(documentText)
        Dim className As String = GetClassName(documentText)
 
        ' display the dialog, the user can enter source file specific information
        ' such as the file description or rename the class etc...
        Dim dialog As New AutoTemplateDialog.AutoTemplateDialog(className, namespaceName)
        dialog.TopLevel = True
        dialog.ShowDialog()
        dialog.Focus()
 
        ' exit if user hit cancel
        If dialog.DialogResult = System.Windows.Forms.DialogResult.Cancel Then
            sel.StartOfDocument()
            dialog.Dispose()
            Return
        End If
 
        namespaceName = dialog.NamespaceName
        className = dialog.ClassName
 
        ' we no longer need the contents of the source file
        sel.Delete(sel.Text.Length)
        sel.StartOfDocument()
 
        ' now insert the template documentation
        GenFileDescription(dialog.Description)
        GenUsingStatements(documentText)
        GenFile(className, namespaceName, documentText)
 
        dialog.Dispose() ' it seems visual studio prevents automatic disposal?
        ' strange behavior results after a while if this isn't done
    End Sub
 
    Sub GenFileDescription(ByVal desc As String)
        ' This will generate the file description that goes at the top of
        ' the source file
        ' desc - A text description of the source file that will be inserted

        Dim fileDescription As String ' the file description that goes into the description tag

        If desc = String.Empty Then
            fileDescription = "//" + Environment.NewLine
        Else
            ' split the description into seperate lines so that we can add them into single line comments
            Dim lines As String() = Regex.Split(desc, "\r\n")
 
            ' comment each description line
            For Each line As String In lines
                fileDescription += ("//     " + line + Environment.NewLine)
            Next
        End If
 
        ' now insert the header template
        DTE.ActiveDocument.Selection.Insert( _
            "#region File Description" & vbNewLine & _
            "//------------------------------------------------------------------------------" & vbNewLine & _
            "// " & vbNewLine & _
            "//     " & DTE.ActiveDocument.Name & vbNewLine & _
            "// " & vbNewLine & _
            "//" & vbNewLine & _
            "// " & vbNewLine & _
                  fileDescription & _
            "// " & vbNewLine & _
            "//" & vbNewLine & _
            "//" & vbNewLine & _
            "// " & vbNewLine & _
            "//     Copyright (c) 2009 My Company Inc. All rights reserved." & vbNewLine & _
            "// " & vbNewLine & _
            "//------------------------------------------------------------------------------" & vbNewLine & _
            "#endregion" & vbNewLine & vbNewLine)
    End Sub
 
    Sub GenUsingStatements(ByVal documentText As String)
        ' This will extract the using statements and wrap them
        ' in a region
        ' documentText is the body of the source file

        Dim mc As MatchCollection ' holds matches to the regular expression
        Dim ex As Regex ' regular expression for finding the using statements
        Dim nl As Regex ' holds maches for new lines

        ' find all using statements
        ex = New Regex("using")
        nl = New Regex("\n")
 
        mc = ex.Matches(documentText)
 
        ' start new region in source file
        DTE.ActiveDocument.Selection.Insert("#region Using Statements" & vbNewLine)
 
        ' now place each using statement in the region
        For Each m As Match In mc
            Dim x As Match = nl.Match(documentText.Substring(m.Index)) 'end statement at newline

            If x.Success Then
                DTE.ActiveDocument.Selection.Insert(documentText.Substring(m.Index, x.Index))
            End If
        Next
 
        ' close off the region
        DTE.ActiveDocument.Selection.Insert("#endregion" & vbNewLine & vbNewLine)
 
    End Sub
 
 
    Function GetNamespaceName(ByVal documentText As String) As String
        ' finds the root namespace defined in the document and returns it

        Dim mc As Match ' matches in regular expression

        Dim ex As Regex
        Dim nl As Regex
 
        ' use regular expression to find the namespace name
        ex = New Regex("namespace[^\r\n]*")
 
        mc = ex.Match(documentText)
 
        ' return result
        If mc.Success Then
            Return mc.Value.Substring(10) ' using 10 will create a 
            ' a problem if anything comes
            ' before the namespace keyword
        Else
            Return ""
        End If
 
    End Function
 
    Function GetClassName(ByVal documentText As String) As String
        ' finds the class name defined in the document
        Dim mc As Match
 
        Dim ex As Regex
        Dim nl As Regex
 
        ' use a regular expression just as in finding the namespace name
        ex = New Regex("class[^\r\n]*")
 
        mc = ex.Match(documentText)
 
        If mc.Success Then
            Return mc.Value.Substring(6)
        Else
            Return ""
        End If
 
    End Function
 
    Sub GenFile(ByVal className As String, ByVal namespaceName As String, ByVal documentText As String)
        ' now we will generate the body of the source file

        ' insert initial class and namespace declaration
        DTE.ActiveDocument.Selection.Insert("namespace " & namespaceName & vbNewLine & "{" & vbNewLine & vbTab & "public class " & className & vbNewLine & vbTab & "{" & vbNewLine)
 
        ' insert the regions of the body
        InsertRegion("Properties")
        InsertRegion("Events")
        InsertRegion("Constructors")
        InsertRegion("Public Methods")
        InsertRegion("Private Methods")
        InsertRegion("Fields")
 
        ' close namespace and class
        DTE.ActiveDocument.Selection.Insert(vbTab & "}" & vbNewLine & "}")
 
    End Sub
 
    Sub InsertRegion(ByVal name As String)
        ' just a helper routine to add a region statment to the source file
        DTE.ActiveDocument.Selection.Insert(vbTab & vbTab & "#region " & name & vbNewLine & vbTab & vbTab & "#endregion" & vbNewLine & vbNewLine)
    End Sub
 
End Module

The macro is pretty straight forward with lots of documentation. It primarily is using the EnvDTE80.DTE2 class to interact with Visual Studio and write the source template.

Once you have saved the macro you can execute it by opening the Macro Explorer and running the AutoDocCSharpSourceFile macro. If you want you can also bind it to a key combination so you don’t have to use the explorer. You can accomplish this using the options dialog from the tools menu.

When you run the macro you should see a file header that looks like this:

#region File Description
//------------------------------------------------------------------------------
// 
//     Program.cs
// 
//
// 
//     This is a TEST!
// 
//
//
// 
//     Copyright (c) 2009 My Company Inc. All rights reserved.
// 
//------------------------------------------------------------------------------
#endregion

And several regions reserved for specific C# constructs. The one issue with the current implementation is that it only preserves a single class name, the namespace name, and the using directives. Anything else in the file is lost. I’ve also noticed a now and then on Vista the dialog appears behind Visual Studio, if that’s the case just alt-tab to get it back.

I Hope this proves helpful to you and saves you some time. I would love to hear feedback on any issues or improvements that could be made.

Here is my Visual Studio solution that implements the dialog window as well as the VB script macro.

WP-Syntax Test

crow — Sun, 08 Feb 2009 06:59:06 +0000

Just wanted to check out the WP-Syntax plugin and see how it works/looks.

 
#include 
#include 
 
int main( void )
{
   printf( "HELLO WP-Syntax\n" );
 
   return 0;
}

Welcome!!

crow — Fri, 06 Feb 2009 06:57:19 +0000

Welcome to Crows Programming!

This site is dedicated to my various rants and raves, mostly related to computer programming and related technologies.

I look forward to hearing feedback from all of you on my thoughts and ideas!

~Crow–