Getting the size on disc
One aside to mention: you should split your UI and business logic code.  For the sake of tossing it into a working example quickly (I'm doing this over lunch), I removed all the UI code and replaced any print-outs with Console.WriteLine calls.

I also did a little refactoring to split method calls.

Additionally, I renamed RecursiveSearch to RecursiveSearch2 so I could run it side-by-side with the original.

Finally, I made some of the non-static method static, but only to speed up running the project.  Pay no mind to these changes.

  public static void RecursiveSearch2 (string path)
  {
     try
     {
        RecursiveSearch2 (new DirectoryInfo (path));
     }
     catch (Exception ex)
     {
        Console.WriteLine (ex.Message);
     }
  }


Since I switched to use DirectoryInfo, I went ahead and made two overloads of the RecursiveSearch method.  One takes in the string for the initial search, but sub-directories can call the overload which takes in DirectoryInfo directly.  The first allows you to make the change without breaking your interface, while the second is more useful during processing work.

For speed, I pushed the try/catch up here and left out exception handling elsewhere, though you may want to add some at the lower level methods, if only to provide more descriptive logging/exception messages.

  public static void RecursiveSearch2 (DirectoryInfo dir)
  {
     foreach (var item in dir.GetFileSystemInfos ())
     {
        if (item is FileInfo)
           PrintFileInfo (item as FileInfo);
        else if (item is DirectoryInfo)
           RecursiveSearch2 (item as DirectoryInfo);
     }
  }


If you call the DirectoryInfo.GetFileSystemInfos method, it returns all directories and files in one call.  The upside is that it reduces the calls to the filesystem, which are generally going to be your bottleneck.  The downside is that you get a base type back, so some type handling may be necessary.

  private static void PrintFileInfo (FileInfo fi)
  {
     long FileLength = fi.Length;
     long FileLengthOnHarddisc = GetFileSizeOnDisk (fi.FullName, fi);


     if ((FileLength == FileLengthOnHarddisc &amp;&amp; FileLength == 4096) || FileLength &gt;= FileLengthOnHarddisc)
     {
        Console.WriteLine (fi.FullName + " - Größe - " + FileLength.ToString () + " - Größe auf Datenträger - " + FileLengthOnHarddisc.ToString ());
     }
  }


We are then left with handling the actual file, which I split off into a different method.  The only notable differences is that I changed the input to be a FileInfo type rather than string, since I already have the FileInfo object from the calling method's loop.

Running your method versus the modified version on my c:\downloads folder cut the time consistently between 1/4 to 1/2 the time of the original, though my sample size is far too small to be conclusive.  I would advise benchmarking it yourself, though.  It is possible that the performance characteristics change wildly based upon the folder structure, depth, and ratio of directories to files.