Warum klappt Binary bei mir nicht
-
@Th69
ich habe beide Routinen jeweils zweimal laufen lassen, dabei gibt es kaum einen Unterschied~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs (09.12.2022) - Start = 10.12.2022 14:02:37 Vergleichsmethode = unsafe MemCmp von Th69 MitRead=True, MitComp=True 16.777.216 Bytes = Puffergröße Pfad1=N:\VideosN\, Pfad2=N:\VideosN\ 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 14.071 Puffer 2.446 identische Dateien Ende = 10.12.2022 14:36:56, Dauer = 00:34:18.8 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs (09.12.2022) - Start = 10.12.2022 14:53:03 Vergleichsmethode = unsafe MemCmp von Th69 MitRead=True, MitComp=True 16.777.216 Bytes = Puffergröße Pfad1=N:\VideosN\, Pfad2=N:\VideosN\ 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 14.071 Puffer 2.446 identische Dateien Ende = 10.12.2022 15:25:58, Dauer = 00:32:55.3 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs (09.12.2022) - Start = 10.12.2022 15:29:33 Vergleichsmethode = CompareByteArray (C++ ASM DLL von HK) MitRead=True, MitComp=True 16.777.216 Bytes = Puffergröße Pfad1=N:\VideosN\, Pfad2=N:\VideosN\ 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 14.071 Puffer 2.446 identische Dateien Ende = 10.12.2022 16:02:58, Dauer = 00:33:24.8 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs (09.12.2022) - Start = 10.12.2022 16:04:11 Vergleichsmethode = CompareByteArray (C++ ASM DLL von HK) MitRead=True, MitComp=True 16.777.216 Bytes = Puffergröße Pfad1=N:\VideosN\, Pfad2=N:\VideosN\ 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 14.071 Puffer 2.446 identische Dateien Ende = 10.12.2022 16:37:22, Dauer = 00:33:10.8 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
@hustbaer
ich habe Dein bearbeitetes Programm mit den gleichen Daten laufen lassen - das Ergebnis sieht gut aus~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Start = 10.12.2022 17:02:50 Vergleichsmethode = RtlCompareMemory MitRead=True, MitComp=True 131.072 Bytes = Puffergröße 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 1.589.437 Puffer 0 fehlende Dateien 0 fehlende Unterpfade 0 Dateien mit unterschiedlicher Länge 0 ungleiche Dateien Ende = 10.12.2022 17:28:33, Dauer = 00:25:43.1 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
@hustbaer
Ich habe Deine Routine in mein Compareprogramm eingebaut und bekomme eigentlich die gleichen Ergebnisse.
Mit der kleineren Puffergröße läuft es deutlich schneller, auch die Vergleichsroutine von Th69.
Hier noch ein paar Ergebnisse~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs (09.12.2022) - Start = 10.12.2022 18:22:47 Vergleichsmethode = RtlCompareMemory [DllImport] kernel32.dll MitRead=True, MitComp=True 131.072 Bytes = Puffergröße Pfad1=N:\VideosN\, Pfad2=N:\VideosN\ 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 1.589.437 Puffer 2.446 identische Dateien Ende = 10.12.2022 18:48:31, Dauer = 00:25:44.5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs (09.12.2022) - Start = 10.12.2022 18:50:50 Vergleichsmethode = RtlCompareMemory [DllImport] kernel32.dll MitRead=True, MitComp=True 16.777.216 Bytes = Puffergröße Pfad1=N:\VideosN\, Pfad2=N:\VideosN\ 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 14.071 Puffer 2.446 identische Dateien Ende = 10.12.2022 19:23:14, Dauer = 00:32:24.0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs (09.12.2022) - Start = 10.12.2022 19:26:05 Vergleichsmethode = unsafe MemCmp von Th69 MitRead=True, MitComp=True 131.072 Bytes = Puffergröße Pfad1=N:\VideosN\, Pfad2=N:\VideosN\ 208.144.569.612 Bytes eingelesen 83 Directories 2.446 Dateien 1.589.437 Puffer 2.446 identische Dateien Ende = 10.12.2022 19:52:05, Dauer = 00:25:59.9 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Jetzt habe ich das auch in meinem Delphi-Programm getestet, das ist kein bemerkenswerter Laufzeitunterschied bei veränderter Puffergröße festzustellen
Start 09:12:13 Ende 09:38:37 Dauer 00:26:24 - 16.777.216 Bytes = Puffergröße
Start 15:19:19 Ende 15:45:34 Dauer 00:26:15 - 131.072 Bytes = PuffergrößeDas muss mit C# zusammenhängen.
-
@hkdd
Du könntest auch versuchen beim ÖffnenFileOptions.SequentialScanmitzugeben. Mit dem Asynchronen Vergleich wird es vermutlich nichts bringen. Wenn du synchron vergleichst u.U. schon.Jetzt habe ich das auch in meinem Delphi-Programm getestet, das ist kein bemerkenswerter Laufzeitunterschied bei veränderter Puffergröße festzustellen
Start 09:12:13 Ende 09:38:37 Dauer 00:26:24 - 16.777.216 Bytes = Puffergröße
Start 15:19:19 Ende 15:45:34 Dauer 00:26:15 - 131.072 Bytes = PuffergrößeDas muss mit C# zusammenhängen.
Hm. OK. Dann weiss ich nicht woran es liegt
-
@hustbaer
mit meiner Delphi-Aussage muss ich mich revidieren. Die Puffer-Größe hat doch eine entscheidende Auswirkung.
Hier ein paar meiner Mess-Ergebnisse.Puffergröße Laufzeit in hex Min:Sek 0x010000 2:04 0x020000 1:14 <= 128 * 1024 0x030000 1:00 0x040000 0:56 0x050000 0:51 0x060000 0:47 0x070000 0:43 0x080000 0:41 0x090000 0:44 0x0A0000 0:43 0x0B0000 0:40 0x0C0000 0:42 0x0D0000 0:40 0x0E0000 0:40 0x0F0000 0:40 0x100000 0:37 0x110000 0:39 0x120000 0:38 0x130000 0:41 0x140000 0:37 0x150000 0:37 0x160000 0:38 0x170000 0:28 0x180000 0:25 = 1536 * 1024 0x200000 0:38 0x280000 0:35 0x300000 0:33Ich habe mich jetzt für 0x180000 Bytes entschieden.
Das ist gut in Delphi und in C#.Evtl. hängt das aber auch von der Hardware ab (CPU, RAM, GDD, SSD, m.2 u.a.m.).
@hustbaer sagte in Warum klappt Binary bei mir nicht:
Mit dem Asynchronen Vergleich wird es vermutlich nichts bringen. Wenn du synchron vergleichst u.U. schon.
Was meinst Du damit ?
Ich lese Datei1 in Puffer1 und Datei2 in Puffer , danach Vergleich Puffer 1 mit 2, und danach wieder Datei1 in Puffer1 usw.Hier die Ergebnisse der C#- und der Delphi-Version
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompHKw - Dateien Vergleichen - (C) 12.12.2022 Hartmut aus Dresden ------------------------------------------------------------------- Parameter: "N:\VideosN" "N:\VideosN" "/U" "/VN" "/F" "/M:200" "/A" ------------------------------------------------------------------- Vergleich: N:\VideosN\ D E L P H I - V E R S I O N mit: N:\VideosN\ ~~~~~~~~~~~~~~~~~~~~~~~ 2.446.Datei: N:\VideosN\Youtube-HK\...den 1971\zz09 So scheid ich denn (Finale).mp4 ================================================================= 82 Unter-Pfade gefunden - identisch. 2.446 Dateien gefunden - und verglichen... 2.446 Dateien verglichen - identisch. Es wurden 208.144.569.612 Bytes = 203.266.181 K-Bytes verglichen Start 18:51:31 Ende 19:18:00 Dauer 00:26:29 ========================================================<Ende>=== Linke MausTaste / ESC = Schließen Rechte MausTaste / F1 = Info ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs - Dateien vergleichen - (C) 12.12.2022 Hartmut aus Dresden --------------------------------------------------------------- Parameter: N:\VideosN N:\VideosN --------------------------------------------------------------- Vergleich: N:\VideosN\ C # - V E R S I O N mit: N:\VideosN\ Th69 Vergleichs-Methode ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ============================================================ 82 Unterordner gefunden 2.446 Dateien gefunden - davon 2.446 identische Dateien verglichen. Es wurden 208.144.569.612 Bytes = 203.266.181 K-Bytes verglichen. 133.902 Puffer gelesen, Pufferlänge: 1.572.864 Bytes. Start 19:24:40 Ende 19:50:57 Dauer 00:26:17.5 ===================================================<Ende>=== ESC = Programm beenden ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
@hkdd sagte in Warum klappt Binary bei mir nicht:
@hustbaer
mit meiner Delphi-Aussage muss ich mich revidieren. Die Puffer-Größe hat doch eine entscheidende Auswirkung.
Hier ein paar meiner Mess-Ergebnisse.Puffergröße Laufzeit in hex Min:Sek 0x010000 2:04 0x020000 1:14 <= 128 * 1024 0x030000 1:00 0x040000 0:56 0x050000 0:51 0x060000 0:47 0x070000 0:43 0x080000 0:41 0x090000 0:44 0x0A0000 0:43 0x0B0000 0:40 0x0C0000 0:42 0x0D0000 0:40 0x0E0000 0:40 0x0F0000 0:40 0x100000 0:37 0x110000 0:39 0x120000 0:38 0x130000 0:41 0x140000 0:37 0x150000 0:37 0x160000 0:38 0x170000 0:28 0x180000 0:25 = 1536 * 1024 0x200000 0:38 0x280000 0:35 0x300000 0:33Ich habe mich jetzt für 0x180000 Bytes entschieden.
Das ist gut in Delphi und in C#.Evtl. hängt das aber auch von der Hardware ab (CPU, RAM, GDD, SSD, m.2 u.a.m.).
Ja, vermutlich. Was auch mit reinspielt ist ob du zwei Verzeichnisse auf dem selben Datenträger vergleichst oder zwei Verzeichnisse auf verschiedenen Datenträgern. Speziell wenn beide Verzeichnisse auf der selben HDD steht werden sehr grosse Puffer vermutlich viel bringen. Wenn es dagegen verschiedene Datenträger sind oder die Daten von einer SSD kommen sollte eine Puffergrösse zwischen 64k und 1 MB ausreichend sein.
@hustbaer sagte in Warum klappt Binary bei mir nicht:
Mit dem Asynchronen Vergleich wird es vermutlich nichts bringen. Wenn du synchron vergleichst u.U. schon.
Was meinst Du damit ?
Ich lese Datei1 in Puffer1 und Datei2 in Puffer , danach Vergleich Puffer 1 mit 2, und danach wieder Datei1 in Puffer1 usw.Mit
FileOptions.SequentialScanteilst du dem OS mit dass du vor hast die Datei linear zu lesen. Das OS sollte dann dafür sorgen dass die nächsten Stücke der Datei bereits im Hintergrund gelesen werden, bevor dein Programm sie anfordert ("read ahead"). Wenn du wie in der von mir veränderten Version den Vergleich asynchron in einem eigenen Thread machst, dann wird das nicht viel bringen. Weil ja der Haupt-Thread sofort das nächste Datenstück anfordert. Wenn du dagegen den Vergleich im selben Thread machst wie das Lesen kann das viel bringen. Weil das OS dann eben während dein Programm den Vergleich ausführt bereits das nächste Datenstück von der HDD/SSD anfordert.Allerdings sollte das OS auch schlau genug sein zu erkennen dass du die Datei linear liest, ohne dass du
FileOptions.SequentialScanverwendest. Das kann aber wiederrum abhängig von der Puffergrösse sein. Auf Linux z.B. bekommst du AFAIK read-ahead per Default nur mit Puffergrössen bis max. 128 kB.
-
Wenn die Verzeichnisse auf unterschiedlichen Datenträgern liegen könnte folgende Änderung nochmal einiges bringen:
using (var fs1 = new FileStream(pDsn1, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) using (var fs2 = new FileStream(pDsn2, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) { // ... // ... p.Length = (int)LeseLen; var r1 = fs1.ReadAsync(p.Buffer1, 0, (int)LeseLen); fs2.Read(p.Buffer2, 0, (int)LeseLen); r1.Wait(); if (MitComp) // ...Mit kleinen Puffern macht das die Sache bei mir langsamer, aber mit ~1MB Puffern bringt es bei mir nochmal ne deutliche Beschleunigung.
-
Jetzt müsste man nur noch eine Funktion finden, welche automatisch für die lokale Gegebenheit die beste Puffergröße ermittelt.
-
@hustbaer sagte in Warum klappt Binary bei mir nicht:
using (var fs2 = new FileStream(pDsn2, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan))
Wenn ich diese Parameter hinzufüge ( 4 und 5)
FileStream fs2 = new FileStream(pDsn2, FileMode.Open, FileAccess.Read, 4096, FileOptions.SequentialScan);dann wird für (4) = 4096 angezeigt: CS1503: Konvertierung von int in System.IO.FileShare nicht möglich.
und für (5) = FileOptions.SequentialScan wird angezeigt:
CS1503: Konvertierung von System.IO.FileOptions in int nicht möglich.Mit ALT+Eingabe wird das Statement folgendermaßen korrigiert
FileStream fs2 = new FileStream(pDsn2, FileMode.Open, FileAccess.Read, (FileShare)4096, (int)FileOptions.SequentialScan);Beim Ausführen erhalte ich allerdings einen Fehler:
System.ArgumentOutOfRangeException: "Der Enumerationswert lag außerhalb des gültigen Bereichs. Parametername: share"Ich benutze allerdings kein USING.
-
@hkdd
Du hastFileShare.Readunterschlagen.
-
@hustbaer
JA, das war es - trotz meiner neuen Linsen in den Augen habe ich das übersehen.
Was bedeuten diese 4096, ist das der Lesepuffer oder nimmt Read dann die angegebene Anzahl Bytes zum lesen ?
-
Was bedeuten diese 4096, ist das der Lesepuffer oder nimmt Read dann die angegebene Anzahl Bytes zum lesen ?
Das ist die Grösse für den internen Puffer der File-Streams. Wenn kleinere Lese bzw. Schreib-Operationen gemacht werden, dann gehen die über den Puffer. Oft liest bzw. schreibt man Dateien ja in kleinen Stücken, da bringt das dann einiges.
Lese bzw. Schreib-Operationen die grösser als der interne Puffer sind werden allerdings direkt an die OS Funktionen weitergeleitet. Für dein Programm ist der Puffer also irrelevant. Alle Konstruktoren wo man
FileOptionsangeben kann erfordern allerdings dass man die Puffergrösse angibt. Also hab ich einfach den Default-Wert von 4096 genommen.
-
@hkdd sagte in Warum klappt Binary bei mir nicht:
Ich benutze allerdings kein USING.
Macht in dem Fall keinen Unterschied. Bloss: wieso verwendest du es nicht?
-
@hustbaer
Ein wenig schneller scheint es zu sein. Das erste Ergebnis ist von gestern und das zweite von heute~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ============================================================ 82 Unterordner gefunden 2.446 Dateien gefunden - davon 2.446 identische Dateien verglichen. Es wurden 208.144.569.612 Bytes = 203.266.181 K-Bytes verglichen. 133.902 Puffer gelesen, Pufferlänge: 1.572.864 Bytes. Start 19:24:40 Ende 19:50:57 Dauer 00:26:17.5 ===================================================<Ende>=== ESC = Programm beenden ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ CompCs - Dateien vergleichen - (C) 12.12.2022 Hartmut aus Dresden --------------------------------------------------------------- Parameter: N:\VideosN N:\VideosN --------------------------------------------------------------- Vergleich: N:\VideosN\ mit: N:\VideosN\ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ============================================================ 82 Unterordner gefunden 2.446 Dateien gefunden - davon 2.446 identische Dateien verglichen. Es wurden 208.144.569.612 Bytes = 203.266.181 K-Bytes verglichen. 133.902 Puffer gelesen, Pufferlänge: 1.572.864 Bytes. Start 16:08:58 Ende 16:34:20 Dauer 00:25:22.0 ===================================================<Ende>=== ESC = Programm beenden ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Ich habe versucht bei den beiden FileStream Anweisungen USING davor zu schreiben und nach dem zweiten Using den Rest mit {...} einzuklammern - das klappt aber nicht. Ohne USING - alles ist OK.
//================================================= // Datei 1 und 2 lesen und vergleichen //================================================= private bool VergleicheDateien(string pDsn1, string pDsn2, Int64 lenFile, string pPfad) { bool rc; Int64 RestLen = lenFile; // Dateilänge beider Dateien Int64 LeseLen = Math.Min(RestLen, MaxPuffL); FileStream fs1 = new FileStream(pDsn1, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan); FileStream fs2 = new FileStream(pDsn2, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan); while (LeseLen > 0) { Application.DoEvents(); if (Abbruch > 0) { return false; } GesBytes += LeseLen; // Anzahl gelesene Bytes gesamt this.Text = "CompHk " + GesBytes.ToString("###,###,###,###,##0") + " Bytes " + pPfad; fs1.Read(ByPu1, 0, (int)LeseLen); fs2.Read(ByPu2, 0, (int)LeseLen); AnzPuff++; // Anzahl verglichene Puffer if (LeseLen < 9) { for (int b = 0; b < LeseLen; b++) { if (ByPu1[b] != ByPu2[b]) { goto VerglErr; // Vergleich abbrechen } } break; } switch (VergleichsMethode) // Welche Art des Vergleiches { case compSequenceEqual: // C# interne Funktion if (!(ByPu1.Take((int)LeseLen).SequenceEqual(ByPu2.Take((int)LeseLen)))) { goto VerglErr; // Vergleich abbrechen } break; case compMemCmp: // [DllImport] msvcrt.dll if (memcmp(ByPu1, ByPu2, LeseLen) != 0) { goto VerglErr; // Vergleich abbrechen } break; case compForNxt: // C# interner Byte-für-Byte-Vergleich for (int b = 0; b < LeseLen; b++) { if (ByPu1[b] != ByPu2[b]) { goto VerglErr; // Vergleich abbrechen } } break; case compUnsafe: // unsafe MemCmp if (!MemCmp(ByPu1, ByPu2, (int)LeseLen)) { goto VerglErr; // Vergleich abbrechen } break; case compRtlCompareMemory: // [DllImport] kernel32.dll RtlCompareMemory IntPtr len = (IntPtr)LeseLen; //IntPtr rc = RtlCompareMemory(ByPu1, ByPu2, len); var rCod = RtlCompareMemory(ByPu1, ByPu2, len); if (rCod != len) { goto VerglErr; // Vergleich abbrechen } break; case compCompareByteArray: // [DllImport] CompareByteArray.dll von HK if (CompareByteArray(ByPu1, ByPu2, (int)LeseLen) != 0) { goto VerglErr; // Vergleich abbrechen } break; } // switch (VergleichsMethode) RestLen -= LeseLen; LeseLen = Math.Min(RestLen, MaxPuffL); } // while (LeseLen > 0) AnzFilesOK++; rc = true; goto UpEnde; // Vergleich abbrechen VerglErr: ByteDiff++; // es gibt Differenzen rc = false; UpEnde: fs1.Close(); fs2.Close(); return rc; } // static bool VergleicheDateien(string pDsn1, string pDsn2, Int64 lenFile)
-
@hkdd
Hab's nicht ausprobiert, aber ich nehme an der Grund für die Fehler ist dass dugotos verwendest. Ich würde empfehlen aufgotozu verzichten. Weiters wäre es praktisch die eigentliche Vergleichs-Funktion vom Rest des Programms zu entkoppeln. z.B. von der Aktualisierung des User-Interface und dem Test ob abgebrochen werden soll. Könnte dann z.B. so aussehen:private bool VergleicheDateien(string pDsn1, string pDsn2, Int64 lenFile, string pPfad) { int res = VergleicheDateien0(pDsn1, pDsn2, lenFile, leseLen => { Application.DoEvents(); if (Abbruch > 0) { return false; } GesBytes += leseLen; // Anzahl gelesene Bytes gesamt AnzPuff++; // Anzahl verglichene Puffer this.Text = "CompHk " + GesBytes.ToString("###,###,###,###,##0") + " Bytes " + pPfad; return true; }); switch (res) { case 0: ByteDiff++; return false; case 1: AnzFilesOK++; return true; default: return false; } } private int VergleicheDateien0(string pDsn1, string pDsn2, Int64 lenFile, Func<long, bool> fortschrittsCallback) { Int64 RestLen = lenFile; // Dateilänge beider Dateien Int64 LeseLen = Math.Min(RestLen, MaxPuffL); using (FileStream fs1 = new FileStream(pDsn1, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) using (FileStream fs2 = new FileStream(pDsn2, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) { while (LeseLen > 0) { if (!fortschrittsCallback(LeseLen)) { return -1; } fs1.Read(ByPu1, 0, (int)LeseLen); fs2.Read(ByPu2, 0, (int)LeseLen); if (LeseLen < 9) { for (int b = 0; b < LeseLen; b++) { if (ByPu1[b] != ByPu2[b]) { return 0; } } break; } switch (VergleichsMethode) // Welche Art des Vergleiches { case compSequenceEqual: // C# interne Funktion if (!(ByPu1.Take((int)LeseLen).SequenceEqual(ByPu2.Take((int)LeseLen)))) { return 0; } break; case compMemCmp: // [DllImport] msvcrt.dll if (memcmp(ByPu1, ByPu2, LeseLen) != 0) { return 0; } break; case compForNxt: // C# interner Byte-für-Byte-Vergleich for (int b = 0; b < LeseLen; b++) { if (ByPu1[b] != ByPu2[b]) { return 0; } } break; case compUnsafe: // unsafe MemCmp if (!MemCmp(ByPu1, ByPu2, (int)LeseLen)) { return 0; } break; case compRtlCompareMemory: // [DllImport] kernel32.dll RtlCompareMemory IntPtr len = (IntPtr)LeseLen; //IntPtr rc = RtlCompareMemory(ByPu1, ByPu2, len); var rCod = RtlCompareMemory(ByPu1, ByPu2, len); if (rCod != len) { return 0; } break; case compCompareByteArray: // [DllImport] CompareByteArray.dll von HK if (CompareByteArray(ByPu1, ByPu2, (int)LeseLen) != 0) { return 0; } break; } // switch (VergleichsMethode) RestLen -= LeseLen; LeseLen = Math.Min(RestLen, MaxPuffL); } // while (LeseLen > 0) return 1; } }Die neue Funktion
VergleicheDateien0ist jetzt völlig unabhängig vom User-Interface. Was viele Vorteile hat, z.B. dass man sie dadurch unabhängig vom User-Interface testen kann.
-
ps:
Hast duReadAsyncauch mal ausprobiert?var r1 = fs1.ReadAsync(ByPu1, 0, (int)LeseLen); fs2.Read(ByPu2, 0, (int)LeseLen); r1.Wait();
-
@hustbaer
leider bin ich kein so ausgefuchster Programmierer, wie Du, aber ich kann viel von Dir lernen - DANKE dafür und auch an all die anderen hier im Forum.
Ich habe jetzt erst einmal die USINGs eingebaut und die GOTOs entfernt. Braucht man bei USING keine CLOSE mehr ?
ReadAsync werde ich nun auch noch ausprobieren, ob damit noch ein paar Sekunden herauszuholen sind.//================================================= // Datei 1 und 2 lesen und vergleichen //================================================= private bool VergleicheDateien(string pDsn1, string pDsn2, Int64 lenFile, string pPfad) { bool rc = true; Int64 RestLen = lenFile; // Dateilänge beider Dateien Int64 LeseLen = Math.Min(RestLen, MaxPuffL); using (FileStream fs1 = new FileStream(pDsn1, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) using (FileStream fs2 = new FileStream(pDsn2, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, FileOptions.SequentialScan)) { while (LeseLen > 0 && rc) { Application.DoEvents(); if (Abbruch > 0) { return false; } GesBytes += LeseLen; // Anzahl gelesene Bytes gesamt this.Text = "CompHk " + GesBytes.ToString("###,###,###,###,##0") + " Bytes " + pPfad; fs1.Read(ByPu1, 0, (int)LeseLen); fs2.Read(ByPu2, 0, (int)LeseLen); AnzPuff++; // Anzahl verglichene Puffer if (LeseLen < 9) { for (int b = 0; b < LeseLen; b++) { if (ByPu1[b] != ByPu2[b]) { rc = false; // Es gibt Differenzen, Vergleich abbrechen } } break; } switch (VergleichsMethode) // Welche Art des Vergleiches { case compSequenceEqual: // C# interne Funktion if (!(ByPu1.Take((int)LeseLen).SequenceEqual(ByPu2.Take((int)LeseLen)))) { rc = false; // Es gibt Differenzen, Vergleich abbrechen } break; case compMemCmp: // [DllImport] msvcrt.dll if (memcmp(ByPu1, ByPu2, LeseLen) != 0) { rc = false; // Es gibt Differenzen, Vergleich abbrechen } break; case compForNxt: // C# interner Byte-für-Byte-Vergleich for (int b = 0; b < LeseLen; b++) { if (ByPu1[b] != ByPu2[b]) { rc = false; // Es gibt Differenzen, Vergleich abbrechen } } break; case compUnsafe: // unsafe MemCmp if (!MemCmp(ByPu1, ByPu2, (int)LeseLen)) { rc = false; // Es gibt Differenzen, Vergleich abbrechen } break; case compRtlCompareMemory: // [DllImport] kernel32.dll RtlCompareMemory IntPtr len = (IntPtr)LeseLen; //IntPtr rc = RtlCompareMemory(ByPu1, ByPu2, len); var rCod = RtlCompareMemory(ByPu1, ByPu2, len); if (rCod != len) { rc = false; // Es gibt Differenzen, Vergleich abbrechen } break; case compCompareByteArray: // [DllImport] CompareByteArray.dll von HK if (CompareByteArray(ByPu1, ByPu2, (int)LeseLen) != 0) { rc = false; // Es gibt Differenzen, Vergleich abbrechen } break; } // switch (VergleichsMethode) RestLen -= LeseLen; LeseLen = Math.Min(RestLen, MaxPuffL); } // while (LeseLen > 0 && rc) } if (rc) { AnzFilesOK++; } // es gibt keine Differenzen else { ByteDiff++; } // es gibt Differenzen //fs1.Close(); //fs2.Close(); return rc; } // static bool VergleicheDateien(string pDsn1, string pDsn2, Int64 lenFile)
-
@hustbaer sagte in Warum klappt Binary bei mir nicht:
var r1 = fs1.ReadAsync(ByPu1, 0, (int)LeseLen);
fs2.Read(ByPu2, 0, (int)LeseLen);
r1.Wait();var r1 = fs1.ReadAsync(ByPu1, 0, (int)LeseLen);r1 ist m.E. doch die zurück gegebene tatsächlich gelesene Länge, also ein int-Wert.
Macht r1.Wait() dann einen Sinn ?In den gefundenen ReadAsync Beispielen sieht es etwa so aus
var r1ReadLen = await fs1.ReadAsync(ByPu1, 0, (int)LeseLen);
-
@hkdd sagte in Warum klappt Binary bei mir nicht:
Braucht man bei USING keine CLOSE mehr ?
Nein braucht man nicht dafür ist das using da, damit man nicht vergessen kann close/dispose aufzurufen.
Besonders falls eine exception geworfen wird, wird durch das using statemant definitiv immer beim verlassen des blocks close/dispose aufgerufen.
-
@hkdd sagte in Warum klappt Binary bei mir nicht:
var r1 = fs1.ReadAsync(ByPu1, 0, (int)LeseLen);r1 ist m.E. doch die zurück gegebene tatsächlich gelesene Länge, also ein int-Wert.
Macht r1.Wait() dann einen Sinn ?In den gefundenen ReadAsync Beispielen sieht es etwa so aus
var r1ReadLen = await fs1.ReadAsync(ByPu1, 0, (int)LeseLen);Alle asynchronen Methoden liefern ein Task (für
void) oder Task<T>-Objekt zurück, auch Stream.ReadAsync.
Der eigentliche Rückgabewert steht dann in Result.
