Private Shared Sub PathExceptionExample()
      ' Get a reference to a source file
      Dim sourceFile As AbstractFile = New DiskFile("SomeFile.dat")

      ' Get a reference to a zip archive
      Dim zipFile As AbstractFile = New DiskFile("PathExceptionExample.zip")
      Dim zip As New Xceed.Zip.ZipArchive(zipFile)

      ' Compute a very long file name (512 characters)
      Dim stringBuilder As New StringBuilder()
      For i As Integer = 0 To 31
        stringBuilder.Append("VeryLongFilename")
      Next i
      stringBuilder.Append(".dat")

      Using batch As New AutoBatchUpdate(zip)
        ' Get a reference to a zipped file that will have the very long file name
        Dim zippedFile As AbstractFile = zip.GetFile(stringBuilder.ToString())

        ' Zip the source file to that zipped file
        sourceFile.CopyTo(zippedFile, True)

        ' Get a reference to a zipped file that has invalid characters
        zippedFile = zip.GetFile("P""ath*Exception?Example.dat")

        ' Zip the source file to that zipped file
        sourceFile.CopyTo(zippedFile, True)
      End Using

      ' Create a reference to a FileSystemEvents object 
      Dim events As New FileSystemEvents()

      ' Subscribe to the PathException event of the FileSystemEvents object using the PathExceptionEventHandler delegate 
      AddHandler events.PathException, AddressOf OnPathException

      ' Get a reference to a folder on a hard disk
      Dim destinationFolder As AbstractFolder = New DiskFolder("SomeFolder")

