Dateien erstellen

[Meflin]

hallo,

wie kann ich eine datei einer beliebeigen gröse erstellen? also der inhalt/typ ist egal, wichtig ist nur die größe!

*MFG & THX*

[Matze]

Wie meinst du das?
Du sagst z.B. TextFile - 1 GB
und dann möchtest du eine 1 GB große .txt haben? :gruebel:

Wie möchtest du das denn machen... ;)

[Meflin]

das ist ja die frage wie ich das machen kann... :wall:

aber im prinzip mein ich das!

[Matze]

Das kann man so nicht machen.
Höchstens, du nimmst eine Schleife und füllst in die Textdatei so viele Zeichen ein, bis die gewünschte Größe erreicht ist, aber ob das so toll ist, bezweifle ich.

[Meflin]

ja, auf die idee bin ich auch schon gekommen. aber das muss doch auch einfacher gehen!

[Chewie]

Damit eine Datei 1 GB groß ist, muss der Inhalt 1 GB belegen.
Am einfachsten, du schreibst immer die gleiche Zahl hinein.
Du nimmmst einen Filestream und los gehts:

Delphi-Quellcode:

var
  F: TFileStream;
  wrBytes, Size: LongWord;
  buf: Byte;
const
  BytesPerBlock = 1024;
begin
  F := TFileStream.Create('c:\test.txt', fmCreate or fmShareExclusive);
  try
    buf := 0;
    Size := 1024 * 1024;
    wrBytes := 0;
    while wrBytes + BytesPerBlock <= Size do
    begin
      F.Write(buf, BytesPerBlock);
      Inc(wrBytes, BytesPerBlock);
    end;
    if wrBytes + BytesPerBlock < Size then
      F.Write(buf, Size - wrBytes);
  finally
    F.Free;
  end;
end;

Edit: Ein kleiner Fehler korrigiert

[Matze]

Ich wüsste nicht wie.
Du musst der Datei ja irgend einen Inhalt "geben", damit sie so groß wird.
Wie groß sollen die Datein denn ungefär werden?

[flomei]

:lol: Wie viele Zeichen willst du denn in eine .txt Datei packen bis sie 1GB groß ist???
Aber mal ne Frage: Wofür willst du das haben? Für nen Benchmark? Die arbeiten mit solchen Verfahren: Datei mit der Größe xy auf Platte schreiben und gucken wie schnell die Platte ist und so was. Soll das für so etwas werden?

MfG Florian :hi:

[Meflin]

ok, aber die dateigröße ist ja variabel. weis hier einer die genauen umrechnungen von MB KB und GB?

[Matze]

Ich habe Chewie's Möglichkeit getestet mit

Delphi-Quellcode:

size:=1024*1024*1024;

und das geht! Es dauert halt 2-3 Minuten! :thumb:

Nachtrag: Mein Editor kann die Datei nicht öffnen, weil sie zu groß ist. Word auch nicht. :mrgreen:

[Matze]

http://www.coax.de/wissen/einheite.asp

[Meflin]

ok, thx damit wäre die frage beantwortet!

[Wormid]

Obwohl die Frage eigentlich beantwortet ist: Warum so umständlich mit Streams und Konsorten?

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var F: TextFile;
    S: String;
    i: Integer;
begin
    AssignFile(F, 'C:\test.txt');
    Rewrite(F);
    // Man kann da auch mit andern Werten spielen... Aber
    // allzugroß sollte man das nicht machen, sonst fängt Windows
    // an das auszulagern... Und dann wird es langsam... ;-)
    SetLength(S, 1024 * 1024);
    for i := 1 to 1024 do Write(F, S);
    CloseFile(F);
end;

Und *zack*... in 45 Sekunden ist ein Gigabyte weniger frei auf Laufwerk C:!

Gruß

Wormid

[Chewie]

Deine und meine Methode sind sehr ähnnlich. Du benutzt Pascal-Files, ich einen TFilestream. Meine Variante kann aber ohne Modifikation (außer bei den Konstanten und bei Size) belieig großee Dateien schreiben, während du auf deine Array-Größe mal x beschränkt bist.

