public virtual ICancellableAsyncResult BeginOpenRead(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
        {
            StorageAsyncResult<Stream> storageAsyncResult = new StorageAsyncResult<Stream>(callback, state);
            operationContext = operationContext ?? new OperationContext();
            ICancellableAsyncResult result = this.BeginFetchAttributes(
                accessCondition,
                options,
                operationContext,
                ar =>
                {
                    try
                    {
                        this.EndFetchAttributes(ar);
                        storageAsyncResult.UpdateCompletedSynchronously(ar.CompletedSynchronously);
                        AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);

                        FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
                        storageAsyncResult.Result = new FileReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
                        storageAsyncResult.OnComplete();
                    }
                    catch (Exception e)
                    {
                        storageAsyncResult.OnComplete(e);
                    }
                },
                null /* state */);

            storageAsyncResult.CancelDelegate = result.Cancel;
            return storageAsyncResult;
        }

 /// <inheritdoc />
 public override Stream FileOpen(Database db, FileAccess fileAccess, ref string errorMessage, FileMode fileMode = FileMode.Open, bool excusiveAccess = false, int waitOverride = -1, bool signalError = true)
 {
   if (waitOverride == -1)
     waitOverride = WaitForLockMilliseconds;
   if (db.FileStream != null && ((db.FileStream.CanRead == false && fileAccess == FileAccess.Read) ||
                                 (db.FileStream.CanWrite == false && (excusiveAccess || fileAccess == FileAccess.ReadWrite))))
   {
     db.FileStream.Dispose();
     db.FileStream = null;
   }
   if (db.FileStream == null)
     if (excusiveAccess)
     {
       CloudFile cloudFile = m_databaseDir.GetFileReference(db.FileInfo.Name);
       FileRequestOptions fileRequestOptions = new FileRequestOptions();
       fileRequestOptions.ServerTimeout = TimeSpan.FromMilliseconds(waitOverride);
       fileRequestOptions.ParallelOperationThreadCount = 1;
       if (fileAccess == FileAccess.Read)
         db.FileStream = cloudFile.OpenRead(null, fileRequestOptions);
       else
         db.FileStream = cloudFile.OpenWrite(s_initialFileSize, null, fileRequestOptions);
       //db.FileInfo, fileAccess, ref errorMessage, FileShare.None, fileMode, waitOverride, UseExternalStorageApi, signalError);
     }
     else
     {
       CloudFile cloudFile = m_databaseDir.GetFileReference(db.FileInfo.Name);
       FileRequestOptions fileRequestOptions = new FileRequestOptions();
       fileRequestOptions.ServerTimeout = TimeSpan.FromMilliseconds(waitOverride);
       if (fileAccess == FileAccess.Read)
         db.FileStream = cloudFile.OpenRead(null, fileRequestOptions);
       else
         db.FileStream = cloudFile.OpenWrite(s_initialFileSize, null, fileRequestOptions);
     }
   return db.FileStream;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="SerializableFileRequestOptions"/> class.
        /// </summary>
        /// <param name="info">Serialization information.</param>
        /// <param name="context">Streaming context.</param>
        private SerializableFileRequestOptions(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            bool? disableContentMD5Validation = (bool?)info.GetValue(DisableContentMD5ValidationName, typeof(bool?));
            TimeSpan? maximumExecutionTime = (TimeSpan?)info.GetValue(MaximumExecutionTimeName, typeof(TimeSpan?));
            TimeSpan? serverTimeout = (TimeSpan?)info.GetValue(ServerTimeoutName, typeof(TimeSpan?));
            bool? storeFileContentMD5 = (bool?)info.GetValue(StoreFileContentMD5Name, typeof(bool?));
            bool? useTransactionalMD5 = (bool?)info.GetValue(UseTransactionalMD5Name, typeof(bool?));

            if (null != disableContentMD5Validation
                || null != maximumExecutionTime
                || null != serverTimeout
                || null != storeFileContentMD5
                || null != useTransactionalMD5)
            {
                this.fileRequestOptions = Transfer_RequestOptions.DefaultFileRequestOptions;

                this.fileRequestOptions.DisableContentMD5Validation = disableContentMD5Validation;
                this.fileRequestOptions.MaximumExecutionTime = maximumExecutionTime;
                this.fileRequestOptions.ServerTimeout = serverTimeout;
                this.fileRequestOptions.StoreFileContentMD5 = storeFileContentMD5;
                this.fileRequestOptions.UseTransactionalMD5 = useTransactionalMD5;
            }
            else
            {
                this.fileRequestOptions = null;
            }
        }

 public virtual Stream OpenRead(AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
 {
     operationContext = operationContext ?? new OperationContext();
     this.FetchAttributes(accessCondition, options, operationContext);
     AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
     FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
     return new FileReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
 }

 public virtual void Create(FileRequestOptions requestOptions = null, OperationContext operationContext = null)
 {
     FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(requestOptions, this.ServiceClient);
     Executor.ExecuteSync(
         this.CreateDirectoryImpl(modifiedOptions),
         modifiedOptions.RetryPolicy,
         operationContext);
 }

 public static async Task<string> DownloadTextAsync(CloudFile file, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
 {
     using (MemoryStream stream = new MemoryStream())
     {
         await file.DownloadToStreamAsync(stream, accessCondition, options, operationContext);
         return encoding.GetString(stream.ToArray(), 0, (int)stream.Length);
     }
 }

 public IAsyncAction CreateAsync(FileRequestOptions options, OperationContext operationContext)
 {
     FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
     return AsyncInfo.Run(async (token) => await Executor.ExecuteAsyncNullReturn(
         this.CreateDirectoryImpl(modifiedOptions),
         modifiedOptions.RetryPolicy,
         operationContext,
         token));
 }

 public virtual Task CreateAsync(FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
 {
     FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
     return Task.Run(async() => await Executor.ExecuteAsyncNullReturn(
         this.CreateDirectoryImpl(modifiedOptions),
         modifiedOptions.RetryPolicy,
         operationContext,
         cancellationToken), cancellationToken);
 }

 public virtual ICancellableAsyncResult BeginCreate(FileRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state)
 {
     FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
     return Executor.BeginExecuteAsync(
         this.CreateDirectoryImpl(modifiedOptions),
         modifiedOptions.RetryPolicy,
         operationContext,
         callback,
         state);
 }

 public static async Task UploadTextAsync(CloudFile file, string text, Encoding encoding, AccessCondition accessCondition = null, FileRequestOptions options = null, OperationContext operationContext = null)
 {
     byte[] textAsBytes = encoding.GetBytes(text);
     using (MemoryStream stream = new MemoryStream())
     {
         stream.Write(textAsBytes, 0, textAsBytes.Length);
         stream.Seek(0, SeekOrigin.Begin);
         file.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2;
         await file.UploadFromStreamAsync(stream, accessCondition, options, operationContext);
     }
 }

 public Task FetchShareAttributesAsync(CloudFileShare share, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
 {
     if (this.availableShareNames.Contains(share.Name))
     {
         return TaskEx.FromResult(true);
     }
     else
     {
         throw new MockupException("ShareNotExist");
     }
 }

 public virtual Task<Stream> OpenReadAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken)
 {
     operationContext = operationContext ?? new OperationContext();
     return Task.Run<Stream>(async () =>
     {
         await this.FetchAttributesAsync(accessCondition, options, operationContext);
         AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
         FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
         return new FileReadStream(this, streamAccessCondition, modifiedOptions, operationContext);
     }, cancellationToken);
 }

 public IAsyncOperation<IRandomAccessStreamWithContentType> OpenReadAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
 {
     operationContext = operationContext ?? new OperationContext();
     return AsyncInfo.Run<IRandomAccessStreamWithContentType>(async (token) =>
     {
         await this.FetchAttributesAsync(accessCondition, options, operationContext);
         AccessCondition streamAccessCondition = AccessCondition.CloneConditionWithETag(accessCondition, this.Properties.ETag);
         FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient, false);
         return new FileReadStreamHelper(this, streamAccessCondition, modifiedOptions, operationContext);
     });
 }

 public static async Task<IEnumerable<IListFileItem>> ListFilesAndDirectoriesAsync(CloudFileDirectory directory, int? maxResults, FileRequestOptions options, OperationContext operationContext)
 {
     List<IListFileItem> results = new List<IListFileItem>();
     FileContinuationToken token = null;
     do
     {
         FileResultSegment resultSegment = await directory.ListFilesAndDirectoriesSegmentedAsync(maxResults, token, options, operationContext);
         results.AddRange(resultSegment.Results);
         token = resultSegment.ContinuationToken;
     }
     while (token != null);
     return results;
 }

 public void WindowsPhoneDoesNotSupportMD5()
 {
     FileRequestOptions options = new FileRequestOptions();
     Assert.ThrowsException<NotSupportedException>(
         () => options.DisableContentMD5Validation = false,
         "MD5 flags should not work on Windows Phone");
     Assert.ThrowsException<NotSupportedException>(
         () => options.UseTransactionalMD5 = true,
         "MD5 flags should not work on Windows Phone");
     Assert.ThrowsException<NotSupportedException>(
         () => options.StoreFileContentMD5 = true,
         "MD5 flags should not work on Windows Phone");
 }

        public async Task EnumerateFilesAndDirectoriesAsync(CloudFileDirectory directory, Action<IListFileItem> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
        {
            FileContinuationToken continuationToken = null;
            do
            {
                var segment = await directory.ListFilesAndDirectoriesSegmentedAsync(null, continuationToken, options, operationContext, token);
                foreach (var item in segment.Results)
                {
                    enumerationAction(item);
                }

                continuationToken = segment.ContinuationToken;
            }
            while (continuationToken != null);
        }

        public Task EnumerateFilesAndDirectoriesAsync(CloudFileDirectory directory, Action<IListFileItem> enumerationAction, FileRequestOptions options, OperationContext operationContext, CancellationToken token)
        {
            IListFileItem[] enumerationItems;
            if (this.enumerationResults.TryGetValue(directory.Name, out enumerationItems))
            {
                foreach (var item in enumerationItems)
                {
                    enumerationAction(item);
                }

                return TaskEx.FromResult(true);
            }
            else
            {
                throw new MockupException("DirectoryNotFound");
            }
        }

        public async Task FileStoreContentMD5TestAsync()
        {
            FileRequestOptions optionsWithNoMD5 = new FileRequestOptions()
            {
                StoreFileContentMD5 = false,
            };
            FileRequestOptions optionsWithMD5 = new FileRequestOptions()
            {
                StoreFileContentMD5 = true,
            };

            CloudFileShare share = GetRandomShareReference();
            try
            {
                await share.CreateAsync();

                CloudFile file = share.GetRootDirectoryReference().GetFileReference("file4");
                using (Stream stream = new MemoryStream())
                {
                    await file.UploadFromStreamAsync(stream, null, optionsWithMD5, null);
                }
                await file.FetchAttributesAsync();
                Assert.IsNotNull(file.Properties.ContentMD5);

                file = share.GetRootDirectoryReference().GetFileReference("file5");
                using (Stream stream = new MemoryStream())
                {
                    await file.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null);
                }
                await file.FetchAttributesAsync();
                Assert.IsNull(file.Properties.ContentMD5);

                file = share.GetRootDirectoryReference().GetFileReference("file6");
                using (Stream stream = new MemoryStream())
                {
                    await file.UploadFromStreamAsync(stream);
                }
                await file.FetchAttributesAsync();
                Assert.IsNull(file.Properties.ContentMD5);
            }
            finally
            {
                share.DeleteIfExistsAsync().Wait();
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FileReadStreamBase"/> class.
        /// </summary>
        /// <param name="file">File reference to read from</param>
        /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the file. If <c>null</c>, no condition is used.</param>
        /// <param name="options">An <see cref="FileRequestOptions"/> object that specifies additional options for the request.</param>
        /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
        protected FileReadStreamBase(CloudFile file, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext)
        {
            if (options.UseTransactionalMD5.Value)
            {
                CommonUtility.AssertInBounds("StreamMinimumReadSizeInBytes", file.StreamMinimumReadSizeInBytes, 1, Constants.MaxRangeGetContentMD5Size);
            }

            this.file = file;
            this.fileProperties = new FileProperties(file.Properties);
            this.currentOffset = 0;
            this.streamMinimumReadSizeInBytes = this.file.StreamMinimumReadSizeInBytes;
            this.internalBuffer = new MultiBufferMemoryStream(file.ServiceClient.BufferManager);
            this.accessCondition = accessCondition;
            this.options = options;
            this.operationContext = operationContext;
            this.fileMD5 = (this.options.DisableContentMD5Validation.Value || string.IsNullOrEmpty(this.fileProperties.ContentMD5)) ? null : new MD5Wrapper();
            this.lastException = null;
        }

        public IAsyncOperation<bool> CreateIfNotExistsAsync(FileRequestOptions options, OperationContext operationContext)
        {
            FileRequestOptions modifiedOptions = FileRequestOptions.ApplyDefaults(options, this.ServiceClient);
            operationContext = operationContext ?? new OperationContext();

            return AsyncInfo.Run(async (token) =>
                {
                    bool exists = await this.ExistsAsync(modifiedOptions, operationContext).AsTask(token); 

                    if (exists)
                    {
                        return false;
                    }

                    try
                    {
                        await this.CreateAsync(modifiedOptions, operationContext).AsTask(token);
                        return true;
                    }
                    catch (Exception)
                    {
                        if (operationContext.LastResult.HttpStatusCode == (int)HttpStatusCode.Conflict)
                        {
                            StorageExtendedErrorInformation extendedInfo = operationContext.LastResult.ExtendedErrorInformation;
                            if ((extendedInfo == null) ||
                                (extendedInfo.ErrorCode == FileErrorCodeStrings.ShareAlreadyExists))
                            {
                                return false;
                            }
                            else
                            {
                                throw;
                            }
                        }
                        else
                        {
                            throw;
                        }
                    }
                });
        }