Gravierende Geschwindigkeitsunterschiede bei System.IO zwischen Win 7 und Win XP

Hallo,
ich bin ziemlich neu in C# und habe eine ConsoleApp geschrieben welche nach bestimmten Ordnern sucht und diese löscht.

In Win 7 (64 bit 4GB Ram) löscht das Teil 1,5 GB in 2-4 Sekunden und die MB anzeige schießt hoch.
Bei XP (32 bit 2GB / 3GB Ram) löscht das Teil SEHR langsam und ich kann praktisch mitsehen welchen Ordner er gerade löscht da er so lange braucht.

Ich weiß nicht woran es liegen könnte, villeicht kann mir ja hier jemand weiterhelfen, wäre super..

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;


namespace ConsoleApplication1
{
    class Program
    {

        static double cleaned_mb;

        static void Main (string[] args)
        {
            for (int i = 0; i < args.Length; i++)
            {
                getDirs (args[i] + @"\TestDataFolder");
            }


            Console.Clear ();
            Console.WriteLine ("****************************************************************");
            Console.WriteLine ("***      DATA CLEANER 1.0                                    ***");
            Console.WriteLine ("****************************************************************");
            Console.WriteLine ("CURR DIR: FINISHED");
            Console.WriteLine ("CLEANED SPACE: " + Convert.ToString (cleaned_mb + " MB"));
            Console.WriteLine ("****************************************************************");
            Console.ReadLine ();
        }



        static void getDirs (string path)
        {
            string[] directories = Directory.GetDirectories (path);

            foreach (string directory in directories)
            {
                if (Path.GetFileName (directory).Length > 5)
                {
                    if (Path.GetFileName (directory).Substring (0, 5) == "2010-" && Path.GetFileName (directory).IndexOf ("_") != 0 || Path.GetFileName (directory).Substring (0, 5) == "2011-" && Path.GetFileName (directory).IndexOf ("_") != 0)
                    {
                        try
                        {
                            cleaned_mb += GetDirectorySize (directory);

                            Console.Clear ();
                            Console.WriteLine ("****************************************************************");
                            Console.WriteLine ("***      DATA CLEANER 1.0                                    ***");
                            Console.WriteLine ("****************************************************************");
                            Console.WriteLine ("CURR DIR: " + directory);
                            Console.WriteLine ("CLEANED SPACE: " + Convert.ToString (cleaned_mb + " MB"));
                            Console.WriteLine ("*****************************************************************");
                            Directory.Delete (directory, true);
                        }
                        catch (Exception ex)
                        {
                            cleaned_mb -= GetDirectorySize (directory);
                            Console.WriteLine (ex.Message);
                        }
                    }
                }
                try
                {
                    if (Directory.Exists (directory))
                        getDirs (directory);
                }
                catch (Exception ex)
                {
                    Console.WriteLine (ex.Message);
                }
            }
        }

        static double GetDirectorySize (string p)
        {
            string[] a = Directory.GetFiles (p, "*.*");
            double b = 0;
            foreach (string name in a)
            {
                FileInfo info = new FileInfo (name);
                b += info.Length;
            }

            if (b != 0)
                b /= 1048576;

            return b;
        }

    }
}

Je nachdem ob du einen Debugger dran hängen hast oder nicht und ob du in der Debug-Version oder Release-Version kompiliert hast kann das schon ausschlaggebend sein.

Hallo,

da die Informationen, die Dir die einzelnen Info-Objekte von System.IO liefern, sehr umfangreich sind, ist das auslesen und agieren auch dementsprechend "langsam" - besonders übers Netzwerk.

Ich bin daher dahin übergegangen eine Lib zu erstellen, die System.IO nachbilder, aber direkt die WinAPI nutzt, da ich die meisten Werte, die mir FileInfo liefert, eh nicht benötige.
Hier reden wir besonders beim Durchsuchen von Netzwerken von dem Faktor 800.

Dass sich aber bei Win7 und XP einiges bei Dateioperationen unterscheidet bzw weiterentwickelt wurde, ist bekannt.
Es ist auch direkt über die WinAPI der Fall, dass XP hier langsamer ist.

Wenn Du aber nun von 10 Minuten redest, könnte es auch sein, dass der Virenscanner auf der Maschine Dir dazwischen schießt, oder die Platte nen Hau hat.

Gruß

Ich habe die Release Version verwendet. Auf beiden Rechner natürlich exakt diesselbe Datei.

@Abt, ok möglicherweiße sollte ich es mal direkt über die WinApi versuchen wobei ich noch nie in C# mit Apis gearbeitet habe, villeicht hast du ja einen Link für mich?
edit// ne hab schon was gutes gefunden, danke

Und danke 😃

Lg

Versuche es einmal mit den Enumerate* Methoden der Directory Klasse(ab .net 4.0). Das sollte vor allem bei vielen Dateien mehr Performance bringen.

Tix, kann Dir leider meine Lib dazu nicht zur Verfügung stellen. Erlaubt mein Arbeitgeber verständlicherweise nicht.
Aber A Faster Directory Enumerator verwendet zumindest die gleichen API-Schnittstellen, wie ich es tue.

Die neuen Enumerate-Methoden, wie sie marsgk angesprochen hat, sind zwar schneller als die Get-Methoden. Aber immernoch um längen langsamer als über FindFirstFile() oder gar die Shell.

@Abt:
Du hattest die Lib von Uwe Keim ( Zeta ) gesehen?

Da kommen die Routinen auch mit langen Pfaden zurecht.

Ich weiß grad ehrlich gesagt nicht, was Du meinst, FZelle 🤔
"Mit langen Pfaden zurecht kommen" ist nicht immer gleich eine Lösung, die mit allem klappt. Manche Filer kommen damit nicht zurecht oder haben andere, kuriose Anfälligkeiten bei Unc-Pfaden.