Visual-Basic-Forum VB-Paradise.de

Quellcode

    	private void processFileWorker_DoWork(object sender, DoWorkEventArgs e)
    	{
        	// Zunächst lesen wir das Argument aus und casten es zurück zum Klassentyp
        	processWorkerInfo pIWork = (processWorkerInfo)e.Argument;

        	// Wir erstellen eine TimeDate-Variable, inder wir den Startzeitpunkt festlegen
        	// Anhand dieser Variable können wir später die Bytes pro Sekunde errechnen
        	DateTime startTime;
        	cryptStatus cStatus = new cryptStatus();

        	// Wir erstellen eine Try-Anweisung um evtl. Fehler abzufangen
        	try
        	{	    	
		    	// Wir erstellen benötige Objekt zum Verschlüsseln der Datei anhand des AES-Algorithmus
            	byte[] key = Encoding.ASCII.GetBytes(pIWork.passwordString);
            	byte[] iv = Encoding.ASCII.GetBytes(pIWork.ivString);
            	FileStream readStream = new FileStream(pIWork.sourceFile, FileMode.Open);
            	FileStream writeStream = new FileStream(pIWork.targetFile, FileMode.Create);
            	RijndaelManaged riMan = new RijndaelManaged();
            	CryptoStream cryptStream = new CryptoStream(writeStream, riMan.CreateEncryptor(key, iv), CryptoStreamMode.Write);

            	// Die benötigten Variablen für die Schleife und die Verarbeitung
            	byte[] processingData = new byte[pIWork.bufferSize];
            	long bufferCounter = 0;
            	long buffer = 0;
            	long fileLength = readStream.Length;
            	bool done = false;

            	// Wir weisen den jetzigen Startzeitpunkt zu
            	startTime = DateTime.Now;
            	do
	        	{
                	if(bufferCounter >= fileLength - buffer) {
                    	processingData = new byte[fileLength - pIWork.bufferSize];
                    	buffer = readStream.Read(processingData, 0, Convert.ToInt32(fileLength - bufferCounter));
                    	writeStream.Write(processingData, 0, Convert.ToInt32(buffer));
                    	done = true;
                	}

                	buffer = readStream.Read(processingData, 0, Convert.ToInt32(pIWork.bufferSize));
                	writeStream.Write(processingData, 0, Convert.ToInt32(pIWork.bufferSize));
                	bufferCounter += buffer;


                	// Hier werden wir nun unsere Variablen übergeben
                	// Wir nutzen dazu eine weitere eigene Klasse, um dies möglichst einfach
                	// handzuhaben - zunächst müssen wir aber noch einige Werte errechnen
                	

                	// Gesamtgröße in Bytes der zu verschlüsselnden Datei
                	cStatus.fileSize = fileLength;
                	// Größe in Bytes der bereits verschlüsselten Datei
                	cStatus.processedSize = bufferCounter;


                	// Da dies sehr rechtenintensiv ist, und den Thread komplett auslastet, wird die GUI auch
                	// hier nicht mehr reagieren. Wir können die CPU massiv entlasten, indem wir nach allen 4096 Bytes
                	// für 1ms eine Pause einlegen. Dies verlangsamt die Verschlüsselung aber extrem! 
                	System.Threading.Thread.Sleep(1);

                	// Wir übergeben unser Object
                	processFileWorker.ReportProgress(cStatus.percentDone, cStatus);

            	} while (done == false);
        	}
        	catch (Exception)
        	{
            	// Es ist ein Fehler aufgetreten
            	throw;
        	}
    	}

    	private void processFileWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    	{

        	// Wir casten den UserState zu dem Typ unserer Status-Klasse 
        	cryptStatus cStatus = (cryptStatus)e.UserState;

        	// Und updaten die GUI
        	lblSizeComplete.Text = (cStatus.fileSize / 1024 / 1024) + " MB";
        	lblSizeCrypted.Text = (cStatus.processedSize / 1024 / 1024) + " MB";
        	lblBytesPerSecound.Text = (cStatus.bytesPerSecound / 1024 / 1024).ToString() + " MB";
        	lblEstimatedTime.Text = cStatus.timeLeft.TotalSeconds + " Sek";
        	lblPercent.Text = cStatus.percentDone + " %";
        	progressBar1.Value = cStatus.percentDone;
       	
    	}

    	private void processFileWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
    	{
        	MessageBox.Show("Vorgang beendet!");
    	}

    	private void btnCryptFile_Click(object sender, EventArgs e)
    	{
        	// Erzeuge neues Objekt von unserer Datenklasse
        	processWorkerInfo pInfo = new processWorkerInfo();

        	// Wir übernehmen die Daten der GUI 
        	// (Ich nehme hier für dieses Beispiel an, das die Daten i.O sind)
        	pInfo.sourceFile = txtSource.Text;
        	pInfo.targetFile = txtTarget.Text;
        	pInfo.bufferSize = Convert.ToInt64(txtBufferSize.Text);
        	pInfo.passwordString = txtPassword.Text;
        	pInfo.ivString = txtSalt.Text;
        	pInfo.operation = true; // Für das Verschlüsseln nutze ich true, andernfalls false

        	// Wir starten den BackgroundWorker und geben als Argument die Klasse mit,
        	// sodass wir nicht auf den anderen Thread zugreifen müssen
        	processFileWorker.RunWorkerAsync(pInfo);

        	
    	}

	}