/// <summary> /// Read the metadata out of a blob file (stored in the system as length + bytes). It is assumed that the blob /// exists. /// </summary> /// <param name="blob">source of the metadata</param> /// <returns>metadata bytes</returns> public static byte[] ReadMetadataFile(CloudPageBlob blob) { // Optimization for small metadata file size: we read some maximum length bytes, and if the file size is // smaller than that, we do not have to issue a second read request after reading the length of metadata. byte[] firstRead = new byte[OneShotReadMaxFileSize]; var downloaded = blob.DownloadRangeToByteArray(firstRead, 0, 0, OneShotReadMaxFileSize); Debug.Assert(downloaded == OneShotReadMaxFileSize); int length = BitConverter.ToInt32(firstRead, 0); // If file length is less than what we have read, we can return from memory immediately if (length < OneShotReadMaxFileSize - sizeof(int)) { // This still copies the array. But since the cost will be dominated by read request to Azure, I am // guessing it does not matter return(firstRead.Skip(sizeof(int)).Take(length).ToArray()); } // Otherwise, copy over what we have read and read the remaining bytes. byte[] result = new byte[length]; int numBytesRead = OneShotReadMaxFileSize - sizeof(int); Array.Copy(firstRead, sizeof(int), result, 0, numBytesRead); downloaded = blob.DownloadRangeToByteArray(result, numBytesRead, OneShotReadMaxFileSize, length - numBytesRead); Debug.Assert(downloaded == length - numBytesRead, "Underfilled read buffer"); return(result); }
//******************** //* * //* PageRead_Click * //* * //******************** // Read a page. private void PageRead_Click(object sender, RoutedEventArgs e) { int pageNumber = 0; byte[] bytes = new byte[512]; try { pageNumber = Convert.ToInt32(PageNumber.Text); if (pageNumber < 0 || pageNumber > MaxPageNumber) { MessageBox.Show("Cannot write page - page number is out of range.\n\nEnter a value from 0 to " + MaxPageNumber.ToString(), "Invalid Page Number"); return; } Cursor = Cursors.Wait; byte[] data = new byte[512]; PageBlob.DownloadRangeToByteArray(data, 0, pageNumber * 512, 512); PageHexData.Text = BitConverter.ToString(data).Replace("-", " "); Cursor = Cursors.Arrow; } catch (Exception ex) { MessageBox.Show("The following error occurred attempting to read the page:\n\n" + ex.Message, "Error reading page"); } }
public byte[] DownloadPageData(CloudBlobContainer container, string key, long startOffset, long length) { CloudPageBlob pageBlob = container.GetPageBlobReference(key); byte[] result = new byte[length]; pageBlob.DownloadRangeToByteArray(result, 0, startOffset, length); return(result); }
/// <summary> /// Download the page range specified /// </summary> /// <param name="startPage">start page</param> /// <param name="endPage">end page</param> /// <param name="accessCondition">access conditions</param> /// <returns></returns> public byte[] DownloadBytes(int startIndex, int endIndex, bool disregardConcurrency = false) { try { var accessCondition = disregardConcurrency ? null : AccessCondition.GenerateIfMatchCondition(_pageBlob.Properties.ETag); var data = new byte[endIndex - startIndex]; Logger.Verbose("Downloading [{0}] bytes for blob [{1}], etag [{2}]", data.Length, _pageBlob.Uri, _pageBlob.Properties.ETag); var bytesDownloaded = _pageBlob.DownloadRangeToByteArray(data, 0, startIndex, data.Length, accessCondition); return(data); } catch (AzureStorage.StorageException ex) { throw HandleAndRemapCommonExceptions(ex); } }
public override int Read(byte[] buffer, int offset, int count) { long currentLength = Length; // can't skip ahead of write if (_readPosition + count > currentLength) { count = (int)(currentLength - _readPosition); } if (count == 0) { return(0); } int numBytesRead = _pageBlob.DownloadRangeToByteArray(buffer, offset, _readPosition, count); _readPosition += numBytesRead; return(numBytesRead); }