Parallel.ForEach и foreach возвращают разные ссылочные переменные

Рекурсивная функция присваивает относительную сумму фактической сумме.

countFolder = countFolderinLambda;
countFile = countFileinLambda;
countByte = countByteinLambda;

Учтите, что эта функция работает параллельно для нескольких каталогов, и все они присваивают свой номер countFile, ничего не зная о других параллельных каталогах.

Например,

w/ has 5 files
w/x/ has 3 files
w/y/ has 10 files
w/z/ has 7 files

• Параллельная ветвь для w/x/ устанавливает общее количество файлов в 8.
• Параллельная ветвь для w/y/ устанавливает общее количество файлов в 15.
• Параллельная ветвь для w/z/ устанавливает общее количество файлов в 12.

Каждая параллель отменяет работу предыдущей.

Вместо этого заставьте рекурсивную функцию подсчитывать относительные файлы, а затем добавлять к итогу вместо переназначения им. См. ниже — обратите внимание, что я переименовал ваши переменные в relativeX и totalX для большей ясности.

void parRecurse(DirectoryInfo di, ref int totalFolders, ref int totalFiles, ref long totalBytes)
{
    int relativeFolders = 0;
    int relativeFiles = 0;
    long relativeBytes = 0;

    try
    {
        DirectoryInfo[] directories = di.GetDirectories();
        Parallel.ForEach(directories, d =>
        {
            Interlocked.Increment(ref relativeFolders);
            foreach (FileInfo f in d.GetFiles())
            {
                Interlocked.Increment(ref relativeFiles);
                Interlocked.Add(ref relativeBytes, f.Length);
            }
            parRecurse(d, ref relativeFolders, ref relativeFiles, ref relativeBytes);
        });
    }
    catch (UnauthorizedAccessException)
    {
        Console.WriteLine("You do not have access to this directory");
    }

    Interlocked.Add(ref totalFolders, relativeFolders);
    Interlocked.Add(ref totalFiles, relativeFiles);
    Interlocked.Add(ref totalBytes, relativeBytes);
}

Кроме того, после написания различных рекурсивных функций я склоняюсь к созданию класса-контейнера для данных вместо передачи ссылок. Классы передаются по ссылке, что упрощает работу. Что-то вроде этого:

public class FileSystemCountContext
{
    private int _directories = 0;
    private int _files = 0;
    private long _bytes = 0;

    public int Directories => _directories;
    public int Files => _files;
    public long Bytes => _bytes;

    public override string ToString()
    {
        return $"{Directories} directories, {Files} files, {Bytes} bytes";
    }

    public void IncrementDirectories()
    {
        Interlocked.Increment(ref _directories);
    }

    public void IncrementFiles()
    {
        Interlocked.Increment(ref _files);
    }

    public void IncrementBytes(long amount)
    {
        Interlocked.Add(ref _bytes, amount);
    }
}


FileSystemCountContext CountFileSystem(DirectoryInfo directory, bool parallel = false, FileSystemCountContext? context = null)
{
    if (context == null)
    {
        context = new();
    }

    foreach (FileInfo fi in directory.GetFiles())
    {
        context.IncrementFiles();
        context.IncrementBytes(fi.Length);
    }

    if (parallel)
    {
        Parallel.ForEach(directory.GetDirectories(), di =>
        {
            context.IncrementDirectories();
            CountFileSystem(di, parallel, context);
        });
    }
    else
    {
        foreach (DirectoryInfo di in directory.GetDirectories())
        {
            context.IncrementDirectories();
            CountFileSystem(di, parallel, context);
        }
    }

    return context;
}