c# - programación - practicas c++

Creando un enorme archivo ficticio en cuestión de segundos en C#

Question

Quiero crear un gran archivo ficticio, digamos 1 ~ 2 GB en cuestión de segundos. esto es lo que escribí en C #:

file.writeallbytes("filename",new byte[a huge number]);

y otra forma de indicar el estado, era como seguir:

long FSS = din.TotalFreeSpace;
long segments = FSS / 10000;
long last_seg = FSS % 10000;
BinaryWriter br = new BinaryWriter(fs);
for (long i = 0; i < segments; i++)
{
br.Write(new byte[10000]);
this.label2.Text = "segments write :" + i.ToString() + "/r/n" + "segments remain :" + ((segments-i)+1).ToString();
Application.DoEvents();
}
br.Write(new byte[last_seg]);
this.label2.Text += "/r/nDone!";
br.Close();

donde din es un objeto de información de disco

Bueno, con estos dos enfoques, tomar algo así como 2 o más minutos para escribir un archivo tan grande pero ficticio. ¿Hay alguna otra forma más rápida de hacerlo?

Saludos.

Answer 1

¿Por qué no usó la clase BackgroundWorker para lograr esto, ya que puede pasar cualquier cosa al método ReportProgress para indicar el informe de estado? Vea el ejemplo a continuación:

private BackgroundWorker bgWorker; public Form1() { InitializeComponent(); bgWorker = new BackgroundWorker(); bgWorker.DoWork += new DoWorkEventHandler(bgWorker_DoWork); bgWorker.ProgressChanged += new ProgressChangedEventHandler(bgWorker_ProgressChanged); bgWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bgWorker_RunWorkerCompleted); bgWorker.RunWorkerAsync(); } void bgWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) { this.label2.Text = "Done"; } void bgWorker_ProgressChanged(object sender, ProgressChangedEventArgs e) { MyStatus myProgressStatus = (MyStatus)e.UserState; this.label2.Text = string.Format("segments write : {0}" + Environment.Newline + "Segments Remain: {1}", myProgressStatus.iWritten, myProgressStatus.iRemaining); } void bgWorker_DoWork(object sender, DoWorkEventArgs e) { long FSS = din.TotalFreeSpace; long segments = FSS / 10000; long last_seg = FSS % 10000; BinaryWriter br = new BinaryWriter(fs); for (long i = 0; i < segments; i++) { br.Write(new byte[10000]); bgWorker.ReportProgress(i.ToString(), new MyStatus(i, ((segments-i) + 1))); } br.Write(new byte[last_seg]); br.Close(); } public class MyStatus{ public int iWritten; public int iRemaining; public MyStatus(int iWrit, int iRem){ this.iWritten = iWrit; this.iRemaining = iRem; } } }

Este es un borrador. Espero que esto ayude, Saludos, Tom.

Answer 2

Podría estar equivocado, pero probablemente descubrirá que es imposible crear un archivo tan grande tan rápido, ya que habrá un cuello de botella en el proceso de escritura de E / S.

Sin embargo, en su código arriba de la aplicación. DoEvents ralentizará las cosas. También cualquier repintado de screenthis.label2.Text = causará una ligera desaceleración.

Answer 3

Si no te importan los contenidos, entonces, de lejos, la forma más rápida que conozco es esta: es prácticamente instantánea:

private void CreateDummyFile(string fileName, long length)
{
using (var fileStream = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None))
{
fileStream.SetLength(length);
}
}

Answer 4

Si solo necesita un FileStream , puede usar FileStream.SetLength . Eso te dará un flujo de 2 GB de largo. Luego puede escribir el byte final en una posición arbitraria de su elección. Pero los contenidos serán indefinidos.

Si intentas crear un archivo en el disco, sí, necesitarás escribir sus contenidos. Y sí, los discos duros van a ser lentos; algo así como una velocidad de escritura de 1 GB / min. no es totalmente ridículo. Lo siento, ¡eso es física!

Answer 5

Simplemente cree el archivo, busque un desplazamiento adecuadamente grande y escriba un solo byte:

FileStream fs = new FileStream(@"c:/tmp/huge_dummy_file", FileMode.CreateNew);
fs.Seek(2048L * 1024 * 1024, SeekOrigin.Begin);
fs.WriteByte(0);
fs.Close();

Esto producirá un archivo de 2 GB con contenidos básicamente impredecibles, lo que debería estar bien para sus propósitos.