[Lillebrohr]

Guten Tag,

erm, steht die Größe der Datei nicht im Datei-Header drinn ?

Könnte man da nicht irgendwas regeln ? Sozusagen auslesen und umschreiben ?


Bis denne

MfG

LB

[Wormid]

@Chewie: Stimmt sogar... das mit der beliebigen Größe war mir nicht bewußt. Allergings könte man ja auch SetLength mit der endgültigen Größe des Strings füttern und den dann nur einmal wegschreiben. Ist aber nicht empfehlenswert bei einer gewünschten Länge von über 10 MB oder so. :freak:

[Chewie]

Zitat:

Zitat von Wormid

Allergings könte man ja auch SetLength mit der endgültigen Größe des Strings füttern und den dann nur einmal wegschreiben. Ist aber nicht empfehlenswert bei einer gewünschten Länge von über 10 MB oder so. :freak:

Bingo :wink: Oder falls doch ... mach schon mal den Kaffee warm :mrgreen:

[Chewie]

:oops:
Ich hab gerade gemerkt, dass ich einen Denkfehler drin hatte. In der while-Schleife muss auf kleiner/gleich geprüft werden.

[Meflin]

ja das is mir auch schon aufgefallen, weil allle dateien im test (zb bei 10 kb nur 9kb)kleiner wurden als sie sein sollten! *G*

[kasi]

Das ist schneller

Code:

procedure DoCreateFile(Filename: string; Size: LongInt);
var
  FS: TFileStream;

begin
FS := TFileStream.Create(Filename, fmCreate);
try
  FS.Size := Size;
finally
  FS.Free;
end;
end;

kasi

[Matze]

Wie groß kann man die datei dann machen? Irgendwann kommt:

Zitat:

[Fehler] Unit1.pas(41): Überlauf bei Konvertierung oder arithmetischer Operation

[kasi]

LongInt ist 32 Bit mit Vorzeichen also 2 GB

Wenn größer sein muß

Code:

procedure DoCreateFile2(Filename: string; Size: Int64);
var
  FS: TFileStream;

begin
FS := TFileStream.Create(Filename, fmCreate);
try
  FileSeek(FS.Handle, Size, 0);
  Win32Check(SetEndOfFile(FS.Handle));
finally
  FS.Free;
end;
end;

So ist THandleStream.setSize auch implementiert

Aufruf (10 GB )

Code:

DoCreateFile2(Application.ExeName+'.test', Int64(1024*1024*1024)*10);

KASI

[Matze]

Cool!
Danke, wie groß werden sie dort maximal. :mrgreen:

[kasi]

9.223.372.036.854.775.808 Byte

also ca. 9000 Terabyte-Platten :)
Werde es in 100 Jahren mal testen :mrgreen:

KASI

[Chewie]

Hmmm... einfach die Size zu setzen :wall:

Ist auch ne Idee :nerd:

[Luckie]

Die Dateigröäße steht nicht im Header der Datei. Wenn dann muß der Eintrag im Dateisystem manipuliert werden.

[Matze]

OK! Vielen Dank. :thumb:

[Dannyboy]

Ich denke, die Größe einer Datei wird berechnet. Das erklärt auch, warum
man zuschauen kann, wie die Anzeige der Größe steigt, wenn man einen
Ordner > 10 GB (z.B.) rechts klickt und auf Eigenschaften geht.
Sie steht nicht im Header!

Ich wollte auch mal sehen, wie schnell ich meine Platte zumüllen kann,
dazu habe ich die Funktionen BlockRead und Blockwrite verwendet.
Das ging sehr schnell, weil ich 5 Mio Byte per Block in die Datei geschrieben habe.
Probier's einfach mal aus. 8)

Denk daran, dass Du einen Runtime-Error kriegst, sollte Deine Datei die
4GB überschreiten. Da haut Dir Windows ganz gewaltig auf die Finger!

[Meflin]

chewies methode arbeitet zuverlässig und schnell, da so große dateien nicht erstellt werden müssen (die dateien werden wohl selten größer als 1mb). deshalb werde ich auch bei dieser methode bleiben!