'       Here we extract the files from the archive. But the file in the archive
'       * with the long filename can't be expressed on the Windows file system as it is
'       * implemented by the .NET framework. The PathException event handler will allow
'       * us to intervene before the operation throws an exception. 

      ' Extract the files from the archive
      zip.CopyFilesTo(events, Nothing, destinationFolder, True, True)
    End Sub

    ''' <summary>
    ''' Finds an exception amongst the supplied exception stack
    ''' </summary>
    ''' <typeparam name="T">The exception type to find</typeparam>
    ''' <param name="exception">The exception stack</param>
    ''' <returns>An exception object of the specified Type or null</returns>
    Private Shared Function FindException(Of T As Exception)(ByVal exception As Exception) As T
      Dim target As T = Nothing

      ' While we have an exception
      Do While exception IsNot Nothing
        ' If we can express the current exception as the target type
        target = TryCast(exception, T)
        If target IsNot Nothing Then
          ' We're done
          Exit Do
        End If

        ' Go to the next exception
        exception = exception.InnerException
      Loop

      ' Return what we found
      Return target
    End Function

    ''' <summary>
    ''' Replaces a single character in the supplied String object at the specified index
    ''' </summary>
    ''' <param name="s"></param>
    ''' <param name="index"></param>
    ''' <param name="newChar"></param>
    ''' <returns>A String object with the replaced character</returns>
    Private Shared Function ReplaceChar(ByVal s As String, ByVal index As Integer, ByVal newChar As Char) As String
      ' Put the path in a string builder
      Dim builder As New System.Text.StringBuilder(s)

      ' Replace that invalid character with 'newChar'
      builder(index) = newChar

      ' Update the path with the new value without the offending character
      s = builder.ToString()

      Return s
    End Function

    Private Shared Function ComputeSmallerName(ByVal path As String, ByVal e As PathExceptionEventArgs) As String
      ' TODO: Implement logic to compute a smaller name depending on your scenario and needs
      Return Nothing
    End Function

    Private Shared Sub OnPathException(ByVal sender As Object, ByVal e As PathExceptionEventArgs)
      ' Try to find a InvalidCharacterInPathException in the exception stack we got from the event
      Dim invalidCharacterInPathException As InvalidCharacterInPathException = FindException(Of InvalidCharacterInPathException)(e.Exception)
      Dim pathTooLongException As PathTooLongException = FindException(Of PathTooLongException)(e.Exception)
      Dim itemIsFolderException As ItemIsFolderException = FindException(Of ItemIsFolderException)(e.Exception)
      Dim itemIsFileException As ItemIsFileException = FindException(Of ItemIsFileException)(e.Exception)
      Dim argumentException As ArgumentException = FindException(Of ArgumentException)(e.Exception)

      ' If part of the path failure was caused by an invalid character
      If invalidCharacterInPathException IsNot Nothing Then
        ' The InvalidCharacterInPathException gives us exactly what character is invalid 

        e.Path = ReplaceChar(e.Path, invalidCharacterInPathException.InvalidCharIndex, "_"c)

        ' Have the FileSystem retry using the path
        e.Action = ItemExceptionAction.Retry
      ElseIf pathTooLongException IsNot Nothing Then
        ' If the exception occurred for a folder
        If e.FileSystemType Is GetType(AbstractFolder) AndAlso e.Path.Length < 248 Then
'           It's the combined length of all the preceding folder names that makes
'           * this folder name bust the limit 

          ' Try to create 'space' in the path by not using the folder name at all
          ' and use the parent folder instead
          e.Path = ".."

          ' Tell the component to retry using the new value we will put in e.Path
          e.Action = ItemExceptionAction.Retry
        Else
          ' TODO: Implement ComputeSmallerName() to compute a small folder name and assign it for trial 
          Dim smallerName As String = ComputeSmallerName(e.Path, e)

          ' If a smaller name could be computed
          If String.IsNullOrEmpty(smallerName) Then
            ' Skip the item
            e.Action = ItemExceptionAction.Ignore
          Else
            e.Path = smallerName

            ' Tell the component to retry using the new value we will put in e.Path
            e.Action = ItemExceptionAction.Retry
          End If
        End If
      ElseIf itemIsFolderException IsNot Nothing Then
'         Here, we are creating an AbstractFile object but the path represents an existing
'         folder.
'         
'         There's not much we can do to fix that. If it makes sense in your scenario, you
'         can always try to ignore the item and move on to the next one. Note that 'ignore'
'         only applies when processing a list of items. 
        'e.Action = ItemExceptionAction.Ignore;
      ElseIf itemIsFileException IsNot Nothing Then
'         Here, we are creating an AbstractFolder object but the path represents an existing
'        file.
'         
'        There's not much we can do to fix that. If it makes sense in your scenario, you
'        can always try to ignore the item and move on to the next one. Note that 'ignore'
'        only applies when processing a list of items. 
        'e.Action = ItemExceptionAction.Ignore;
'       NOTE: Order is important here. ArgumentException is the more general exception that usually
'      contains more specific inner exceptions. We test for these specific exceptions above and
'      handle the more general exceptions last. 
      ElseIf argumentException IsNot Nothing Then
'         ArgumentException is more complicated as it is less defined. It is an umbrella exception
'        that is usually thrown when a .NET framework method or Windows itself can't process the path
'        for 'some' reason.
'         
'        One thing that is worth checking is more invalid characters. System.IO.Path.GetInvalidPathChars()
'        is what is used by the component to check the path with. But it doesn't contain things like
'        '?', '*'. Most likely because in some contexts, they are valid. But not when you want to
'        manipulate an actual file or folder. 

        ' If the problem argument is the filename
        If argumentException.ParamName = "fileName" Then
          ' Common 'invalid' characters that are not caught by System.IO.Path.GetInvalidPathChars()
          Dim furtherInvalidChars() As Char = { "?"c, "*"c }

          Dim index As Integer
          index = e.Path.IndexOfAny(furtherInvalidChars)
          If index <> -1 Then
            e.Path = ReplaceChar(e.Path, index, "_"c)

            ' Have the FileSystem retry using the path
            e.Action = ItemExceptionAction.Retry
          End If
        End If
      End If
    End Sub