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

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
}

        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;
        }

        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();
            }
        }

Zip.ExtractAll(myZipFile, myDestinationFolder);

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 & _
            "// <file>" & vbNewLine & _
            "//     " & DTE.ActiveDocument.Name & vbNewLine & _
            "// </file>" & vbNewLine & _
            "//" & vbNewLine & _
            "// <description>" & vbNewLine & _
                  fileDescription & _
            "// </description>" & vbNewLine & _
            "//" & vbNewLine & _
            "//" & vbNewLine & _
            "// <copyright file=""" & DTE.ActiveDocument.Name & """ company=""My Company"">" & vbNewLine & _
            "//     Copyright (c) 2009 My Company Inc. All rights reserved." & vbNewLine & _
            "// </copyright>" & 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

#region File Description
//------------------------------------------------------------------------------
// <file>
//     Program.cs
// </file>
//
// <description>
//     This is a TEST!
// </description>
//
//
// <copyright file="Program.cs" company="My Company">
//     Copyright (c) 2009 My Company Inc. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
#endregion

 
#include <stdio.h>
#include <stdlib.h>
 
int main( void )
{
   printf( "HELLO WP-Syntax\n" );
 
   return 0;
}