[Chewie]

Die Geschwindigkeit und die Speicherauslastung kannst du ja über die Konstante BytesPerBlock regulieren..

Außerdem: NTFS (zumindest die Version ab 2000, wies bei NT ist, weiß ich nicht) unterstützen Dateien > 4 GB.
Einige API-Funktionen zum Dateeihandling nehmen für die Position des Dateizeigers 2 32Bit-Werte.

[Matze]

Ich hab XP und NTFS, da hab ich eine 5 GB-Datei in weniger als einer Sek.

So ein unsinniges Programm :mrgreen:
Für meine Zwecke jedenfalls. ;)

[Duffy]

Hallo alle zusammen,
so gehts auch ...

Delphi-Quellcode:

procedure TForm1.BitBtn1Click(Sender: TObject);
const
  OpenFlags: array[Boolean] of Integer = (fmCreate or fmShareExclusive, fmOpenReadWrite or fmShareExclusive);
var
  FileStream: TFileStream;
begin
  FileStream := TFileStream.Create('C:\BigBigWorld.txt', OpenFlags[FileExists('C:\BigBigWorld.txt')]);
  FileStream.Size := 1024*1024*1024;
  FileStream.Free;
end;

byr

[wb32]

Fragen über Fragen, als Kommentare im Source :)
Wäre nett wenn mir das jemand erklären könnte.
Wenn ich damit Dateien erstelle ist die mit irgendwelchen Werten gefüllt, wo kommen die her ?

Code:

var 
 F: TFileStream; 
 wrBytes, Size: LongWord; 
 buf: Byte; 
const 
 BytesPerBlock = 1024; 
begin 
 F := TFileStream.Create('c:\test.txt', fmCreate or fmShareExclusive); 
 try 
  buf := 0; 
  Size := 1024 * 1024; 
  wrBytes := 0; 
 while wrBytes + BytesPerBlock <= Size do begin 
  F.Write(buf, BytesPerBlock); // hier wird in die datei geschreiben ??? 
  Inc(wrBytes, BytesPerBlock); // was wird hier gemacht ??? 
 end; 
if wrBytes + BytesPerBlock < Size then F.Write(buf, Size - wrBytes); // und was wird dann hier gemacht ??? 
 finally 
  F.Free; 
 end; 
end;

danke ...

[Wormid]

Zitat:

F.Write(buf, BytesPerBlock); // hier wird in die datei geschreiben ???

Jau, da wird in die Datei gschrieben... Und zwar der Inhalt von "buf" mit der Länge "BytesPerBlock".

Zitat:

Inc(wrBytes, BytesPerBlock); // was wird hier gemacht ???

Hier wird die Variable "wrBytes" um "BytesPerBlock" erhöht (incrementiert). Alternativ könnte man schreiben "wrBytes := wrBytes + BytesPerBlock". Inc ist aber eleganter und der Assemblercode dahinter ist angeblich auch besser optimiert... Die Variable wrBytes hält also fest, wieviele Bytes bisher in die Datei geschrieben wurden.

Zitat:

if wrBytes + BytesPerBlock < Size then F.Write(buf, Size - wrBytes); // und was wird dann hier gemacht ???

Ich denke, die Zeile soll dafür gut sein, den Rest in die Datei zu schreiben, bis sie die Größe "Size" erreicht hat, falls das innerhalb der Schleife nicht glatt aufging. Allerdings bin ich mir so in der Form nicht sicher, ob das korrekt ist... Müsste es nicht "if wrBytes + BytesPerBlock > Size then ..." heißen?

Gruß

Wormid

[wb32]

hmm aber

buf := 0;

woher kommt denn da der buchstaben salat in den dateien ?

[Christian Seehase]

Moin wb,

buf ist als Byte deklariert, hat also die Länge 1.
Je Durchgang werden aber BytesPerBlock (hat den Wert 1024) Bytes geschrieben.
In der Datei landet also eine Null und die 1023 Zeichen die im Speicher auf die Null folgen. Was auch immer da stehen mag.

[wb32]

ok verstanden :) danke