Merkwürdige Laufzeitunterschiede C# / Delphi 7

wob

Mit scheint nur die Variante mit FileStream.Read sinnvoll zu sein (da der StreamReader wohl für Textdateien gedacht ist - und auch der BinaryReader ein Encoding als Parameter haben will).

Kommt der massive Unterschied vom Lesen großer Dateien oder machst du vielleicht beim Loopen über alle Dateien etwas anders? So ein massiver Geschwindigkeitsunterschied deutet eher darauf hin, dass du irgendwas in C# nicht so machst, wie es gedacht ist (denke ich).

(Achtung: ich habe noch nie mit C# gearbeitet)

Edit: die beiden if (!File.Exists(...)) können weg. Der Stream-Konstruktur wirft doch sowieso eine FileNotFoundException, wenn es die Datei nicht gibt.

Der Code danach mit den vielen Längen und dem goto sieht kompliziert aus. Warum nicht einfach aus beiden Dateien lesen, solange das möglich ist? Lohne sich ein Vergleich wirklich, wenn die Dateien unterschiedliche Länge haben? Muss der Puffer so groß sein? Größer ist nicht unbedingt besser, kann ja irgendwelche Cache-Effekte geben etc - auch ist nicht klar, dass der Buffer-Reuse eine gute Idee ist.

Jockelx

Hi,

was mir so auffällt:
C# und Java beneiden uns um "unsere" C++Destruktoren, deshalb haben sie sich etwas ausgedacht, damit Sie wenigstens etwas in der Richtung haben: nämlich using. Das solltest du nutzen (sowieso), da ich mir nicht sicher bin, ob ein close ausreicht.
Dann würde ich FileStreams nehmen und statt dem Binary

ByPu1.Take(count1).SequenceEqual(ByPu2.Take(count2)

Ansonsten: messen, messen, messen. Wird es langsamer (also was nicht aufgeräumt), sind große Dateien das Problem oder viele Dateien, Blockgrösse ändern,...

hkdd

@Jockelx
Using kann man nicht so einfach benutzen, wenn man zwei Dateien parallel einliest, wie bei einem Compare-Programm erforderlich.
SequenceEqual werde ich probieren.
Mit verschiedenen Puffergrößen habe ich probiert, kleinere Puffer verlängern die Laufzeit, das betrifft aber nur große Dateien.
DANKE für die Hinweise.

@wob
Lohne sich ein Vergleich wirklich, wenn die Dateien unterschiedliche Länge haben
Das kann beim Programm eingestellt werden.
Oftmals macht das keinen Sinn, ich hatte aber auch schon Dateien, wo am Ende etwas angehängt wurde.
In diesem Fall wird in der kürzeren Länge verglichen.

Das Laufzeitproblem hat aber mit dem eigentlich Vergleich nichts zu tun, weil ich ja nichts vergleiche (außer bei Delphi), sondern nur die Dateien einlese. Da gibt es auch keine Dateien mit unterschiedlicher Länge.

Jockelx

@hkdd Warum nicht?

using (var file1 = new FileStream(fileName1, FileMode.Open))
        using (var file2 = new FileStream(fileName2, FileMode.Open))
{
...
}

hkdd

Ich habe ein kleines abgerüstetes Consolen-Programm geschrieben, das auch alle diese Dateien in ähnlicher Weise liest, wie mein anderes Programm. Da fehlt das Lesen der zweiten zu vergleichenden Datei, es gibt keinerlei Fehlerbehandlung usw.
Da dauert das Lesen nur wenige Sekunden.
Hier das Programm (es ist nicht groß)

using System;
using System.IO;
using System.Linq;

namespace AllFilesInDir // Alle Dateien eines Ordners (Kommandozeile) lesen
{
    internal class Program
    {
        public static Int64 GesBytes = 0; // Summe  aller gelesenen Bytes
        public static int AnzDir     = 0; // Anzahl aller Directories incl. Start-Dir
        public static int AnzFiles   = 0; // Anzahl aller gelesenen Dateien
        public static int AnzPuff    = 0; // Anzahl aller gelesenen Puffer
        public const int MaxPuffL = 0x01000000; // 16.777.216 Bytes = Pufferlänge
        public static byte[] ByPu = new byte[MaxPuffL+0x1000]; // Eingabepuffer

        static void Main(string[] args)
        {
            DateTime dtStart= DateTime.Now;  // Start-Zeitpunkt merken
            Console.WriteLine("Start = "+dtStart.ToString());
            string StartPfad = args[0]; // Pfad aus Kommandozeile holen
            PfadVerarbeiten(StartPfad);
            Console.WriteLine(MaxPuffL.ToString("###,###,###,###,###") + " Bytes = Puffergröße");
            Console.WriteLine(GesBytes.ToString("###,###,###,###,###") + " Bytes eingelesen");
            Console.WriteLine(AnzDir.ToString("###,###,###,###,###") + " Directories");
            Console.WriteLine(AnzFiles.ToString("###,###,###,###,###") + " Dateien");
            Console.WriteLine(AnzPuff.ToString("###,###,###,###,###") + " Puffer");
            DateTime dtEnde = DateTime.Now;  // Ende-Zeitpunkt merken
            System.TimeSpan Dauer = dtEnde - dtStart;
            Console.WriteLine("Ende  = " + dtEnde.ToString()+", Dauer = "+Dauer.ToString().Substring(0,10));
            Console.ReadLine(); // Warten auf ENTER
        }
        static void PfadVerarbeiten(string pPfad) // wird rekursiv aufgerufen
        {
            AnzDir++;
            string sPfad = pPfad;
            if (sPfad[sPfad.Length - 1] != '\\') sPfad += "\\"; // ggf. Ende \ anfügen
            DirectoryInfo di = new DirectoryInfo(pPfad);     // Aktuelles Directory
            FileInfo[] fi = di.GetFiles("*.*");              // Dateien im Directory
            int FilesAnz = fi.Count();                       // Anzahl Dateien im Directory
            DirectoryInfo[] ui = di.GetDirectories("*.*");   // Unterordner im Directory
            int DirAnz = ui.Count();                         // Anzahl Unterordner im Directory
            for (int i = 0; i < FilesAnz; i++) // Alle Dateien einlesen
            { LeseDatei(fi[i].FullName, fi[i].Length); }

            for (int i = 0; i < DirAnz; i++) // Alle Unterordner verarbeiten
            { PfadVerarbeiten(ui[i].FullName); } // Rekursiver Aufruf
        }
        static void LeseDatei(string pDsn, Int64 lenFile) 
        {
            AnzFiles++;
            Int64 RestLen = lenFile;
            FileStream fs = new FileStream(pDsn, FileMode.Open, FileAccess.Read);
            Int64 LeseLen = Math.Min(RestLen, MaxPuffL);
            while(LeseLen > 0) 
            {
                GesBytes += LeseLen;
                AnzPuff++;
                fs.Read(ByPu, 0, (int)LeseLen);
                RestLen -= LeseLen;
                LeseLen = Math.Min(RestLen, MaxPuffL);
            }
        }
    }
}

Und hier das Ergebnis

Start = 05.12.2022 14:08:11
16.777.216 Bytes = Puffergröße
18.069.912.569 Bytes eingelesen
770 Directories
15.228 Dateien
16.152 Puffer
Ende  = 05.12.2022 14:08:13, Dauer = 00:00:02.5

Da muss ich doch nach einem Overhead suchen, der irgendwo versteckt liegt.

SeppJ

@hkdd sagte in Merkwürdige Laufzeitunterschiede C# / Delphi 7:

Da muss ich doch nach einem Overhead suchen, der irgendwo versteckt liegt.

Eine der ersten Antworten hier im Thread:

@Quiche-Lorraine sagte in Merkwürdige Laufzeitunterschiede C# / Delphi 7:

Ich würde da mal einen Blick in die Profiling Tools werfen, sofern du Visual Studio verwendest.

hustbaer

@hkdd
Wie @wob schon geschrieben hat macht StreamReader ne Codepage-Konvertierung. Ich vermute mal da wird die Zeit draufgehen.

@hkdd sagte in Merkwürdige Laufzeitunterschiede C# / Delphi 7:

Dabei ist mir nicht klar, ob die Zuweisung
  Binary b1 = new Binary(ByPu1);
den ganzen Pufferinhalt von ByPu1 nach b1 umspeichert (nochmals unsinniger Aufwand)

Vermutlich ja. Kannst du aber ganz einfach rausfinden indem du den Cursor in der Zeile in das Wort Binary reinstellst und F12 drückst.

oder ob man mit fs1.Read statt in ein byte[] Array auch in einen Binary-Puffer lesen kann.
Bei Binary kann man mit b1.Equals(b2) zwei Puffer direkt vergleichen, statt der urtümlichen
for-Schleife Byte für Byte oder externer [DllImport]-Routinen.
Bei Delphi mache ich den Vergleich mit einer Ass-Sequenz.

Vergiss Binary. Das macht intern auch nix anderes als nen Loop in dem es einzeln die Bytes vergleicht. Assembler brauchst du auch nicht wirklich. Du kannst z.B. direkt memcmp der MSVC CRT aufrufen:

        [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
        private static extern int memcmp(byte[] b1, byte[] b2, UIntPtr count);

hustbaer

ps: Wenn du .NET 6 verwenden kannst:

static bool ByteArrayCompare(ReadOnlySpan<byte> a1, ReadOnlySpan<byte> a2)
{
    return a1.SequenceEqual(a2);
}

https://stackoverflow.com/a/48599119/454519

hkdd

@Jockelx
die Klammern {...} beziehen sich doch auf das zweite using.
Eigentlich müsste es so aussehen:

using (var file1 = new FileStream(fileName1, FileMode.Open))
{
        using (var file2 = new FileStream(fileName2, FileMode.Open))
        {
               ...
        }
}

Da fällt es nicht so leicht, das parallele Lesen von file1 und file2 zu synchronisieren.

@hustbaer,
msvcrt habe ich bereits in meinem Programm vorgesehen. Es ist halt auch eine externe [DllImport]-Routine.
SequenceEqual sieht schon besser (da intern) aus.

@Jockelx
Deinen Vorschlag finde ich auch sehr interessant

ByPu1.Take(count1).SequenceEqual(ByPu2.Take(count2)

Ich finde es toll, wie man hier im Forum seine Probleme/Fragen beantwortet bekommt.

Th69

Die Klammern sind normale Block-Klammern, wie bei anderen Anweisungen auch (if, for, while), d.h. bei nur einer folgenden Anweisung können diese entfallen.
Ab C# 8 können sogar die using-Anweisungen ohne Verschachtelung geschrieben werden (und gelten dann bis zum Ende des Blocks, in dem sie sich selbst befinden): using-Deklaration (es entfallen zur Syntaxerkennung dann die runden Klammern).

using var file1 = new FileStream(fileName1, FileMode.Open);
using var file2 = new FileStream(fileName2, FileMode.Open);

// keine Blockklammern mehr nötig