4. Files überschreiben

Files überschreiben

  • S
     

    BOOL ( WINAPI Mine_DeleteFileW )( LPCTSTR lpFileName ){
	std::wstring FileName = lpFileName;
	HANDLE hFile = CreateFileW( FileName.c_str(),
								FILE_ALL_ACCESS, 
								NULL, 
								NULL, 
								OPEN_EXISTING,
								FILE_ATTRIBUTE_NORMAL,
								NULL );
	if ( hFile == INVALID_HANDLE_VALUE){
		OutputDebugStringW(L"File handle couldnt be opened");
	}else{
		__int64 Size;
		if ( !GetFileSizeEx( hFile, (PLARGE_INTEGER)&Size ) ){
			OutputDebugStringW(L"Couldnt optain size of file");
		}else{
			OutputDebugStringA(IntToString(Size).c_str());
			char * Buffer;
			int NumWritten;
			const int BufferSize = 1048576;// 1Mb	
			if ( Size >= BufferSize ){
				__int64 Rounds = Size / BufferSize;
				OutputDebugStringA((IntToString(Rounds) + (std::string)" Rounds").c_str());
				int Rest = ( Size - ( Rounds * BufferSize ) );
				OutputDebugStringA((IntToString(Rest) + (std::string)" Rest").c_str());
				Buffer = new char[BufferSize];
				std::fill(Buffer,Buffer+BufferSize,0);
				LARGE_INTEGER Num;
				Num.QuadPart = BufferSize;
				for ( __int64 i = 0; i < Rounds; i++ ){
					if ( !WriteFile( hFile, Buffer, BufferSize, (PDWORD)&NumWritten, NULL ) ){
						OutputDebugStringW(L"Write file broke inside loop");
						break;
					}
					if ( NumWritten != BufferSize )OutputDebugStringA(((std::string)"Wrote to less in Round : " + IntToString(i) ).c_str());
					if ( !SetFilePointerEx( hFile, Num, NULL, FILE_CURRENT ) ){
						OutputDebugStringW(L"SetFilePointer failed");
					}

				}
				delete[] Buffer;
				if ( Rest != 0 ){
					Buffer = new char[Rest];
					std::fill(Buffer,Buffer+Rest,0);
					if ( !WriteFile( hFile, Buffer, Rest, (PDWORD)&NumWritten, NULL ) ){
						OutputDebugStringW(L"Write file broke inside rest");
					}
					if ( NumWritten != BufferSize )OutputDebugStringW(L"Wrote too less inside rest!");	
					delete[] Buffer;
				}
			}else{
				Buffer = new char[Size];
				std::fill(Buffer,Buffer+Size,0);
				if ( !WriteFile( hFile, Buffer, Size, (PDWORD)&NumWritten, NULL ) ){
					OutputDebugStringW(L"Write file broke inside small version");
				}
				if ( NumWritten != BufferSize )OutputDebugStringW(L"Wrote too less in small!");
				delete[] Buffer;
			}
			FileName += L" was safe deleted : Wide";
			OutputDebugStringW(FileName.c_str());
		}
		CloseHandle(hFile);
	}

	return false;//Real_DeleteFileW(lpFileName);
}

    Hi, also ich dachte ich hätte den fehler selbst gefunden, aber es ist leider nicht so :(...

    Der quellcode wie er jetzt ist überschreibt nur immer einen teil der Datei richtig, aber nie ganz. Weiß jemand von euch villeicht wieso?

    Edit:
    Also hab bemerkt das die files beim schreiben wachsen, kann das sein das der hinzufügt anstatt überschreibt o.o?

    0
  • _

    Ich glaube, statt OPEN_EXISTING musst du TRUNCATE_EXISTING nehmen. Probier's mal...

    0
  • S

    Ja, aber ich brauch ja die frühere größe der datei, und wenn ich das so machen muss ich 2x create file aufrufen, und das nimmt ja mehr zeit in anspruch 😞

    0
  • S

    Also das mit den 2 Create File aufrufen hab ich probiert, wenn ich das erste aufruf, dann die größe ermittel, CloseHandle drauf mach, und das zweite aufruf, krieg ich nur INVALID HANDLE

    0
  • Mod

    Was soll den das mit SetFilePointer? WriteFile justiert doch den File-Pointer?
    IMHO überspringst Du damit einen Block.

    Weiterhin macht es IMHO keinen sinn einen 1mb Block zu schreiben. Du kannst genausogut 4kb Blöcke schreiben, das wird IMHO nicht schneller.

    0
  • S

    Danke für den hinweiß mit dem Block überspringen, jetzt gehts übrigens. Aber ich hab die erfahrung gemacht das 2x 1mb buffer schreiben schneller geht als ( 2 mb / 4kb ) mal schreiben

    0
  • Mod

    Liegt wahrscheinlich im Millisekunden Bereich. Dafür blähst Du Dein Programmm mit einer unnötigen Speicheranforderung auf.

    0
  • B

    Martin Richter schrieb:

    Liegt wahrscheinlich im Millisekunden Bereich. Dafür blähst Du Dein Programmm mit einer unnötigen Speicheranforderung auf.

    ... und auch das soll man tunlichst vermeiden ...
    Hat was mit Optimierung zu tun. Man kann nur entweder nach Laufzeit oder nach Speicherbedarf optimieren. Wenn es um Millisekunden geht, erscheint mir jede Optimierung nach der Laufzeit unsinnig.

    0
  • Mod

    berniebutt schrieb:

    Martin Richter schrieb:

    Liegt wahrscheinlich im Millisekunden Bereich. Dafür blähst Du Dein Programmm mit einer unnötigen Speicheranforderung auf.

    ... und auch das soll man tunlichst vermeiden ...
    Hat was mit Optimierung zu tun. Man kann nur entweder nach Laufzeit oder nach Speicherbedarf optimieren. Wenn es um Millisekunden geht, erscheint mir jede Optimierung nach der Laufzeit unsinnig.

    100% ACK!

    0
  • S

    so, ich hab ja als erstes gesagt dieses projekt von mir spielt sich im rahmen eines addins für den explorer ab, und dort sind file größen von > 4 gb keine seltenheit also hab ich hier mal nen beispiel gemacht mit 200mb.

    edit: ups das war in nem anderen post . sag ichs halt jetzt 😃

    //---------------------------------------------------------------------------

#pragma hdrstop
#include <windows.h>
#include <iostream>
#include <string>
using namespace std;
//---------------------------------------------------------------------------

#pragma argsused
int main(int argc, char* argv[])
{
  __int64 Frequency, Start, End;

  if (!QueryPerformanceFrequency((LARGE_INTEGER*)&Frequency))
    return 0;
	string FileName = "Datei.txt";
	HANDLE hFile = CreateFile( FileName.c_str(),
								FILE_ALL_ACCESS,
								NULL,
								NULL,
								CREATE_NEW,
								FILE_ATTRIBUTE_NORMAL,
								NULL );
	if ( hFile == INVALID_HANDLE_VALUE){
		cout << "File handle couldnt be opened to write file\n";
	}
  char * Buffer;
  int NumWritten;
  int BufferSize = 1048576;
  int Rounds = 200; // 200 mb.
  for ( int n = 0; n < 2; n++ ){
    Buffer = new char[BufferSize];
    std::fill(Buffer,Buffer+BufferSize,0);
    QueryPerformanceCounter((LARGE_INTEGER*)&Start);
    for ( int i = 0; i < Rounds; i++ ){
      if ( !WriteFile( hFile, Buffer, BufferSize, (PDWORD)&NumWritten, NULL ) ){
        cout << "Write file failed\n";
      }
      if ( NumWritten != BufferSize )
        cout << "Wrote too less inside rest!\n";
    }
    QueryPerformanceCounter((LARGE_INTEGER*)&End);
    cout << "Zeit: " << ( End - Start ) / (double)Frequency  << " Buffer: " << BufferSize << endl ;
    delete[] Buffer;
    BufferSize = 1024;// 200mb mit 1kbyte buffer
    Rounds = 204800;
  }
  CloseHandle(hFile);

  return 0;
}
//---------------------------------------------------------------------------

    Ausgabe:
    Zeit: 5.86576 Buffer: 1048576
    Zeit: 11.4128 Buffer: 1024

    das ist der unterschied den ich erkenne bei 200mb, korrigiert mich bitte wenn ich was falsch gemacht habe ❤ ( Zeit in sekunden )

    0
  • B

    Eine Datei mit mehr als 4 gB ist kein peanut. Da musst Du wohl eher nach der Laufzeit mit grösserem buffer optimieren. Du hast das Problem erkannt. Wie sollen wir da helfen? Zum Glück sind Speicheranforderungen heute kein grosses Hindernis mehr.

    0
  • S

    Ich wollt die millisekunden differenz nur nicht auf mir sitzen lassen 🙂

    0
  • B

    Sei doch bitte nicht gleich pikiert wegen der Millisekunden. Bei mehreren Sekunden kann die Frage schon interessant sein. Vielleicht teilst Du mal mit, was und wieviel sich ändern kann und ob Datenblöcke gekürzt oder eingeschoben werden müssen.

    0
Anmelden zum Antworten