diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000000000..d645695673349
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000000000..eeca3cf539abd
--- /dev/null
+++ b/README.md
@@ -0,0 +1,90 @@
+<h1>Windows Azure SDK for .NET</h1>
+<p>This SDK allows you to build Windows Azure applications that take advantage of
+Azure scalable cloud computing resources: table and blob storage, messaging through
+Service Bus, distributed caching through cache.</p>
+<p>For documentation please see the 
+<a href="http://www.windowsazure.com/en-us/develop/net/">Windows Azure .NET Developer Center</a>.</p>
+
+<h1>Features</h1>
+<ul>
+    <li>Tables
+        <ul>
+            <li>Create/Delete Tables</li>
+            <li>Query/Create/Read/Update/Delete Entities</li>
+    </li>
+    <li>BLOBs
+        <ul>
+            <li>Create/Read/Update/Delete BLOBs</li>
+    </li>
+    <li>Queues
+        <ul>
+            <li>Create/Delete Queues</li>
+            <li>Insert/Peek Queue Messages</li>
+            <li>Advanced Queue Operations</li>
+    </li>
+</ul>
+        
+<h1>Getting Started</h1>
+<h2>Download</h2>
+
+<h3>Option 1: Via Git</h3>
+<p>To get the source code of the SDK via git just type:<br/>
+<pre>git clone git://github.com/WindowsAzure/azure-sdk-for-net.git<br/>
+cd ./azure-sdk-for-net</pre>
+
+<h3>Option 2: Via NuGet</h3>
+<p>To get the binaries of this library as distributed by Microsoft, ready for use
+within your project you can also have them installed by the .NET package manager NuGet.<br/>
+<pre>Install-Package WindowsAzure.Storage</pre></p>
+
+<h2>Requirements</h2>
+<ul>
+    <li>Account: To use this SDK to call Windows Azure services, you need to first
+    create an account.</li>
+    <li>Hosting: To host your Java code in Windows Azure, you additionally need
+    to download the full Windows Azure SDK for .NET - which includes packaging,
+    emulation, and deployment tools.</li>
+    <li>.NET Framework 3.5 or higher</li>
+</ul>
+
+<h2>Code Samples</h2>
+<p>Note:</p>
+<ul>
+    <li>All code samples are available under the <code>/samples</code> folder.</li>
+    <li>How-Tos focused around accomplishing specific tasks are available on the
+    <a href="http://www.windowsazure.com/en-us/develop/net/">Windows Azure .NET
+    Developer Center</a>.</li>
+</ul>
+
+<p>First, include the classes you need (in this case we'll include the StorageClient
+and further demonstrate creating a table):<br/>
+<pre>using Microsoft.WindowsAzure;
+using Microsoft.WindowsAzure.StorageClient;</pre></p>
+
+<p>To perform an operation on any Windows Azure resource you will first instantiate
+a <strong>client</strong> which allows performing actions on it. The resource is known as an
+<strong>entity</strong>. To do so for Table you also have to authenticate your request:<br/>
+<pre>var storageAccount = 
+    CloudStorageAccount.FromConfigurationSetting("StorageConnectionString");
+var tableClient = storageAccount.CreateCloudTableClient();</pre></p>
+
+<p>Now, to create a table entity using the client:<br/>
+<pre>tableClient.CreateTable("People");</pre></p>
+
+<h1>Need Help?</h1>
+<p>Be sure to check out the Windows Azure <a href="http://go.microsoft.com/fwlink/?LinkId=234489">
+Developer Forums on MSDN</a> if you have trouble with the provided code.</p>
+
+<h1>Feedback</h1>
+<p>For feedback related specificically to this SDK, please use the Issues
+section of the repository.</p>
+<p>For general suggestions about Windows Azure please use our
+<a href="http://www.mygreatwindowsazureidea.com/forums/34192-windows-azure-feature-voting">UserVoice forum</a>.</p>
+
+<h1>Learn More</h1>
+<ul>
+    <li><a href="http://www.windowsazure.com/en-us/develop/net/">Windows Azure .NET
+    Developer Center</a></li>
+    <li><a href="http://msdn.microsoft.com/en-us/library/dd179380.aspx">
+    Windows Azure SDK Reference for .NET (MSDN)</a></li>
+</ul>
diff --git a/microsoft-azure-api/AssemblyInfo.cs b/microsoft-azure-api/AssemblyInfo.cs
new file mode 100644
index 0000000000000..6283e4af1ac98
--- /dev/null
+++ b/microsoft-azure-api/AssemblyInfo.cs
@@ -0,0 +1,96 @@
+//-----------------------------------------------------------------------
+// <copyright file="AssemblyInfo.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains assembly information.
+// </summary>
+//-----------------------------------------------------------------------
+
+using System;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Security;
+
+#if UNSIGNED
+[assembly: InternalsVisibleTo("Microsoft.WindowsAzure.StorageClient.Internal")]
+[assembly: InternalsVisibleTo("Microsoft.WindowsAzure.StorageClient.ConvenienceTests")]
+[assembly: InternalsVisibleTo("Microsoft.WindowsAzure.StorageClient.Protocol.Tests")]
+[assembly: InternalsVisibleTo("Microsoft.WindowsAzure.Diagnostics")]
+[assembly: InternalsVisibleTo("Microsoft.WindowsAzure.Diagnostics.Internal")]
+[assembly: InternalsVisibleTo("Microsoft.WindowsAzure.CloudDrive")]
+[assembly: InternalsVisibleTo("Microsoft.WindowsAzure.InternalAccessor")]
+#else
+[assembly: InternalsVisibleTo(
+    "Microsoft.WindowsAzure.StorageClient.Internal, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+[assembly: InternalsVisibleTo(
+    "StorageClientConvenienceTests, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+[assembly: InternalsVisibleTo(
+    "StorageClientProtocolTests, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+[assembly: InternalsVisibleTo(
+    "StorageClientProtocolBillingTests, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+[assembly: InternalsVisibleTo(
+    "Microsoft.WindowsAzure.Diagnostics, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+[assembly: InternalsVisibleTo(
+    "Microsoft.WindowsAzure.Diagnostics.Internal, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+[assembly: InternalsVisibleTo(
+    "Microsoft.WindowsAzure.CloudDrive, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+[assembly: InternalsVisibleTo(
+    "Microsoft.WindowsAzure.InternalAccessor, PublicKey=" +
+    "0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67" +
+    "871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0b" +
+    "d333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307" +
+    "e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c3" +
+    "08055da9")]
+
+#endif
+[assembly: CLSCompliant(true)]
+[assembly: AllowPartiallyTrustedCallers]
+[assembly: SecurityTransparent]
+[assembly: NeutralResourcesLanguageAttribute("en-US")]
diff --git a/microsoft-azure-api/CloudStorageAccount.cs b/microsoft-azure-api/CloudStorageAccount.cs
new file mode 100644
index 0000000000000..f7d62db6c77e2
--- /dev/null
+++ b/microsoft-azure-api/CloudStorageAccount.cs
@@ -0,0 +1,945 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudStorageAccount.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudStorageAccount class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using Microsoft.WindowsAzure.StorageClient;
+    using AccountSetting = System.Collections.Generic.KeyValuePair<string, System.Func<string, bool>>;
+
+    /// <summary>
+    /// Represents a Windows Azure storage account.
+    /// </summary>
+    public sealed class CloudStorageAccount
+    {
+        /// <summary>
+        /// The setting name for using the development storage.
+        /// </summary>
+        internal const string UseDevelopmentStorageName = "UseDevelopmentStorage";
+
+        /// <summary>
+        /// The setting name for specifying a development storage proxy Uri.
+        /// </summary>
+        internal const string DevelopmentStorageProxyUriName = "DevelopmentStorageProxyUri";
+
+        /// <summary>
+        /// The setting name for using the default storage endpoints with the specified protocol.
+        /// </summary>
+        internal const string DefaultEndpointsProtocolName = "DefaultEndpointsProtocol";
+
+        /// <summary>
+        /// The setting name for the account name.
+        /// </summary>
+        internal const string AccountNameName = "AccountName";
+
+        /// <summary>
+        /// The setting name for the account key.
+        /// </summary>
+        internal const string AccountKeyName = "AccountKey";
+
+        /// <summary>
+        /// The setting name for a custom blob storage endpoint.
+        /// </summary>
+        internal const string BlobEndpointName = "BlobEndpoint";
+
+        /// <summary>
+        /// The setting name for a custom queue endpoint.
+        /// </summary>
+        internal const string QueueEndpointName = "QueueEndpoint";
+
+        /// <summary>
+        /// The setting name for a custom table storage endpoint.
+        /// </summary>
+        internal const string TableEndpointName = "TableEndpoint";
+
+        /// <summary>
+        /// The setting name for a shared access key.
+        /// </summary>
+        internal const string SharedAccessSignatureName = "SharedAccessSignature";
+
+        /// <summary>
+        /// The default account name for the development storage.
+        /// </summary>
+        private const string DevstoreAccountName = "devstoreaccount1";
+
+        /// <summary>
+        /// The default account key for the development storage.
+        /// </summary>
+        private const string DevstoreAccountKey = "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==";
+
+        /// <summary>
+        /// The credentials string used to test for the development storage credentials.
+        /// </summary>
+        private const string DevstoreCredentialInString = 
+            CloudStorageAccount.AccountNameName + "=" + DevstoreAccountName + ";" +
+            CloudStorageAccount.AccountKeyName + "=" + DevstoreAccountKey;
+
+        /// <summary>
+        /// The root blob storage DNS name.
+        /// </summary>
+        private const string BlobBaseDnsName = "blob.core.windows.net";
+
+        /// <summary>
+        /// The root queue DNS name.
+        /// </summary>
+        private const string QueueBaseDnsName = "queue.core.windows.net";
+
+        /// <summary>
+        /// The root table storage DNS name.
+        /// </summary>
+        private const string TableBaseDnsName = "table.core.windows.net";
+
+        /// <summary>
+        /// Validator for the UseDevelopmentStorage setting. Must be "true".
+        /// </summary>
+        private static readonly AccountSetting UseDevelopmentStorageSetting = Setting(UseDevelopmentStorageName, "true");
+
+        /// <summary>
+        /// Validator for the DevelopmentStorageProxyUri setting. Must be a valid Uri.
+        /// </summary>
+        private static readonly AccountSetting DevelopmentStorageProxyUriSetting = Setting(DevelopmentStorageProxyUriName, IsValidUri);
+
+        /// <summary>
+        /// Validator for the DefaultEndpointsProtocol setting. Must be either "http" or "https".
+        /// </summary>
+        private static readonly AccountSetting DefaultEndpointsProtocolSetting = Setting(DefaultEndpointsProtocolName, "http", "https");
+        
+        /// <summary>
+        /// Validator for the AccountName setting. No restrictions.
+        /// </summary>
+        private static readonly AccountSetting AccountNameSetting = Setting(AccountNameName);
+
+        /// <summary>
+        /// Validator for the AccountKey setting. Must be a valid base64 string.
+        /// </summary>
+        private static readonly AccountSetting AccountKeySetting = Setting(AccountKeyName, IsValidBase64String);
+
+        /// <summary>
+        /// Validator for the BlobEndpoint setting. Must be a valid Uri.
+        /// </summary>
+        private static readonly AccountSetting BlobEndpointSetting = Setting(BlobEndpointName, IsValidUri);
+
+        /// <summary>
+        /// Validator for the QueueEndpoint setting. Must be a valid Uri.
+        /// </summary>
+        private static readonly AccountSetting QueueEndpointSetting = Setting(QueueEndpointName, IsValidUri);
+
+        /// <summary>
+        /// Validator for the TableEndpoint setting. Must be a valid Uri.
+        /// </summary>
+        private static readonly AccountSetting TableEndpointSetting = Setting(TableEndpointName, IsValidUri);
+
+        /// <summary>
+        /// Validator for the SharedAccessSignature setting. No restrictions.
+        /// </summary>
+        private static readonly AccountSetting SharedAccessSignatureSetting = Setting(SharedAccessSignatureName);
+
+        /// <summary>
+        /// Stores the user-specified configuration setting publisher.
+        /// </summary>
+        private static Action<string, Func<string, bool>> configurationSettingPublisher;
+
+        /// <summary>
+        /// Singleton instance for the development storage account.
+        /// </summary>
+        private static CloudStorageAccount devStoreAccount;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudStorageAccount"/> class using the specified
+        /// account credentials and service endpoints.
+        /// </summary>
+        /// <param name="storageCredentials">The account credentials.</param>
+        /// <param name="blobEndpoint">The Blob service endpoint.</param>
+        /// <param name="queueEndpoint">The Queue service endpoint.</param>
+        /// <param name="tableEndpoint">The Table service endpoint.</param>
+        public CloudStorageAccount(
+            StorageCredentials storageCredentials,
+            Uri blobEndpoint,
+            Uri queueEndpoint,
+            Uri tableEndpoint)
+        {
+            this.Credentials = storageCredentials;
+            this.BlobEndpoint = blobEndpoint;
+            this.QueueEndpoint = queueEndpoint;
+            this.TableEndpoint = tableEndpoint;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudStorageAccount"/> class using the specified
+        /// account credentials and the default service endpoints. 
+        /// </summary>
+        /// <param name="storageCredentialsAccountAndKey">An object of type <see cref="StorageCredentialsAccountAndKey"/> that 
+        /// specifies the account name and account key for the storage account.</param>
+        /// <param name="useHttps"><c>True</c> to use HTTPS to connect to storage service endpoints; otherwise, <c>false</c>.</param>
+        public CloudStorageAccount(StorageCredentialsAccountAndKey storageCredentialsAccountAndKey, bool useHttps)
+            : this(
+                storageCredentialsAccountAndKey,
+                new Uri(GetDefaultBlobEndpoint(useHttps ? "https" : "http", storageCredentialsAccountAndKey.AccountName)),
+                new Uri(GetDefaultQueueEndpoint(useHttps ? "https" : "http", storageCredentialsAccountAndKey.AccountName)),
+                new Uri(GetDefaultTableEndpoint(useHttps ? "https" : "http", storageCredentialsAccountAndKey.AccountName)))
+        {
+        }
+
+        /// <summary>
+        /// Gets a <see cref="CloudStorageAccount"/> object that references the development storage account.
+        /// </summary>
+        /// <value>A reference to the development storage account.</value>
+        public static CloudStorageAccount DevelopmentStorageAccount
+        {
+            get
+            {
+                if (devStoreAccount == null)
+                {
+                    devStoreAccount = GetDevelopmentStorageAccount(new Uri("http://127.0.0.1"));
+                }
+
+                return devStoreAccount;
+            }
+        }
+
+        /// <summary>
+        /// Gets the endpoint for the Blob service, as configured for the storage account.
+        /// </summary>
+        /// <value>The Blob service endpoint.</value>
+        public Uri BlobEndpoint { get; private set; }
+
+        /// <summary>
+        /// Gets the endpoint for the Queue service, as configured for the storage account.
+        /// </summary>
+        /// <value>The Queue service endpoint.</value>
+        public Uri QueueEndpoint { get; private set; }
+
+        /// <summary>
+        /// Gets the endpoint for the Table service, as configured for the storage account.
+        /// </summary>
+        /// <value>The Table service endpoint.</value>
+        public Uri TableEndpoint { get; private set; }
+
+        /// <summary>
+        /// Gets the credentials used to create this <see cref="CloudStorageAccount"/> object.
+        /// </summary>
+        /// <value>The credentials used to create the <see cref="CloudStorageAccount"/> object.</value>
+        public StorageCredentials Credentials { get; private set; }
+
+        /// <summary>
+        /// Parses a connection string and returns a <see cref="CloudStorageAccount"/> created
+        /// from the connection string.
+        /// </summary>
+        /// <param name="value">A valid connection string.</param>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="value"/> is null or empty.</exception>
+        /// <exception cref="FormatException">Thrown if <paramref name="value"/> is not a valid connection string.</exception>
+        /// <exception cref="ArgumentException">Thrown if <paramref name="value"/> cannot be parsed.</exception>
+        /// <returns>A <see cref="CloudStorageAccount"/> object constructed from the values provided in the connection string.</returns>
+        public static CloudStorageAccount Parse(string value)
+        {
+            CloudStorageAccount ret;
+
+            if (String.IsNullOrEmpty(value))
+            {
+                throw new ArgumentNullException("value");
+            }
+
+            if (TryParse(value, out ret, err => { throw new FormatException(err); }))
+            {
+                return ret;
+            }
+
+            throw new ArgumentException("Error parsing", "value");
+        }
+
+        /// <summary>
+        /// Create a new instance of a <see cref="CloudStorageAccount"/> object from a specified configuration
+        /// setting. This method may be called only after the <see cref="SetConfigurationSettingPublisher"/> 
+        /// method has been called to configure the global configuration setting publisher.
+        /// </summary>
+        /// <param name="settingName">The name of the configuration setting.</param>
+        /// <exception cref="InvalidOperationException">Thrown if the global configuration setting
+        /// publisher has not been configured, or if the configuration setting cannot be found.</exception>
+        /// <returns>A <see cref="CloudStorageAccount"/> constructed from the values in the configuration string.</returns>
+        public static CloudStorageAccount FromConfigurationSetting(string settingName)
+        {
+            if (configurationSettingPublisher == null)
+            {
+                throw new InvalidOperationException(SR.ConfigurationSettingPublisherError);
+            }
+
+            return (new StorageAccountConfigurationSetting(settingName)).CloudStorageAccount;
+        }
+
+        /// <summary>
+        /// Indicates whether a connection string can be parsed to return a <see cref="CloudStorageAccount"/> object.
+        /// </summary>
+        /// <param name="value">The connection string to parse.</param>
+        /// <param name="account">A <see cref="CloudStorageAccount"/> object to hold the instance returned if
+        /// the connection string can be parsed.</param>
+        /// <returns><b>true</b> if the connection string was successfully parsed; otherwise, <b>false</b>.</returns>
+        public static bool TryParse(string value, out CloudStorageAccount account)
+        {
+            if (String.IsNullOrEmpty(value))
+            {
+                account = null;
+
+                return false;
+            }
+
+            return TryParse(value, out account, err => { });
+        }
+
+        /// <summary>
+        /// Sets the global configuration setting publisher for the storage account, which will be called when
+        /// the account access keys are updated in the service configuration file.
+        /// </summary>
+        /// <param name="configurationSettingPublisher">The configuration setting publisher for the storage account.</param>
+        public static void SetConfigurationSettingPublisher(Action<string, Func<string, bool>> configurationSettingPublisher)
+        {
+            CloudStorageAccount.configurationSettingPublisher = configurationSettingPublisher;
+        }
+
+        /// <summary>
+        /// Returns a connection string for this storage account, without sensitive data.
+        /// </summary>
+        /// <returns>A connection string.</returns>
+        public override string ToString()
+        {
+            return this.ToString(false);
+        }
+
+        /// <summary>
+        /// Returns a connection string for the storage account, optionally with sensitive data.
+        /// </summary>
+        /// <param name="exportSecrets"><c>True</c> to include sensitive data in the string; otherwise, <c>false</c>.</param>
+        /// <returns>A connection string.</returns>
+        public string ToString(bool exportSecrets)
+        {
+            var settings = new List<string>();
+
+            if (this == DevelopmentStorageAccount)
+            {
+                settings.Add(String.Format("{0}=true", UseDevelopmentStorageName));
+            }
+            else if (this.Credentials != null &&
+                     this.Credentials.AccountName == DevstoreAccountName &&
+                     this.Credentials.ToString(true) == DevstoreCredentialInString &&
+                     this.BlobEndpoint != null && this.QueueEndpoint != null && this.TableEndpoint != null &&
+                     this.BlobEndpoint.Host == this.QueueEndpoint.Host &&
+                     this.QueueEndpoint.Host == this.TableEndpoint.Host &&
+                     this.BlobEndpoint.Scheme == this.QueueEndpoint.Scheme &&
+                     this.QueueEndpoint.Scheme == this.TableEndpoint.Scheme)
+            {
+                settings.Add(String.Format("{0}=true", UseDevelopmentStorageName));
+                settings.Add(String.Format("{0}={1}://{2}", DevelopmentStorageProxyUriName, this.BlobEndpoint.Scheme, this.BlobEndpoint.Host));
+            }
+            else if (this.BlobEndpoint != null && this.QueueEndpoint != null && this.TableEndpoint != null &&
+                     this.BlobEndpoint.Host.EndsWith(BlobBaseDnsName) &&
+                     this.QueueEndpoint.Host.EndsWith(QueueBaseDnsName) &&
+                     this.TableEndpoint.Host.EndsWith(TableBaseDnsName) &&
+                     this.BlobEndpoint.Scheme == this.QueueEndpoint.Scheme &&
+                     this.QueueEndpoint.Scheme == this.TableEndpoint.Scheme)
+            {
+                settings.Add(String.Format("{0}={1}", DefaultEndpointsProtocolName, this.BlobEndpoint.Scheme));
+
+                if (this.Credentials != null)
+                {
+                    settings.Add(this.Credentials.ToString(exportSecrets));
+                }
+            }
+            else
+            {
+                if (this.BlobEndpoint != null)
+                {
+                    settings.Add(String.Format("{0}={1}", BlobEndpointName, this.BlobEndpoint));
+                }
+
+                if (this.QueueEndpoint != null)
+                {
+                    settings.Add(String.Format("{0}={1}", QueueEndpointName, this.QueueEndpoint));
+                }
+
+                if (this.TableEndpoint != null)
+                {
+                    settings.Add(String.Format("{0}={1}", TableEndpointName, this.TableEndpoint));
+                }
+
+                if (this.Credentials != null)
+                {
+                    settings.Add(this.Credentials.ToString(exportSecrets));
+                }
+            }
+
+            return String.Join(";", settings.ToArray());
+        }
+
+        /// <summary>
+        /// Returns a <see cref="CloudStorageAccount"/> with development storage credentials using the specified proxy Uri.
+        /// </summary>
+        /// <param name="proxyUri">The proxy endpoint to use.</param>
+        /// <returns>The new <see cref="CloudStorageAccount"/>.</returns>
+        internal static CloudStorageAccount GetDevelopmentStorageAccount(Uri proxyUri)
+        {
+            if (proxyUri == null)
+            {
+                return DevelopmentStorageAccount;
+            }
+
+            string prefix = proxyUri.Scheme + "://" + proxyUri.Host;
+
+            return new CloudStorageAccount(
+                new StorageCredentialsAccountAndKey(DevstoreAccountName, DevstoreAccountKey),
+                new Uri(prefix + ":10000/devstoreaccount1"),
+                new Uri(prefix + ":10001/devstoreaccount1"),
+                new Uri(prefix + ":10002/devstoreaccount1"));
+        }
+
+        /// <summary>
+        /// Internal implementation of Parse/TryParse.
+        /// </summary>
+        /// <param name="s">The string to parse.</param>
+        /// <param name="accountInformation">The <see cref="CloudStorageAccount"/> to return.</param>
+        /// <param name="error">A callback for reporting errors.</param>
+        /// <returns>If true, the parse was successful. Otherwise, false.</returns>
+        internal static bool TryParse(string s, out CloudStorageAccount accountInformation, Action<string> error)
+        {
+            var settings = ParseStringIntoSettings(s, error);
+
+            // malformed settings string
+            if (settings == null)
+            {
+                accountInformation = null;
+
+                return false;
+            }
+
+            // devstore case
+            if (MatchesSpecification(
+                settings,
+                AllRequired(UseDevelopmentStorageSetting),
+                Optional(DevelopmentStorageProxyUriSetting)))
+            {
+                var proxyUri = settings[DevelopmentStorageProxyUriName];
+
+                accountInformation = GetDevelopmentStorageAccount(proxyUri == null ? null : new Uri(proxyUri));
+
+                return true;
+            }
+
+            // automatic case
+            if (MatchesSpecification(
+                settings,
+                AllRequired(DefaultEndpointsProtocolSetting, AccountNameSetting, AccountKeySetting),
+                Optional(BlobEndpointSetting, QueueEndpointSetting, TableEndpointSetting)))
+            {
+                var blobEndpoint = settings[BlobEndpointName];
+                var queueEndpoint = settings[QueueEndpointName];
+                var tableEndpoint = settings[TableEndpointName];
+
+                accountInformation = new CloudStorageAccount(
+                    GetCredentials(settings),
+                    new Uri(blobEndpoint ?? GetDefaultBlobEndpoint(settings)),
+                    new Uri(queueEndpoint ?? GetDefaultQueueEndpoint(settings)),
+                    new Uri(tableEndpoint ?? GetDefaultTableEndpoint(settings)));
+
+                return true;
+            }
+
+            // explicit case
+            if (MatchesSpecification(
+                settings,
+                AtLeastOne(BlobEndpointSetting, QueueEndpointSetting, TableEndpointSetting),
+                ValidCredentials()))
+            {
+                var blobUri = settings[BlobEndpointName] == null ? null : new Uri(settings[BlobEndpointName]);
+                var queueUri = settings[QueueEndpointName] == null ? null : new Uri(settings[QueueEndpointName]);
+                var tableUri = settings[TableEndpointName] == null ? null : new Uri(settings[TableEndpointName]);
+
+                accountInformation = new CloudStorageAccount(GetCredentials(settings), blobUri, queueUri, tableUri);
+
+                return true;
+            }
+
+            // not valid
+            accountInformation = null;
+
+            error("No valid combination of account information found.");
+
+            return false;
+        }
+
+        /// <summary>
+        /// Tokenizes input and stores name/value pairs in a NameValueCollection.
+        /// </summary>
+        /// <param name="s">The string to parse.</param>
+        /// <param name="error">Error reporting delegate.</param>
+        /// <returns>Tokenized collection.</returns>
+        private static NameValueCollection ParseStringIntoSettings(string s, Action<string> error)
+        {
+            var settings = new NameValueCollection();
+            var pos = 0;
+
+            while (pos < s.Length)
+            {
+                var equalsPos = s.IndexOf('=', pos);
+
+                if (equalsPos == -1)
+                {
+                    error("Settings must be of the form \"name=value\".");
+                    return null;
+                }
+
+                var name = s.Substring(pos, equalsPos - pos).Trim();
+
+                if (settings[name] != null)
+                {
+                    error(String.Format("Duplicate setting '{0}' found.", name));
+                    return null;
+                }
+
+                var semiPos = s.IndexOf(';', equalsPos);
+
+                if (semiPos == -1)
+                {
+                    // add 1 to move past the '='
+                    settings.Add(name, s.Substring(equalsPos + 1).Trim());
+
+                    return settings;
+                }
+                else
+                {
+                    // add 1 to move past the '=', subtract one to miss the ';'
+                    settings.Add(name, s.Substring(equalsPos + 1, semiPos - equalsPos - 1));
+                }
+
+                // add 1 to move past the ';'
+                pos = semiPos + 1;
+            }
+
+            error("Invalid account string.");
+            return null;
+        }
+
+        /// <summary>
+        /// Encapsulates a validation rule for an enumeration based account setting.
+        /// </summary>
+        /// <param name="name">The name of the setting.</param>
+        /// <param name="validValues">A list of valid values for the setting.</param>
+        /// <returns>An <see cref="AccountSetting"/> representing the enumeration constraint.</returns>
+        private static AccountSetting Setting(string name, params string[] validValues)
+        {
+            return new AccountSetting(
+                name,
+                (settingValue) =>
+                {
+                    if (validValues.Length == 0)
+                    {
+                        return true;
+                    }
+
+                    foreach (var validValue in validValues)
+                    {
+                        if (settingValue == validValue)
+                        {
+                            return true;
+                        }
+                    }
+
+                    return false;
+                });
+        }
+
+        /// <summary>
+        /// Encapsulates a validation rule using a func.
+        /// </summary>
+        /// <param name="name">The name of the setting.</param>
+        /// <param name="isValid">A func that determines if the value is valid.</param>
+        /// <returns>An <see cref="AccountSetting"/> representing the constraint.</returns>
+        private static AccountSetting Setting(string name, Func<string, bool> isValid)
+        {
+            return new AccountSetting(name, isValid);
+        }
+
+        /// <summary>
+        /// Determines whether the specified setting value is a valid base64 string.
+        /// </summary>
+        /// <param name="settingValue">The setting value.</param>
+        /// <returns><c>true</c> if the specified setting value is a valid base64 string; otherwise, <c>false</c>.</returns>
+        private static bool IsValidBase64String(string settingValue)
+        {
+            try
+            {
+                Convert.FromBase64String(settingValue);
+
+                return true;
+            }
+            catch (FormatException)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Validation function that validates Uris.
+        /// </summary>
+        /// <param name="settingValue">Value to validate.</param>
+        /// <returns><c>true</c> if the specified setting value is a valid Uri; otherwise, <c>false</c>.</returns>
+        private static bool IsValidUri(string settingValue)
+        {
+            return Uri.IsWellFormedUriString(settingValue, UriKind.Absolute);
+        }
+
+        /// <summary>
+        /// Settings filter that requires all specified settings be present and valid.
+        /// </summary>
+        /// <param name="requiredSettings">A list of settings that must be present.</param>
+        /// <returns>The remaining settings or null if the filter's requirement is not satisfied.</returns>
+        private static Func<NameValueCollection, NameValueCollection> AllRequired(params AccountSetting[] requiredSettings)
+        {
+            return (settings) =>
+            {
+                var result = new NameValueCollection(settings);
+
+                foreach (var requirement in requiredSettings)
+                {
+                    if (result[requirement.Key] != null && requirement.Value(result[requirement.Key]))
+                    {
+                        result.Remove(requirement.Key);
+                    }
+                    else
+                    {
+                        return null;
+                    }
+                }
+
+                return result;
+            };
+        }
+
+        /// <summary>
+        /// Settings filter that removes optional values.
+        /// </summary>
+        /// <param name="optionalSettings">A list of settings that are optional.</param>
+        /// <returns>The remaining settings or null if the filter's requirement is not satisfied.</returns>
+        private static Func<NameValueCollection, NameValueCollection> Optional(params AccountSetting[] optionalSettings)
+        {
+            return (settings) =>
+            {
+                var result = new NameValueCollection(settings);
+
+                foreach (var requirement in optionalSettings)
+                {
+                    if (result[requirement.Key] != null && requirement.Value(result[requirement.Key]))
+                    {
+                        result.Remove(requirement.Key);
+                    }
+                }
+
+                return result;
+            };
+        }
+
+        /// <summary>
+        /// Settings filter that ensures that at least one setting is present.
+        /// </summary>
+        /// <param name="atLeastOneSettings">A list of settings of which one must be present.</param>
+        /// <returns>The remaining settings or null if the filter's requirement is not satisfied.</returns>
+        private static Func<NameValueCollection, NameValueCollection> AtLeastOne(params AccountSetting[] atLeastOneSettings)
+        {
+            return (settings) =>
+            {
+                var result = new NameValueCollection(settings);
+                bool foundOne = false;
+
+                foreach (var requirement in atLeastOneSettings)
+                {
+                    if (result[requirement.Key] != null && requirement.Value(result[requirement.Key]))
+                    {
+                        result.Remove(requirement.Key);
+                        foundOne = true;
+                    }
+                }
+
+                return foundOne ? result : null;
+            };
+        }
+
+        /// <summary>
+        /// Settings filter that ensures that a valid combination of credentials is present.
+        /// </summary>
+        /// <returns>The remaining settings or null if the filter's requirement is not satisfied.</returns>
+        private static Func<NameValueCollection, NameValueCollection> ValidCredentials()
+        {
+            return (settings) =>
+            {
+                var accountName = settings[AccountNameName];
+                var accountKey = settings[AccountKeyName];
+                var sharedAccessSignature = settings[SharedAccessSignatureName];
+                var result = settings;
+
+                if (accountName != null && !AccountNameSetting.Value(accountName))
+                {
+                    return null;
+                }
+
+                if (accountKey != null && !AccountKeySetting.Value(accountKey))
+                {
+                    return null;
+                }
+
+                if (sharedAccessSignature != null && !SharedAccessSignatureSetting.Value(sharedAccessSignature))
+                {
+                    return null;
+                }
+
+                result.Remove(AccountNameName);
+                result.Remove(AccountKeyName);
+                result.Remove(SharedAccessSignatureName);
+
+                // AccountAndKey
+                if (accountName != null && accountKey != null && sharedAccessSignature == null)
+                {
+                    return result;
+                }
+
+                // SharedAccessSignature
+                if (accountName == null && accountKey == null && sharedAccessSignature != null)
+                {
+                    return result;
+                }
+
+                // Anonymous
+                if (accountName == null && accountKey == null && sharedAccessSignature == null)
+                {
+                    return result;
+                }
+
+                return null;
+            };
+        }
+
+        /// <summary>
+        /// Tests to see if a given list of settings matches a set of filters exactly.
+        /// </summary>
+        /// <param name="settings">The settings to check.</param>
+        /// <param name="constraints">A list of filters to check.</param>
+        /// <returns>
+        /// If any filter returns null, false.
+        /// If there are any settings left over after all filters are processed, false.
+        /// Otherwise true.
+        /// </returns>
+        private static bool MatchesSpecification(
+            NameValueCollection settings,
+            params Func<NameValueCollection, NameValueCollection>[] constraints)
+        {
+            foreach (var constraint in constraints)
+            {
+                var remainingSettings = constraint(settings);
+
+                if (remainingSettings == null)
+                {
+                    return false;
+                }
+                else
+                {
+                    settings = remainingSettings;
+                }
+            }
+
+            if (settings.Count == 0)
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets a StorageCredentials object corresponding to whatever credentials are supplied in the given settings.
+        /// </summary>
+        /// <param name="settings">The settings to check.</param>
+        /// <returns>The StorageCredentials object specified in the settings.</returns>
+        private static StorageCredentials GetCredentials(NameValueCollection settings)
+        {
+            var accountName = settings[AccountNameName];
+            var accountKey = settings[AccountKeyName];
+            var sharedAccessSignature = settings[SharedAccessSignatureName];
+
+            if (accountName != null && accountKey != null && sharedAccessSignature == null)
+            {
+                return new StorageCredentialsAccountAndKey(accountName, Convert.FromBase64String(accountKey));
+            }
+
+            if (accountName == null && accountKey == null && sharedAccessSignature != null)
+            {
+                return new StorageCredentialsSharedAccessSignature(sharedAccessSignature);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the default blob endpoint using specified settings.
+        /// </summary>
+        /// <param name="settings">The settings to use.</param>
+        /// <returns>The default blob endpoint.</returns>
+        private static string GetDefaultBlobEndpoint(NameValueCollection settings)
+        {
+            return GetDefaultBlobEndpoint(settings[DefaultEndpointsProtocolName], settings[AccountNameName]);
+        }
+
+        /// <summary>
+        /// Gets the default blob endpoint using the specified protocol and account name.
+        /// </summary>
+        /// <param name="scheme">The protocol to use.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The default blob endpoint.</returns>
+        private static string GetDefaultBlobEndpoint(string scheme, string accountName)
+        {
+            return String.Format("{0}://{1}.{2}", scheme, accountName, BlobBaseDnsName);
+        }
+
+        /// <summary>
+        /// Gets the default queue endpoint using the specified settings.
+        /// </summary>
+        /// <param name="settings">The settings.</param>
+        /// <returns>The default queue endpoint.</returns>
+        private static string GetDefaultQueueEndpoint(NameValueCollection settings)
+        {
+            return GetDefaultQueueEndpoint(settings[DefaultEndpointsProtocolName], settings[AccountNameName]);
+        }
+
+        /// <summary>
+        /// Gets the default queue endpoint using the specified protocol and account name.
+        /// </summary>
+        /// <param name="scheme">The protocol to use.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The default queue endpoint.</returns>
+        private static string GetDefaultQueueEndpoint(string scheme, string accountName)
+        {
+            return String.Format("{0}://{1}.{2}", scheme, accountName, QueueBaseDnsName);
+        }
+
+        /// <summary>
+        /// Gets the default table endpoint using the specified settings.
+        /// </summary>
+        /// <param name="settings">The settings.</param>
+        /// <returns>The default table endpoint.</returns>
+        private static string GetDefaultTableEndpoint(NameValueCollection settings)
+        {
+            return GetDefaultTableEndpoint(settings[DefaultEndpointsProtocolName], settings[AccountNameName]);
+        }
+
+        /// <summary>
+        /// Gets the default table endpoint using the specified protocol and account name.
+        /// </summary>
+        /// <param name="scheme">The protocol to use.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The default table endpoint.</returns>
+        private static string GetDefaultTableEndpoint(string scheme, string accountName)
+        {
+            return String.Format("{0}://{1}.{2}", scheme, accountName, TableBaseDnsName);
+        }
+
+        /// <summary>
+        /// Encapsulates a mutable storage credentials object.
+        /// </summary>
+        internal class StorageAccountConfigurationSetting
+        {
+            /// <summary>
+            /// Stores the mutable storage credentials.
+            /// </summary>
+            private MutableStorageCredentials credentials;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="StorageAccountConfigurationSetting"/> class.
+            /// </summary>
+            /// <param name="configurationSettingName">Name of the configuration setting.</param>
+            public StorageAccountConfigurationSetting(string configurationSettingName)
+            {
+                this.ConfigurationSettingName = configurationSettingName;
+                this.CloudStorageAccount = null;
+
+                CloudStorageAccount.configurationSettingPublisher(configurationSettingName, this.SetConfigurationValue);
+            }
+
+            /// <summary>
+            /// Gets or sets the name of the configuration setting from which we retrieve storage account information.
+            /// </summary>
+            public string ConfigurationSettingName { get; internal set; }
+
+            /// <summary>
+            /// Gets or sets the cloud storage account.
+            /// </summary>
+            /// <value>The cloud storage account.</value>
+            public CloudStorageAccount CloudStorageAccount { get; internal set; }
+
+            /// <summary>
+            /// Sets the configuration value.
+            /// </summary>
+            /// <param name="value">The value.</param>
+            /// <returns><c>true</c> if the value was set; otherwise, <c>false</c>.</returns>
+            private bool SetConfigurationValue(string value)
+            {
+                if (this.CloudStorageAccount == null)
+                {
+                    // first time
+                    CloudStorageAccount initialAccount;
+
+                    if (CloudStorageAccount.TryParse(value, out initialAccount))
+                    {
+                        this.credentials = new MutableStorageCredentials(initialAccount.Credentials);
+
+                        this.CloudStorageAccount = new CloudStorageAccount(
+                            this.credentials,
+                            initialAccount.BlobEndpoint,
+                            initialAccount.QueueEndpoint,
+                            initialAccount.TableEndpoint);
+                    }
+                    else
+                    {
+                        System.Diagnostics.Trace.TraceError("Error parsing storage account information - staying uninitialized");
+                    }
+                }
+                else
+                {
+                    // key rotation
+                    CloudStorageAccount newAccount;
+                    if (CloudStorageAccount.TryParse(value, out newAccount))
+                    {
+                        if ((newAccount.BlobEndpoint != CloudStorageAccount.BlobEndpoint) ||
+                            (newAccount.QueueEndpoint != CloudStorageAccount.QueueEndpoint) ||
+                            (newAccount.TableEndpoint != CloudStorageAccount.TableEndpoint))
+                        {
+                            System.Diagnostics.Trace.TraceWarning("Rejecting change: Endpoint(s) changed when updating storage account.");
+                            return false;
+                        }
+
+                        this.credentials.UpdateWith(newAccount.Credentials);
+                    }
+                    else
+                    {
+                        System.Diagnostics.Trace.WriteLine("Error parsing storage account information - staying unchanged");
+                    }
+                }
+
+                return true;
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/MutableStorageCredentials.cs b/microsoft-azure-api/MutableStorageCredentials.cs
new file mode 100644
index 0000000000000..cc6b5c5c2dc5f
--- /dev/null
+++ b/microsoft-azure-api/MutableStorageCredentials.cs
@@ -0,0 +1,184 @@
+//-----------------------------------------------------------------------
+// <copyright file="MutableStorageCredentials.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the MutableStorageCredentials class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// Represents a <see cref="StorageCredentials"/> object that is mutable to support key rotation.
+    /// </summary>
+    internal sealed class MutableStorageCredentials : StorageCredentials
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MutableStorageCredentials"/> class.
+        /// </summary>
+        public MutableStorageCredentials() 
+        {
+            this.Current = StorageCredentialsAnonymous.Anonymous;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MutableStorageCredentials"/> class.
+        /// </summary>
+        /// <param name="initialCredentials">The initial credentials.</param>
+        public MutableStorageCredentials(StorageCredentials initialCredentials)
+        {
+            this.Current = initialCredentials;
+        }
+
+        /// <summary>
+        /// Gets the name of the storage account associated with the specified credentials.
+        /// </summary>
+        /// <value>The account name.</value>
+        public override string AccountName 
+        {
+            get { return this.Current.AccountName; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="ComputeHmac"/> method will return a valid
+        /// HMAC-encoded signature string when called with the specified credentials.
+        /// </summary>
+        /// <value>
+        /// Returns <c>true</c> if these credentials will yield a valid signature string; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanComputeHmac
+        {
+            get { return this.Current.CanComputeHmac; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key authentication
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value>
+        /// Returns <c>true</c> if a request can be signed with these credentials; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanSignRequest
+        {
+            get { return this.Current.CanSignRequest; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key Lite authentication
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value>
+        /// Returns <c>true</c> if a request can be signed with these credentials; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanSignRequestLite
+        {
+            get { return this.Current.CanSignRequestLite; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="TransformUri"/> method must be called
+        /// before generating a signature string with the specified credentials.
+        /// </summary>
+        /// <value>
+        /// Returns <c>true</c> if [needs transform Uri]; otherwise, <c>false</c>. If <c>false</c>,
+        /// calling <see cref="TransformUri"/> returns the original, unmodified Uri.
+        /// </value>
+        public override bool NeedsTransformUri
+        {
+            get { return this.Current.NeedsTransformUri; }
+        }
+
+        /// <summary>
+        /// Gets or sets the current <see cref="StorageCredentials"/> object that this instance represents.
+        /// </summary>
+        internal StorageCredentials Current { get; set; }
+
+        /// <summary>
+        /// Updates the object with new credentials.
+        /// </summary>
+        /// <param name="newCredentials">The new credentials.</param>
+        public void UpdateWith(StorageCredentials newCredentials)
+        {
+            this.Current = newCredentials;
+        }
+
+        /// <summary>
+        /// Computes the HMAC signature of the specified string.
+        /// </summary>
+        /// <param name="stringToSign">The string to sign.</param>
+        /// <returns>The computed signature.</returns>
+        public override string ComputeHmac(string stringToSign)
+        {
+            return this.Current.ComputeHmac(stringToSign);
+        }
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key authentication scheme.
+        /// </summary>
+        /// <param name="request">The request to be signed.</param>
+        public override void SignRequest(HttpWebRequest request)
+        {
+            this.Current.SignRequest(request);
+        }
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key Lite authentication scheme.
+        /// </summary>
+        /// <param name="request">The request to be signed.</param>
+        public override void SignRequestLite(HttpWebRequest request)
+        {
+            this.Current.SignRequestLite(request);
+        }
+
+        /// <summary>
+        /// Transforms the Uri.
+        /// </summary>
+        /// <param name="resourceURI">The resource Uri.</param>
+        /// <returns>The transformed Uri.</returns>
+        public override string TransformUri(string resourceURI)
+        {
+            return this.Current.TransformUri(resourceURI);
+        }
+
+        /// <summary>
+        /// Computes the 512-bit HMAC signature of the specified string.
+        /// </summary>
+        /// <param name="stringToSign">The string to sign.</param>
+        /// <returns>The computed signature.</returns>
+        protected internal override string ComputeHmac512(string stringToSign)
+        {
+            return this.Current.ComputeHmac512(stringToSign);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="System.String"/> that represents this instance.
+        /// </summary>
+        /// <param name="exportSecrets">If set to <c>true</c> the string exposes key information.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> that represents this instance.
+        /// </returns>
+        protected internal override string ToString(bool exportSecrets)
+        {
+            return this.Current.ToString(exportSecrets);
+        }
+    }
+}
diff --git a/microsoft-azure-api/SR.Designer.cs b/microsoft-azure-api/SR.Designer.cs
new file mode 100644
index 0000000000000..ac775624734ba
--- /dev/null
+++ b/microsoft-azure-api/SR.Designer.cs
@@ -0,0 +1,545 @@
+//------------------------------------------------------------------------------
+// <copyright file="StorageCredentials.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <auto-generated>
+//     This code was generated by a tool.
+//     Runtime Version:2.0.50727.5403
+//
+//     Changes to this file may cause incorrect behavior and will be lost if
+//     the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class SR {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal SR() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.WindowsAzure.SR", typeof(SR).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The argument must not be empty string..
+        /// </summary>
+        internal static string ArgumentEmptyError {
+            get {
+                return ResourceManager.GetString("ArgumentEmptyError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The argument is out of range.
+        /// </summary>
+        internal static string ArgumentOutOfRangeError {
+            get {
+                return ResourceManager.GetString("ArgumentOutOfRangeError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The argument &apos;{0}&apos; is larger than maximum of &apos;{1}&apos;.
+        /// </summary>
+        internal static string ArgumentTooLargeError {
+            get {
+                return ResourceManager.GetString("ArgumentTooLargeError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The argument &apos;{0}&apos; is smaller than minimum of &apos;{1}&apos;.
+        /// </summary>
+        internal static string ArgumentTooSmallError {
+            get {
+                return ResourceManager.GetString("ArgumentTooSmallError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot attach to a TableStorageDataServiceContext object. These objects already contain the functionality for accessing the table storage service..
+        /// </summary>
+        internal static string AttachToTableServiceContext {
+            get {
+                return ResourceManager.GetString("AttachToTableServiceContext", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to EncodeMessage should be true for binary message..
+        /// </summary>
+        internal static string BinaryMessageShouldUseBase64Encoding {
+            get {
+                return ResourceManager.GetString("BinaryMessageShouldUseBase64Encoding", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to &quot;Versions before 2009-09-19 do not support Shared Key Lite for Blob And Queue, current target version &apos;{0}&apos;&quot;.
+        /// </summary>
+        internal static string BlobQSharedKeyLiteUnsuppported {
+            get {
+                return ResourceManager.GetString("BlobQSharedKeyLiteUnsuppported", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot change size below currently written size.
+        /// </summary>
+        internal static string BlobSizeReductonError {
+            get {
+                return ResourceManager.GetString("BlobSizeReductonError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to A stream blob must have a blob size of 0..
+        /// </summary>
+        internal static string BlobSizeTypeMismatch {
+            get {
+                return ResourceManager.GetString("BlobSizeTypeMismatch", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The blob is larger than maximum supported size &apos;{0}&apos;.
+        /// </summary>
+        internal static string BlobTooLargeError {
+            get {
+                return ResourceManager.GetString("BlobTooLargeError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to BlobType of the blob reference doesn&apos;t match BlobType of the blob..
+        /// </summary>
+        internal static string BlobTypeMismatchExceptionMessage {
+            get {
+                return ResourceManager.GetString("BlobTypeMismatchExceptionMessage", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Data already uploaded.
+        /// </summary>
+        internal static string BlocksExistError {
+            get {
+                return ResourceManager.GetString("BlocksExistError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The block size must be positive value.
+        /// </summary>
+        internal static string BlocksTooSmallError {
+            get {
+                return ResourceManager.GetString("BlocksTooSmallError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Block size can not be larger than &apos;{0}&apos;.
+        /// </summary>
+        internal static string BlockTooLargeError {
+            get {
+                return ResourceManager.GetString("BlockTooLargeError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot create Shared Access Signature for snapshots. Perform the operation on the root blob instead..
+        /// </summary>
+        internal static string CannotCreateSASForSnapshot {
+            get {
+                return ResourceManager.GetString("CannotCreateSASForSnapshot", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot create Shared Access Signature as the credentials does not have account name information. Please check that the credentials used support creating Shared Access Signature..
+        /// </summary>
+        internal static string CannotCreateSASSignatureForGivenCred {
+            get {
+                return ResourceManager.GetString("CannotCreateSASSignatureForGivenCred", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot create Shared Access Signature unless the Account Key credentials are used by the BlobServiceClient..
+        /// </summary>
+        internal static string CannotCreateSASWithoutAccountKey {
+            get {
+                return ResourceManager.GetString("CannotCreateSASWithoutAccountKey", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot perform this operation on a blob representing a snapshot..
+        /// </summary>
+        internal static string CannotModifySnapshot {
+            get {
+                return ResourceManager.GetString("CannotModifySnapshot", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot retry operation using a source stream which does not support seek. To avoid this exception set the RetryPolicy to NoRetry or use a seekable stream..
+        /// </summary>
+        internal static string CannotRetryNonSeekableStreamError {
+            get {
+                return ResourceManager.GetString("CannotRetryNonSeekableStreamError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Server operation did not finish within user specified timeout &apos;{0}&apos; seconds, check if operation is valid or try increasing the timeout..
+        /// </summary>
+        internal static string ClientSideTimeoutError {
+            get {
+                return ResourceManager.GetString("ClientSideTimeoutError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to If-Modified-Since and If-Unmodified-Since require a DateTime value..
+        /// </summary>
+        internal static string ConditionalRequiresDateTime {
+            get {
+                return ResourceManager.GetString("ConditionalRequiresDateTime", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to If-Match and If-None-Match require an ETag value..
+        /// </summary>
+        internal static string ConditionalRequiresETag {
+            get {
+                return ResourceManager.GetString("ConditionalRequiresETag", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The conditionals specified for this operation did not match server..
+        /// </summary>
+        internal static string ConditionNotMatchedError {
+            get {
+                return ResourceManager.GetString("ConditionNotMatchedError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to SetConfigurationSettingPublisher needs to be called before FromConfigurationSetting can be used.
+        /// </summary>
+        internal static string ConfigurationSettingPublisherError {
+            get {
+                return ResourceManager.GetString("ConfigurationSettingPublisherError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The supplied credentials &apos;{0&apos;} cannot be used to sign request.
+        /// </summary>
+        internal static string CredentialsCantSignRequest {
+            get {
+                return ResourceManager.GetString("CredentialsCantSignRequest", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The option &apos;{0}&apos; must be &apos;None&apos; to delete a specific snapshot specified by &apos;{1}&apos;.
+        /// </summary>
+        internal static string DeleteSnapshotsNotValidError {
+            get {
+                return ResourceManager.GetString("DeleteSnapshotsNotValidError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot combine incompatible absolute Uris base &apos;{0}&apos;  relative &apos;{1}&apos;.When trying to combine 2 absolute Uris, the base uri should be a valid base of the relative Uri..
+        /// </summary>
+        internal static string IncompatibleAddressesProvided {
+            get {
+                return ResourceManager.GetString("IncompatibleAddressesProvided", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid acl public access type returned &apos;{0}&apos;. Expected blob or container..
+        /// </summary>
+        internal static string InvalidAclType {
+            get {
+                return ResourceManager.GetString("InvalidAclType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The continuation type passed in is unexpected. Please verify that the correct continuation type is passed in. Expected {0}, found {1}.
+        /// </summary>
+        internal static string InvalidContinuationType {
+            get {
+                return ResourceManager.GetString("InvalidContinuationType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid query parameters inside Blob address &apos;{0}&apos;..
+        /// </summary>
+        internal static string InvalidQueryParametersInsideBlobAddress {
+            get {
+                return ResourceManager.GetString("InvalidQueryParametersInsideBlobAddress", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Listing snapshots is only supported in flat mode (no delimiter). Consider setting BlobRequestOptions.UseFlatBlobListing property to true..
+        /// </summary>
+        internal static string ListSnapshotsWithDelimiterError {
+            get {
+                return ResourceManager.GetString("ListSnapshotsWithDelimiterError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Calculated MD5 does not match existing property.
+        /// </summary>
+        internal static string MD5MismatchError {
+            get {
+                return ResourceManager.GetString("MD5MismatchError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Messages cannot be larger than {0} bytes..
+        /// </summary>
+        internal static string MessageTooLarge {
+            get {
+                return ResourceManager.GetString("MessageTooLarge", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot find account information inside Uri &apos;{0}&apos;.
+        /// </summary>
+        internal static string MissingAccountInformationInUri {
+            get {
+                return ResourceManager.GetString("MissingAccountInformationInUri", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid blob address &apos;{0}&apos;, missing container information.
+        /// </summary>
+        internal static string MissingContainerInformation {
+            get {
+                return ResourceManager.GetString("MissingContainerInformation", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Missing mandatory parameters for valid Shared Access Signature.
+        /// </summary>
+        internal static string MissingMandatoryParamtersForSAS {
+            get {
+                return ResourceManager.GetString("MissingMandatoryParamtersForSAS", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Canonicalization did not find a non empty x-ms-date header in the WebRequest. Please use a WebRequest with a valid x-ms-date header in RFC 123 format (example request.Headers[&quot;x-ms-date&quot;] = DateTime.UtcNow.ToString(&quot;R&quot;, CultureInfo.InvariantCulture)).
+        /// </summary>
+        internal static string MissingXmsDateInHeader {
+            get {
+                return ResourceManager.GetString("MissingXmsDateInHeader", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot provide credentials as part of the address and as constructor parameter. Either pass in the address or use a different constructor..
+        /// </summary>
+        internal static string MultipleCredentialsProvided {
+            get {
+                return ResourceManager.GetString("MultipleCredentialsProvided", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Multiple different snapshot times provided as part of query &apos;{0}&apos; and as constructor parameter &apos;{1}&apos;..
+        /// </summary>
+        internal static string MultipleSnapshotTimesProvided {
+            get {
+                return ResourceManager.GetString("MultipleSnapshotTimesProvided", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to EndMoveNextSegment must be called before the Current property can be accessed..
+        /// </summary>
+        internal static string MustCallEndMoveNextSegmentFirst {
+            get {
+                return ResourceManager.GetString("MustCallEndMoveNextSegmentFirst", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The segment cursor has no more results..
+        /// </summary>
+        internal static string NoMoreResultsForSegmentCursor {
+            get {
+                return ResourceManager.GetString("NoMoreResultsForSegmentCursor", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to This operation is not supported for creating a PageBlob. Use other operations to create a PageBlob..
+        /// </summary>
+        internal static string NotSupportedForPageBlob {
+            get {
+                return ResourceManager.GetString("NotSupportedForPageBlob", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Missing account name information inside path style uri. Path style uris should be of the form http://&lt;IPAddressPlusPort&gt;/&lt;accountName&gt;.
+        /// </summary>
+        internal static string PathStyleUriMissingAccountNameInformation {
+            get {
+                return ResourceManager.GetString("PathStyleUriMissingAccountNameInformation", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Address &apos;{0}&apos; is not an absolute address. Relative addresses are not permitted in here..
+        /// </summary>
+        internal static string RelativeAddressNotPermitted {
+            get {
+                return ResourceManager.GetString("RelativeAddressNotPermitted", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Attempting to seek past the end of the stream.
+        /// </summary>
+        internal static string SeekTooFarError {
+            get {
+                return ResourceManager.GetString("SeekTooFarError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Attempting to seek before the start of the stream.
+        /// </summary>
+        internal static string SeekTooLowError {
+            get {
+                return ResourceManager.GetString("SeekTooLowError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Server returned more that MaxResults requested.
+        /// </summary>
+        internal static string ServerReturnedMoreThanMaxResults {
+            get {
+                return ResourceManager.GetString("ServerReturnedMoreThanMaxResults", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Snapshot query parameter is already defined in the blobUri. Either pass in a snapshotTime parameter or use a full URL with a snapshot query parameter..
+        /// </summary>
+        internal static string SnapshotTimePassedTwice {
+            get {
+                return ResourceManager.GetString("SnapshotTimePassedTwice", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to &apos;{0}&apos; is not a valid table name..
+        /// </summary>
+        internal static string TableNameInvalid {
+            get {
+                return ResourceManager.GetString("TableNameInvalid", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The number of blocks is larger than the maximum of &apos;{0}&apos;.
+        /// </summary>
+        internal static string TooManyBlocksError {
+            get {
+                return ResourceManager.GetString("TooManyBlocksError", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Too many &apos;{0}&apos; shared access policy identifiers provided. Server does not support setting more than &apos;{1}&apos; on a single container..
+        /// </summary>
+        internal static string TooManyPolicyIdentifiers {
+            get {
+                return ResourceManager.GetString("TooManyPolicyIdentifiers", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The blob type cannot be undefined..
+        /// </summary>
+        internal static string UndefinedBlobType {
+            get {
+                return ResourceManager.GetString("UndefinedBlobType", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/SR.resx b/microsoft-azure-api/SR.resx
new file mode 100644
index 0000000000000..3b87ad0c907d4
--- /dev/null
+++ b/microsoft-azure-api/SR.resx
@@ -0,0 +1,289 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--Copyright 2011 Microsoft Corporation
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="BlobSizeReductonError" xml:space="preserve">
+    <value>Cannot change size below currently written size</value>
+  </data>
+  <data name="BlobSizeTypeMismatch" xml:space="preserve">
+    <value>A stream blob must have a blob size of 0.</value>
+  </data>
+  <data name="BlobTooLargeError" xml:space="preserve">
+    <value>The blob is larger than maximum supported size '{0}'</value>
+  </data>
+  <data name="BlocksExistError" xml:space="preserve">
+    <value>Data already uploaded</value>
+  </data>
+  <data name="BlockTooLargeError" xml:space="preserve">
+    <value>Block size can not be larger than '{0}'</value>
+  </data>
+  <data name="ConditionalRequiresDateTime" xml:space="preserve">
+    <value>If-Modified-Since and If-Unmodified-Since require a DateTime value.</value>
+  </data>
+  <data name="ConditionalRequiresETag" xml:space="preserve">
+    <value>If-Match and If-None-Match require an ETag value.</value>
+  </data>
+  <data name="MD5MismatchError" xml:space="preserve">
+    <value>Calculated MD5 does not match existing property</value>
+  </data>
+  <data name="UndefinedBlobType" xml:space="preserve">
+    <value>The blob type cannot be undefined.</value>
+  </data>
+  <data name="BlocksTooSmallError" xml:space="preserve">
+    <value>The block size must be positive value</value>
+  </data>
+  <data name="ArgumentEmptyError" xml:space="preserve">
+    <value>The argument must not be empty string.</value>
+  </data>
+  <data name="MissingContainerInformation" xml:space="preserve">
+    <value>Invalid blob address '{0}', missing container information</value>
+  </data>
+  <data name="ArgumentOutOfRangeError" xml:space="preserve">
+    <value>The argument is out of range</value>
+  </data>
+  <data name="ArgumentTooLargeError" xml:space="preserve">
+    <value>The argument '{0}' is larger than maximum of '{1}'</value>
+  </data>
+  <data name="ArgumentTooSmallError" xml:space="preserve">
+    <value>The argument '{0}' is smaller than minimum of '{1}'</value>
+  </data>
+  <data name="SeekTooFarError" xml:space="preserve">
+    <value>Attempting to seek past the end of the stream</value>
+  </data>
+  <data name="SeekTooLowError" xml:space="preserve">
+    <value>Attempting to seek before the start of the stream</value>
+  </data>
+  <data name="RelativeAddressNotPermitted" xml:space="preserve">
+    <value>Address '{0}' is not an absolute address. Relative addresses are not permitted in here.</value>
+  </data>
+  <data name="TooManyBlocksError" xml:space="preserve">
+    <value>The number of blocks is larger than the maximum of '{0}'</value>
+  </data>
+  <data name="NoMoreResultsForSegmentCursor" xml:space="preserve">
+    <value>The segment cursor has no more results.</value>
+  </data>
+  <data name="TableNameInvalid" xml:space="preserve">
+    <value>'{0}' is not a valid table name.</value>
+  </data>
+  <data name="AttachToTableServiceContext" xml:space="preserve">
+    <value>Cannot attach to a TableStorageDataServiceContext object. These objects already contain the functionality for accessing the table storage service.</value>
+  </data>
+  <data name="CannotCreateSASWithoutAccountKey" xml:space="preserve">
+    <value>Cannot create Shared Access Signature unless the Account Key credentials are used by the BlobServiceClient.</value>
+  </data>
+  <data name="CannotModifySnapshot" xml:space="preserve">
+    <value>Cannot perform this operation on a blob representing a snapshot.</value>
+  </data>
+  <data name="InvalidQueryParametersInsideBlobAddress" xml:space="preserve">
+    <value>Invalid query parameters inside Blob address '{0}'.</value>
+  </data>
+  <data name="MissingMandatoryParamtersForSAS" xml:space="preserve">
+    <value>Missing mandatory parameters for valid Shared Access Signature</value>
+  </data>
+  <data name="MultipleCredentialsProvided" xml:space="preserve">
+    <value>Cannot provide credentials as part of the address and as constructor parameter. Either pass in the address or use a different constructor.</value>
+  </data>
+  <data name="MultipleSnapshotTimesProvided" xml:space="preserve">
+    <value>Multiple different snapshot times provided as part of query '{0}' and as constructor parameter '{1}'.</value>
+  </data>
+  <data name="TooManyPolicyIdentifiers" xml:space="preserve">
+    <value>Too many '{0}' shared access policy identifiers provided. Server does not support setting more than '{1}' on a single container.</value>
+  </data>
+  <data name="MessageTooLarge" xml:space="preserve">
+    <value>Messages cannot be larger than {0} bytes.</value>
+  </data>
+  <data name="InvalidAclType" xml:space="preserve">
+    <value>Invalid acl public access type returned '{0}'. Expected blob or container.</value>
+  </data>
+  <data name="IncompatibleAddressesProvided" xml:space="preserve">
+    <value>Cannot combine incompatible absolute Uris base '{0}'  relative '{1}'.When trying to combine 2 absolute Uris, the base uri should be a valid base of the relative Uri.</value>
+  </data>
+  <data name="MissingAccountInformationInUri" xml:space="preserve">
+    <value>Cannot find account information inside Uri '{0}'</value>
+  </data>
+  <data name="PathStyleUriMissingAccountNameInformation" xml:space="preserve">
+    <value>Missing account name information inside path style uri. Path style uris should be of the form http://&lt;IPAddressPlusPort&gt;/&lt;accountName&gt;</value>
+  </data>
+  <data name="CannotCreateSASSignatureForGivenCred" xml:space="preserve">
+    <value>Cannot create Shared Access Signature as the credentials does not have account name information. Please check that the credentials used support creating Shared Access Signature.</value>
+  </data>
+  <data name="ClientSideTimeoutError" xml:space="preserve">
+    <value>Server operation did not finish within user specified timeout '{0}' seconds, check if operation is valid or try increasing the timeout.</value>
+  </data>
+  <data name="MustCallEndMoveNextSegmentFirst" xml:space="preserve">
+    <value>EndMoveNextSegment must be called before the Current property can be accessed.</value>
+  </data>
+  <data name="BlobQSharedKeyLiteUnsuppported" xml:space="preserve">
+    <value>"Versions before 2009-09-19 do not support Shared Key Lite for Blob And Queue, current target version '{0}'"</value>
+  </data>
+  <data name="MissingXmsDateInHeader" xml:space="preserve">
+    <value>Canonicalization did not find a non empty x-ms-date header in the WebRequest. Please use a WebRequest with a valid x-ms-date header in RFC 123 format (example request.Headers["x-ms-date"] = DateTime.UtcNow.ToString("R", CultureInfo.InvariantCulture))</value>
+  </data>
+  <data name="NotSupportedForPageBlob" xml:space="preserve">
+    <value>This operation is not supported for creating a PageBlob. Use other operations to create a PageBlob.</value>
+  </data>
+  <data name="DeleteSnapshotsNotValidError" xml:space="preserve">
+    <value>The option '{0}' must be 'None' to delete a specific snapshot specified by '{1}'</value>
+  </data>
+  <data name="CredentialsCantSignRequest" xml:space="preserve">
+    <value>The supplied credentials '{0'} cannot be used to sign request</value>
+  </data>
+  <data name="CannotCreateSASForSnapshot" xml:space="preserve">
+    <value>Cannot create Shared Access Signature for snapshots. Perform the operation on the root blob instead.</value>
+  </data>
+  <data name="ConditionNotMatchedError" xml:space="preserve">
+    <value>The conditionals specified for this operation did not match server.</value>
+  </data>
+  <data name="ConfigurationSettingPublisherError" xml:space="preserve">
+    <value>SetConfigurationSettingPublisher needs to be called before FromConfigurationSetting can be used</value>
+  </data>
+  <data name="ListSnapshotsWithDelimiterError" xml:space="preserve">
+    <value>Listing snapshots is only supported in flat mode (no delimiter). Consider setting BlobRequestOptions.UseFlatBlobListing property to true.</value>
+  </data>
+  <data name="ServerReturnedMoreThanMaxResults" xml:space="preserve">
+    <value>Server returned more that MaxResults requested</value>
+  </data>
+  <data name="InvalidContinuationType" xml:space="preserve">
+    <value>The continuation type passed in is unexpected. Please verify that the correct continuation type is passed in. Expected {0}, found {1}</value>
+  </data>
+  <data name="BlobTypeMismatchExceptionMessage" xml:space="preserve">
+    <value>BlobType of the blob reference doesn't match BlobType of the blob.</value>
+  </data>
+  <data name="BinaryMessageShouldUseBase64Encoding" xml:space="preserve">
+    <value>EncodeMessage should be true for binary message.</value>
+  </data>
+  <data name="CannotRetryNonSeekableStreamError" xml:space="preserve">
+    <value>Cannot retry operation using a source stream which does not support seek. To avoid this exception set the RetryPolicy to NoRetry or use a seekable stream.</value>
+  </data>
+  <data name="SnapshotTimePassedTwice" xml:space="preserve">
+    <value>Snapshot query parameter is already defined in the blobUri. Either pass in a snapshotTime parameter or use a full URL with a snapshot query parameter.</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/microsoft-azure-api/Settings.SourceAnalysis b/microsoft-azure-api/Settings.SourceAnalysis
new file mode 100644
index 0000000000000..975146b8930ca
--- /dev/null
+++ b/microsoft-azure-api/Settings.SourceAnalysis
@@ -0,0 +1,40 @@
+<!--Copyright 2011 Microsoft Corporation
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<StyleCopSettings Version="4.3">
+  <GlobalSettings>
+    <StringProperty Name="LinkedSettingsFile">%StyleCopLocation%\bin\Settings.SourceAnalysis</StringProperty>
+  </GlobalSettings>
+  <Parsers>
+    <Parser ParserId="Microsoft.StyleCop.CSharp.CsParser">
+      <ParserSettings>
+        <BooleanProperty Name="AnalyzeGeneratedFiles">True</BooleanProperty>
+      </ParserSettings>
+    </Parser>
+  </Parsers>
+  <Analyzers>
+    <Analyzer AnalyzerId="Microsoft.StyleCop.CSharp.NamingRules">
+      <AnalyzerSettings>
+        <CollectionProperty Name="Hungarian">
+          <Value>md</Value>
+        </CollectionProperty>
+      </AnalyzerSettings>
+    </Analyzer>
+    <Analyzer AnalyzerId="Microsoft.StyleCop.CSharp.DocumentationRules">
+      <AnalyzerSettings>
+        <StringProperty Name="CompanyName">Microsoft</StringProperty>
+        <StringProperty Name="Copyright">Copyright (c)2010 Microsoft. All rights reserved.</StringProperty>
+      </AnalyzerSettings>
+    </Analyzer>
+  </Analyzers>
+</StyleCopSettings>
\ No newline at end of file
diff --git a/microsoft-azure-api/Settings.StyleCop b/microsoft-azure-api/Settings.StyleCop
new file mode 100644
index 0000000000000..4abf2f98f0cee
--- /dev/null
+++ b/microsoft-azure-api/Settings.StyleCop
@@ -0,0 +1,68 @@
+<!--Copyright 2011 Microsoft Corporation
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<StyleCopSettings Version="4.3">
+  <Analyzers>
+    <Analyzer AnalyzerId="Microsoft.StyleCop.CSharp.NamingRules">
+      <AnalyzerSettings>
+        <CollectionProperty Name="Hungarian">
+          <Value>at</Value>
+          <Value>io</Value>
+          <Value>md</Value>
+          <Value>x</Value>
+        </CollectionProperty>
+      </AnalyzerSettings>
+    </Analyzer>
+    <Analyzer AnalyzerId="Microsoft.StyleCop.CSharp.ReadabilityRules">
+      <Rules>
+        <Rule Name="DoNotUseRegions">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">True</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings />
+    </Analyzer>
+    <Analyzer AnalyzerId="Microsoft.StyleCop.CSharp.DocumentationRules">
+      <Rules>
+        <Rule Name="PropertyDocumentationMustHaveValue">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">True</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="PropertyDocumentationMustHaveValueText">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">True</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustBeginWithACapitalLetter">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">True</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="DocumentationTextMustEndWithAPeriod">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">True</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+        <Rule Name="FileHeaderMustHaveSummary">
+          <RuleSettings>
+            <BooleanProperty Name="Enabled">True</BooleanProperty>
+          </RuleSettings>
+        </Rule>
+      </Rules>
+      <AnalyzerSettings>
+      </AnalyzerSettings>
+    </Analyzer>
+  </Analyzers>
+</StyleCopSettings>
\ No newline at end of file
diff --git a/microsoft-azure-api/SharedAccessSignatureHelper.cs b/microsoft-azure-api/SharedAccessSignatureHelper.cs
new file mode 100644
index 0000000000000..14244f7e77e39
--- /dev/null
+++ b/microsoft-azure-api/SharedAccessSignatureHelper.cs
@@ -0,0 +1,233 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedAccessSignatureHelper.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedAccessSignatureHelper.cs class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+    using Microsoft.WindowsAzure.StorageClient.Protocol;
+
+    /// <summary>
+    /// Contains helper methods for implementing shared access signatures.
+    /// </summary>
+    internal static class SharedAccessSignatureHelper
+    {
+        /// <summary>
+        /// Get the signature hash embedded inside the Shared Access Signature.
+        /// </summary>
+        /// <param name="policy">The shared access policy to hash.</param>
+        /// <param name="groupPolicyIdentifier">An optional identifier for the policy.</param>
+        /// <param name="resourceName">The canonical resource string, unescaped.</param>
+        /// <param name="client">The client whose credentials are to be used for signing.</param>
+        /// <returns>The signed hash.</returns>
+        internal static string GetSharedAccessSignatureHashImpl(
+            SharedAccessPolicy policy,
+            string groupPolicyIdentifier,
+            string resourceName,
+            CloudBlobClient client)
+        {
+            CommonUtils.AssertNotNull("policy", policy);
+            CommonUtils.AssertNotNullOrEmpty("resourceName", resourceName);
+            CommonUtils.AssertNotNull("client", client);
+
+            ////StringToSign = signedpermissions + "\n"
+            ////               signedstart + "\n"
+            ////               signedexpiry + "\n"
+            ////               canonicalizedresource + "\n"
+            ////               signedidentifier
+            ////HMAC-SHA256(URL.Decode(UTF8.Encode(StringToSign)))
+
+            string stringToSign = string.Format(
+                "{0}\n{1}\n{2}\n{3}\n{4}",
+                SharedAccessPolicy.PermissionsToString(policy.Permissions),
+                GetDateTimeOrEmpty(policy.SharedAccessStartTime),
+                GetDateTimeOrEmpty(policy.SharedAccessExpiryTime),
+                resourceName,
+                groupPolicyIdentifier);
+
+            string signature = client.Credentials.ComputeHmac(stringToSign);
+
+            return signature;
+        }
+
+        /// <summary>
+        /// Get the complete query builder for creating the Shared Access Signature query.
+        /// </summary>
+        /// <param name="policy">The shared access policy to hash.</param>
+        /// <param name="groupPolicyIdentifier">An optional identifier for the policy.</param>
+        /// <param name="resourceType">Either "b" for blobs or "c" for containers.</param>
+        /// <param name="signature">The signature to use.</param>
+        /// <returns>The finished query builder.</returns>
+        internal static UriQueryBuilder GetShareAccessSignatureImpl(
+            SharedAccessPolicy policy,
+            string groupPolicyIdentifier,
+            string resourceType,
+            string signature)
+        {
+            CommonUtils.AssertNotNull("policy", policy);
+            CommonUtils.AssertNotNullOrEmpty("resourceType", resourceType);
+            CommonUtils.AssertNotNull("signature", signature);
+
+            UriQueryBuilder builder = new UriQueryBuilder();
+
+            // FUTURE blob for blob and container for container
+            string permissions = SharedAccessPolicy.PermissionsToString(policy.Permissions);
+            if (String.IsNullOrEmpty(permissions))
+            {
+                permissions = null;
+            }
+
+            AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedStart, GetDateTimeOrNull(policy.SharedAccessStartTime));
+            AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedExpiry, GetDateTimeOrNull(policy.SharedAccessExpiryTime));
+            builder.Add(Constants.QueryConstants.SignedResource, resourceType);
+            AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedPermissions, permissions);
+            AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedIdentifier, groupPolicyIdentifier);
+            AddEscapedIfNotNull(builder, Constants.QueryConstants.Signature, signature);
+
+            return builder;
+        }
+
+        /// <summary>
+        /// Converts the specified value to either a string representation or <see cref="String.Empty"/>.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A string representing the specified value.</returns>
+        internal static string GetDateTimeOrEmpty(DateTime? value)
+        {
+            string result = GetDateTimeOrNull(value) ?? string.Empty;
+            return result;
+        }
+
+        /// <summary>
+        /// Converts the specified value to either a string representation or <c>null</c>.
+        /// </summary>
+        /// <param name="value">The value to convert.</param>
+        /// <returns>A string representing the specified value.</returns>
+        internal static string GetDateTimeOrNull(DateTime? value)
+        {
+            string result = value != null ? value.Value.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ") : null;
+            return result;
+        }
+
+        /// <summary>
+        /// Escapes and adds the specified name/value pair to the query builder if it is not null.
+        /// </summary>
+        /// <param name="builder">The builder to add the value to.</param>
+        /// <param name="name">The name of the pair.</param>
+        /// <param name="value">The value to be escaped.</param>
+        internal static void AddEscapedIfNotNull(UriQueryBuilder builder, string name, string value)
+        {
+            if (value != null)
+            {
+                builder.Add(name, value);
+            }
+        }
+
+        /// <summary>
+        /// Parses the query.
+        /// </summary>
+        /// <param name="queryParameters">The query parameters.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal static void ParseQuery(NameValueCollection queryParameters, out StorageCredentialsSharedAccessSignature credentials)
+        {
+            string signature = null;
+            string signedStart = null;
+            string signedExpiry = null;
+            string signedResource = null;
+            string sigendPermissions = null;
+            string signedIdentifier = null;
+            string signedVersion = null;
+
+            bool sasParameterFound = false;
+
+            credentials = null;
+
+            foreach (var key in queryParameters.AllKeys)
+            {
+                switch (key.ToLower())
+                {
+                    case Constants.QueryConstants.SignedStart:
+                        signedStart = queryParameters[key];
+                        sasParameterFound = true;
+                        break;
+
+                    case Constants.QueryConstants.SignedExpiry:
+                        signedExpiry = queryParameters[key];
+                        sasParameterFound = true;
+                        break;
+
+                    case Constants.QueryConstants.SignedPermissions:
+                        sigendPermissions = queryParameters[key];
+                        sasParameterFound = true;
+                        break;
+
+                    case Constants.QueryConstants.SignedResource:
+                        signedResource = queryParameters[key];
+                        sasParameterFound = true;
+                        break;
+
+                    case Constants.QueryConstants.SignedIdentifier:
+                        signedIdentifier = queryParameters[key];
+                        sasParameterFound = true;
+                        break;
+
+                    case Constants.QueryConstants.Signature:
+                        signature = queryParameters[key];
+                        sasParameterFound = true;
+                        break;
+
+                    case Constants.QueryConstants.SignedVersion:
+                        signedVersion = queryParameters[key];
+                        sasParameterFound = true;
+                        break;
+
+                    default:
+                        break;
+                    //// string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.InvalidQueryParametersInsideBlobAddress, key.ToLower());
+                    //// throw new ArgumentException(errorMessage);
+                }
+            }
+
+            if (sasParameterFound)
+            {
+                if (signature == null || signedResource == null)
+                {
+                    string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.MissingMandatoryParamtersForSAS);
+                    throw new ArgumentException(errorMessage);
+                }
+
+                UriQueryBuilder builder = new UriQueryBuilder();
+                AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedStart, signedStart);
+                AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedExpiry, signedExpiry);
+                AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedPermissions, sigendPermissions);
+                builder.Add(Constants.QueryConstants.SignedResource, signedResource);
+                AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedIdentifier, signedIdentifier);
+                AddEscapedIfNotNull(builder, Constants.QueryConstants.SignedVersion, signedVersion);
+                AddEscapedIfNotNull(builder, Constants.QueryConstants.Signature, signature);
+
+                string token = builder.ToString();
+                credentials = new StorageCredentialsSharedAccessSignature(token);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient.csproj b/microsoft-azure-api/StorageClient.csproj
new file mode 100644
index 0000000000000..2c65c540b052d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient.csproj
@@ -0,0 +1,266 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--Copyright 2011 Microsoft Corporation
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{C6F30C10-E1C2-4327-BB6B-3160B479CCA1}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <RootNamespace>Microsoft.WindowsAzure</RootNamespace>
+    <AssemblyName>Microsoft.WindowsAzure.StorageClient</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>TRACE;DEBUG;CODE_ANALYSIS;UNSIGNED</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>bin\Debug\Microsoft.WindowsAzure.StorageClient.XML</DocumentationFile>
+    <RunCodeAnalysis>false</RunCodeAnalysis>
+    <CodeAnalysisRules>
+    </CodeAnalysisRules>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>
+    </DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <NoStdLib>false</NoStdLib>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>false</SignAssembly>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Configuration" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Data.Services.Client">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Web" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="CloudStorageAccount.cs" />
+    <Compile Include="MutableStorageCredentials.cs" />
+    <Compile Include="SharedAccessSignatureHelper.cs" />
+    <Compile Include="SR.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>SR.resx</DependentUpon>
+    </Compile>
+    <Compile Include="StorageClient\AccessCondition.cs" />
+    <Compile Include="StorageClient\BlobAttributes.cs" />
+    <Compile Include="StorageClient\BlobContainerAttributes.cs" />
+    <Compile Include="StorageClient\BlobContainerPermissions.cs" />
+    <Compile Include="StorageClient\BlobContainerProperties.cs" />
+    <Compile Include="StorageClient\BlobContainerPublicAccessType.cs" />
+    <Compile Include="StorageClient\BlobErrorCodeStrings.cs" />
+    <Compile Include="StorageClient\BlobListingDetails.cs" />
+    <Compile Include="StorageClient\BlobProperties.cs" />
+    <Compile Include="StorageClient\BlobReadStream.cs" />
+    <Compile Include="StorageClient\BlobRequestOptions.cs" />
+    <Compile Include="StorageClient\BlobStream.cs" />
+    <Compile Include="StorageClient\BlobType.cs" />
+    <Compile Include="StorageClient\BlobWriteStream.cs" />
+    <Compile Include="StorageClient\BlockListingFilter.cs" />
+    <Compile Include="StorageClient\CloudBlob.cs" />
+    <Compile Include="StorageClient\CloudBlobClient.cs" />
+    <Compile Include="StorageClient\CloudBlobContainer.cs" />
+    <Compile Include="StorageClient\CloudBlobDirectory.cs" />
+    <Compile Include="StorageClient\CloudBlockBlob.cs" />
+    <Compile Include="StorageClient\CloudPageBlob.cs" />
+    <Compile Include="StorageClient\CloudQueue.cs" />
+    <Compile Include="StorageClient\CloudQueueClient.cs" />
+    <Compile Include="StorageClient\CloudQueueMessage.cs" />
+    <Compile Include="StorageClient\CloudStorageAccountStorageClientExtensions.cs" />
+    <Compile Include="StorageClient\CloudTableClient.cs" />
+    <Compile Include="StorageClient\CloudTableQuery.cs" />
+    <Compile Include="StorageClient\CommonUtils.cs" />
+    <Compile Include="StorageClient\ContainerListingDetails.cs" />
+    <Compile Include="StorageClient\DeleteSnapshotsOption.cs" />
+    <Compile Include="StorageClient\EventHelper.cs" />
+    <Compile Include="StorageClient\IListBlobItem.cs" />
+    <Compile Include="StorageClient\LeaseStatus.cs" />
+    <Compile Include="StorageClient\ListBlockItem.cs" />
+    <Compile Include="StorageClient\MessageUpdateFields.cs" />
+    <Compile Include="StorageClient\NavigationHelper.cs" />
+    <Compile Include="StorageClient\PageRange.cs" />
+    <Compile Include="StorageClient\ParallelUpload.cs" />
+    <Compile Include="StorageClient\ProtocolHelper.cs" />
+    <Compile Include="StorageClient\Protocol\AccessPolicyResponse.cs" />
+    <Compile Include="StorageClient\Protocol\BlobContainerEntry.cs" />
+    <Compile Include="StorageClient\Protocol\BlobEntry.cs" />
+    <Compile Include="StorageClient\Protocol\BlobListingContext.cs" />
+    <Compile Include="StorageClient\Protocol\BlobPrefixEntry.cs" />
+    <Compile Include="StorageClient\Protocol\BlobRequest.cs" />
+    <Compile Include="StorageClient\Protocol\BlobResponse.cs" />
+    <Compile Include="StorageClient\Protocol\BlockSearchMode.cs" />
+    <Compile Include="StorageClient\Protocol\CanonicalizationStrategy.cs" />
+    <Compile Include="StorageClient\Protocol\CanonicalizationStrategyFactory.cs" />
+    <Compile Include="StorageClient\Protocol\CanonicalizedString.cs" />
+    <Compile Include="StorageClient\Protocol\ConditionHeaderKind.cs" />
+    <Compile Include="StorageClient\Protocol\Constants.cs" />
+    <Compile Include="StorageClient\Protocol\ContainerRequest.cs" />
+    <Compile Include="StorageClient\Protocol\ContainerResponse.cs" />
+    <Compile Include="StorageClient\Protocol\Credentials.cs" />
+    <Compile Include="StorageClient\Protocol\GetBlockListResponse.cs" />
+    <Compile Include="StorageClient\Protocol\GetMessagesResponse.cs" />
+    <Compile Include="StorageClient\Protocol\GetPageRangesResponse.cs" />
+    <Compile Include="StorageClient\Protocol\IListBlobEntry.cs" />
+    <Compile Include="StorageClient\Protocol\LeaseAction.cs" />
+    <Compile Include="StorageClient\Protocol\ListBlobsResponse.cs" />
+    <Compile Include="StorageClient\Protocol\ListContainersResponse.cs" />
+    <Compile Include="StorageClient\Protocol\ListingContext.cs" />
+    <Compile Include="StorageClient\Protocol\ListQueuesResponse.cs" />
+    <Compile Include="StorageClient\Protocol\LoggingOperations.cs" />
+    <Compile Include="StorageClient\Protocol\LoggingProperties.cs" />
+    <Compile Include="StorageClient\Protocol\MetricsLevel.cs" />
+    <Compile Include="StorageClient\Protocol\MetricsProperties.cs" />
+    <Compile Include="StorageClient\Protocol\PageWrite.cs" />
+    <Compile Include="StorageClient\Protocol\ParseExtensions.cs" />
+    <Compile Include="StorageClient\Protocol\PeekMessagesResponse.cs" />
+    <Compile Include="StorageClient\Protocol\PutBlockListItem.cs" />
+    <Compile Include="StorageClient\Protocol\PutPageProperties.cs" />
+    <Compile Include="StorageClient\Protocol\QueueEntry.cs" />
+    <Compile Include="StorageClient\Protocol\QueueMessage.cs" />
+    <Compile Include="StorageClient\Protocol\QueueRequest.cs" />
+    <Compile Include="StorageClient\Protocol\QueueResponse.cs" />
+    <Compile Include="StorageClient\Protocol\Request.cs" />
+    <Compile Include="StorageClient\Protocol\ResourceConsumedException.cs" />
+    <Compile Include="StorageClient\Protocol\Response.cs" />
+    <Compile Include="StorageClient\Protocol\ResponseParsingBase.cs" />
+    <Compile Include="StorageClient\Protocol\ServiceProperties.cs" />
+    <Compile Include="StorageClient\Protocol\SharedKeyCanonicalizer.cs" />
+    <Compile Include="StorageClient\Protocol\SharedKeyLiteCanonicalizer.cs" />
+    <Compile Include="StorageClient\Protocol\SharedKeyLiteTableCanonicalizer.cs" />
+    <Compile Include="StorageClient\Protocol\SharedKeyTableCanonicalizer.cs" />
+    <Compile Include="StorageClient\Protocol\StorageKey.cs" />
+    <Compile Include="StorageClient\Protocol\TableRequest.cs" />
+    <Compile Include="StorageClient\Protocol\TableResponse.cs" />
+    <Compile Include="StorageClient\Protocol\UriQueryBuilder.cs" />
+    <Compile Include="StorageClient\QueueAttributes.cs" />
+    <Compile Include="StorageClient\QueueErrorCodeStrings.cs" />
+    <Compile Include="StorageClient\QueueListingDetails.cs" />
+    <Compile Include="StorageClient\RequestWithRetry.cs" />
+    <Compile Include="StorageClient\ResponseReceivedEventArgs.cs" />
+    <Compile Include="StorageClient\ResultContinuation.cs" />
+    <Compile Include="StorageClient\ResultPagination.cs" />
+    <Compile Include="StorageClient\ResultSegment.cs" />
+    <Compile Include="StorageClient\RetryPolicies.cs" />
+    <Compile Include="StorageClient\RetryPolicy.cs" />
+    <Compile Include="StorageClient\SharedAccessPermissions.cs" />
+    <Compile Include="StorageClient\SharedAccessPolicies.cs" />
+    <Compile Include="StorageClient\SharedAccessPolicy.cs" />
+    <Compile Include="StorageClient\ShouldRetry.cs" />
+    <Compile Include="StorageClient\SmallBlockMemoryStream.cs" />
+    <Compile Include="StorageClient\StorageClientException.cs" />
+    <Compile Include="StorageClient\StorageErrorCode.cs" />
+    <Compile Include="StorageClient\StorageErrorCodeStrings.cs" />
+    <Compile Include="StorageClient\StorageException.cs" />
+    <Compile Include="StorageClient\StorageExceptionExtensions.cs" />
+    <Compile Include="StorageClient\StorageExtendedErrorInformation.cs" />
+    <Compile Include="StorageClient\StorageServerException.cs" />
+    <Compile Include="StorageClient\StreamUtilities.cs" />
+    <Compile Include="StorageClient\TableErrorCodeStrings.cs" />
+    <Compile Include="StorageClient\TableServiceContext.cs" />
+    <Compile Include="StorageClient\TableServiceEntity.cs" />
+    <Compile Include="StorageClient\TableServiceExtensionMethods.cs" />
+    <Compile Include="StorageClient\TableServiceTable.cs" />
+    <Compile Include="StorageClient\TableServiceUtilities.cs" />
+    <Compile Include="StorageClient\TaskImplHelper.cs" />
+    <Compile Include="StorageClient\Tasks\APMTask.cs" />
+    <Compile Include="StorageClient\Tasks\AsyncResultExtensions.cs" />
+    <Compile Include="StorageClient\Tasks\DelayTask.cs" />
+    <Compile Include="StorageClient\Tasks\InvokeTaskSequenceTask.cs" />
+    <Compile Include="StorageClient\Tasks\ITask.cs" />
+    <Compile Include="StorageClient\Tasks\NullTaskReturn.cs" />
+    <Compile Include="StorageClient\Tasks\RaceTask.cs" />
+    <Compile Include="StorageClient\Tasks\StreamExtensions.cs" />
+    <Compile Include="StorageClient\Tasks\SynchronousTask.cs" />
+    <Compile Include="StorageClient\Tasks\TableServiceExtensions.cs" />
+    <Compile Include="StorageClient\Tasks\Task.cs" />
+    <Compile Include="StorageClient\Tasks\TaskAsyncResult.cs" />
+    <Compile Include="StorageClient\Tasks\TimeoutHelper.cs" />
+    <Compile Include="StorageClient\Tasks\WebRequestExtensions.cs" />
+    <Compile Include="StorageClient\TraceHelper.cs" />
+    <Compile Include="StorageClient\Utilities.cs" />
+    <Compile Include="StorageCredentials.cs" />
+    <Compile Include="StorageCredentialsAccountAndKey.cs" />
+    <Compile Include="StorageCredentialsAnonymous.cs" />
+    <Compile Include="StorageCredentialsSharedAccessSignature.cs" />
+    <EmbeddedResource Include="SR.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>SR.Designer.cs</LastGenOutput>
+      <SubType>Designer</SubType>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+</Project>
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/AccessCondition.cs b/microsoft-azure-api/StorageClient/AccessCondition.cs
new file mode 100644
index 0000000000000..0677e59cc2797
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/AccessCondition.cs
@@ -0,0 +1,204 @@
+//-----------------------------------------------------------------------
+// <copyright file="AccessCondition.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the AccessCondition struct.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Globalization;
+    using System.Net;
+    using Protocol;
+
+    /// <summary>
+    /// Represents a set of access conditions to be used for operations against the storage services.
+    /// </summary>
+    public struct AccessCondition
+    {
+        /// <summary>
+        /// Indicates that no access condition is set.
+        /// </summary>
+        public static readonly AccessCondition None = new AccessCondition();
+
+        /// <summary>
+        /// Gets or sets the header of the request to be set.
+        /// </summary>
+        /// <value>The access condition header.</value>
+        private HttpRequestHeader? AccessConditionHeader { get; set; }
+
+        /// <summary>
+        /// Gets or sets the value of the access condition header.
+        /// </summary>
+        /// <value>The access condition header value.</value>
+        private string AccessConditionValue { get; set; }
+
+        /// <summary>
+        /// Returns an access condition such that an operation will be performed only if the resource has been modified since the specified time.
+        /// </summary>
+        /// <param name="lastModifiedUtc">The last-modified time for the resource, expressed as a UTC value.</param>
+        /// <returns>A structure specifying the if-modified-since condition.</returns>
+        public static AccessCondition IfModifiedSince(DateTime lastModifiedUtc)
+        {
+            lastModifiedUtc = lastModifiedUtc.ToUniversalTime();
+            return new AccessCondition
+            {
+                AccessConditionHeader = HttpRequestHeader.IfModifiedSince,
+
+                // convert Date to String using RFC 1123 pattern
+                AccessConditionValue = lastModifiedUtc.ToString("R", CultureInfo.InvariantCulture)
+            };
+        }
+
+        /// <summary>
+        /// Returns an access condition such that an operation will be performed only if the resource has not been modified since the specified time.
+        /// </summary>
+        /// <param name="lastModifiedUtc">The last-modified time for the resource, expressed as a UTC value.</param>
+        /// <returns>A structure specifying the if-not-modified-since condition.</returns>
+        public static AccessCondition IfNotModifiedSince(DateTime lastModifiedUtc)
+        {
+            lastModifiedUtc = lastModifiedUtc.ToUniversalTime();
+            return new AccessCondition
+            {
+                AccessConditionHeader = HttpRequestHeader.IfUnmodifiedSince,
+
+                // convert Date to String using RFC 1123 pattern
+                AccessConditionValue = Request.ConvertDateTimeToHttpString(lastModifiedUtc)
+            };
+        }
+
+        /// <summary>
+        /// Returns an access condition such that an operation will be performed only if the resource's ETag value matches the ETag value provided.
+        /// </summary>
+        /// <param name="etag">The ETag value to check.</param>
+        /// <returns>A structure specifying the if-match condition.</returns>
+        public static AccessCondition IfMatch(string etag)
+        {
+            return new AccessCondition { AccessConditionHeader = HttpRequestHeader.IfMatch, AccessConditionValue = etag };
+        }
+
+        /// <summary>
+        /// Returns an access condition such that an operation will be performed only if the resource's ETag value does not match the ETag value provided.
+        /// </summary>
+        /// <param name="etag">The ETag value to check.</param>
+        /// <returns>A structure specifying the if-none-match condition.</returns>
+        public static AccessCondition IfNoneMatch(string etag)
+        {
+            return new AccessCondition { AccessConditionHeader = HttpRequestHeader.IfNoneMatch, AccessConditionValue = etag };
+        }
+
+        /// <summary>
+        /// Converts AccessCondition into a <see cref="ConditionHeaderKind"/> type for use as a source conditional to Copy.
+        /// </summary>
+        /// <param name="condition">The original condition.</param>
+        /// <param name="header">The resulting header for the condition.</param>
+        /// <param name="value">The value for the condition.</param>
+        internal static void GetSourceConditions(
+            AccessCondition condition,
+            out Protocol.ConditionHeaderKind header,
+            out string value)
+        {
+            header = Protocol.ConditionHeaderKind.None;
+            value = null;
+
+            if (condition.AccessConditionHeader != null)
+            {
+                switch (condition.AccessConditionHeader.GetValueOrDefault())
+                {
+                    case HttpRequestHeader.IfMatch:
+                        header = Protocol.ConditionHeaderKind.IfMatch;
+                        break;
+                    case HttpRequestHeader.IfNoneMatch:
+                        header = Protocol.ConditionHeaderKind.IfNoneMatch;
+                        break;
+                    case HttpRequestHeader.IfModifiedSince:
+                        header = Protocol.ConditionHeaderKind.IfModifiedSince;
+                        break;
+                    case HttpRequestHeader.IfUnmodifiedSince:
+                        header = Protocol.ConditionHeaderKind.IfUnmodifiedSince;
+                        break;
+                    default:
+                        CommonUtils.ArgumentOutOfRange("condition", condition);
+                        break;
+                }
+
+                value = condition.AccessConditionValue;
+            }
+        }
+
+        /// <summary>
+        /// Applies the condition to the web request.
+        /// </summary>
+        /// <param name="request">The request to be modified.</param>
+        internal void ApplyCondition(HttpWebRequest request)
+        {
+            if (this.AccessConditionHeader != null)
+            {
+                if (this.AccessConditionHeader.Equals(HttpRequestHeader.IfModifiedSince))
+                {
+                    // Not using this property will cause Restricted property exception to be thrown
+                    request.IfModifiedSince = DateTime.Parse(
+                        this.AccessConditionValue,
+                        CultureInfo.InvariantCulture,
+                        DateTimeStyles.AdjustToUniversal);
+                }
+                else
+                {
+                    request.Headers[(HttpRequestHeader)this.AccessConditionHeader] = this.AccessConditionValue;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Verifies the condition is satisfied.
+        /// </summary>
+        /// <param name="etag">The ETag to check.</param>
+        /// <param name="lastModifiedTimeUtc">The last modified time UTC.</param>
+        /// <returns><c>true</c> if the condition is satisfied, otherwise <c>false</c>.</returns>
+        internal bool VerifyConditionHolds(string etag, DateTime lastModifiedTimeUtc)
+        {
+            switch (this.AccessConditionHeader.GetValueOrDefault())
+            {
+                case HttpRequestHeader.IfMatch:
+                    return this.AccessConditionValue == etag || String.Equals(this.AccessConditionValue, "*");
+                case HttpRequestHeader.IfNoneMatch:
+                    return this.AccessConditionValue != etag;
+                case HttpRequestHeader.IfModifiedSince:
+                    {
+                        var conditional = DateTime.Parse(
+                            this.AccessConditionValue,
+                            CultureInfo.InvariantCulture,
+                            DateTimeStyles.AdjustToUniversal);
+                        return lastModifiedTimeUtc > conditional;
+                    }
+
+                case HttpRequestHeader.IfUnmodifiedSince:
+                    {
+                        var conditional = DateTime.Parse(
+                            this.AccessConditionValue,
+                            CultureInfo.InvariantCulture,
+                            DateTimeStyles.AdjustToUniversal);
+                        return lastModifiedTimeUtc <= conditional;
+                    }
+
+                default:
+                    CommonUtils.ArgumentOutOfRange("AccessConditionHeader", this.AccessConditionHeader);
+                    return false;
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobAttributes.cs b/microsoft-azure-api/StorageClient/BlobAttributes.cs
new file mode 100644
index 0000000000000..06c556b54cb8c
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobAttributes.cs
@@ -0,0 +1,86 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobAttributes.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobAttributes class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using Protocol;
+
+    /// <summary>
+    /// Represents a blob's attributes.
+    /// </summary>
+    public class BlobAttributes
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobAttributes"/> class.
+        /// </summary>
+        public BlobAttributes()
+        {
+            this.Properties = new BlobProperties();
+            this.Metadata = new NameValueCollection();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobAttributes"/> class from an existing <see cref="BlobAttributes"/> object.
+        /// </summary>
+        /// <param name="other">The set of blob attributes to clone.</param>
+        public BlobAttributes(BlobAttributes other)
+        {
+            this.Properties = new BlobProperties(other.Properties);
+
+            if (other.Metadata != null)
+            {
+                this.Metadata = new NameValueCollection(other.Metadata);
+            }
+
+            this.Snapshot = other.Snapshot;
+            this.Uri = other.Uri;
+        }
+
+        /// <summary>
+        /// Gets the blob's system properties.
+        /// </summary>
+        /// <value>The blob's properties.</value>
+        public BlobProperties Properties { get; internal set; }
+
+        /// <summary>
+        /// Gets the user-defined metadata for the blob.
+        /// </summary>
+        /// <value>The blob's metadata, as a collection of name-value pairs.</value>
+        public NameValueCollection Metadata { get; internal set; }
+
+        /// <summary>
+        /// Gets the blob's URI.
+        /// </summary>
+        /// <value>The absolute URI to the blob.</value>
+        public Uri Uri { get; internal set; }
+
+        /// <summary>
+        /// Gets the date and time that the blob snapshot was taken, if this blob is a snapshot.
+        /// </summary>
+        /// <value>The blob's snapshot time if the blob is a snapshot; otherwise, <c>null</c>.</value>
+        /// <remarks>
+        /// If the blob is not a snapshot, the value of this property is <c>null</c>.
+        /// </remarks>
+        public DateTime? Snapshot { get; internal set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobContainerAttributes.cs b/microsoft-azure-api/StorageClient/BlobContainerAttributes.cs
new file mode 100644
index 0000000000000..efd43b4f3716c
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobContainerAttributes.cs
@@ -0,0 +1,64 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobContainerAttributes.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobContainerAttributes class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+
+    /// <summary>
+    /// Represents a container's attributes, including its properties and metadata.
+    /// </summary>
+    public class BlobContainerAttributes
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobContainerAttributes"/> class.
+        /// </summary>
+        public BlobContainerAttributes()
+        {
+            this.Metadata = new NameValueCollection();
+            this.Properties = new BlobContainerProperties();
+        }
+
+        /// <summary>
+        /// Gets the user-defined metadata for the container.
+        /// </summary>
+        /// <value>The container's metadata, as a collection of name-value pairs.</value>
+        public NameValueCollection Metadata { get; internal set; }
+
+        /// <summary>
+        /// Gets the container's system properties.
+        /// </summary>
+        /// <value>The container's properties.</value>
+        public BlobContainerProperties Properties { get; internal set; }
+
+        /// <summary>
+        /// Gets the name of the container.
+        /// </summary>
+        /// <value>The container's name.</value>
+        public string Name { get; internal set; }
+
+        /// <summary>
+        /// Gets the container's URI.
+        /// </summary>
+        /// <value>The absolute URI to the container.</value>
+        public Uri Uri { get; internal set; }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/BlobContainerPermissions.cs b/microsoft-azure-api/StorageClient/BlobContainerPermissions.cs
new file mode 100644
index 0000000000000..c317c29dc85a3
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobContainerPermissions.cs
@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobContainerPermissions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobContainerPermissions class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Represents the permissions for a container.
+    /// </summary>
+    public class BlobContainerPermissions
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobContainerPermissions"/> class.
+        /// </summary>
+        public BlobContainerPermissions()
+        {
+            this.PublicAccess = BlobContainerPublicAccessType.Off;
+            SharedAccessPolicies = new SharedAccessPolicies();
+        }
+
+        /// <summary>
+        /// Gets or sets the public access setting for the container.
+        /// </summary>
+        /// <value>The public access setting for the container.</value>
+        public BlobContainerPublicAccessType PublicAccess { get; set; }
+
+        /// <summary>
+        /// Gets the set of shared access policies for the container.
+        /// </summary>
+        /// <value>The set of shared access policies for the container.</value>
+        public SharedAccessPolicies SharedAccessPolicies { get; private set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobContainerProperties.cs b/microsoft-azure-api/StorageClient/BlobContainerProperties.cs
new file mode 100644
index 0000000000000..35fba435a1f9b
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobContainerProperties.cs
@@ -0,0 +1,48 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobContainerProperties.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobContainerProperties class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+
+    /// <summary>
+    /// Represents the system properties for a container.
+    /// </summary>
+    public class BlobContainerProperties
+    {
+        /// <summary>
+        /// Gets the ETag value for the container.
+        /// </summary>
+        /// <value>The container's ETag value.</value>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1702:CompoundWordsShouldBeCasedCorrectly",
+            MessageId = "ETag",
+            Justification = "ETag is the correct capitalization.")]
+        public string ETag { get; internal set; }
+
+        /// <summary>
+        /// Gets the container's last-modified time, expressed as a UTC value.
+        /// </summary>
+        /// <value>The container's last-modified time.</value>
+        public DateTime LastModifiedUtc { get; internal set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobContainerPublicAccessType.cs b/microsoft-azure-api/StorageClient/BlobContainerPublicAccessType.cs
new file mode 100644
index 0000000000000..10d18364468bf
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobContainerPublicAccessType.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobContainerPublicAccessType.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobContainerPublicAccessType enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Specifies the level of public access that is allowed on the container.
+    /// </summary>
+    public enum BlobContainerPublicAccessType
+    {
+        /// <summary>
+        /// No public access. Only the account owner can read resources in this container.
+        /// </summary>
+        Off,
+
+        /// <summary>
+        /// Container-level public access. Anonymous clients can read container and blob data.
+        /// </summary>
+        Container,
+
+        /// <summary>
+        /// Blob-level public access. Anonymous clients can read only blob data within this container.
+        /// </summary>
+        Blob
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobErrorCodeStrings.cs b/microsoft-azure-api/StorageClient/BlobErrorCodeStrings.cs
new file mode 100644
index 0000000000000..55b586913d2d9
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobErrorCodeStrings.cs
@@ -0,0 +1,53 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobErrorCodeStrings.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobErrorCodeStrings class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Provides error code strings that are specific to the Blob service.
+    /// </summary>
+    public static class BlobErrorCodeStrings
+    {
+        /// <summary>
+        /// Error code that may be returned when a block ID is invalid.
+        /// </summary>
+        public const string InvalidBlockId = "InvalidBlockId";
+
+        /// <summary>
+        /// Error code that may be returned when a blob with the specified address cannot be found.
+        /// </summary>
+        public const string BlobNotFound = "BlobNotFound";
+
+        /// <summary>
+        /// Error code that may be returned when a client attempts to create a blob that already exists.
+        /// </summary>
+        public const string BlobAlreadyExists = "BlobAlreadyExists";
+
+        /// <summary>
+        /// Error code that may be returned when the specified block or blob is invalid.
+        /// </summary>
+        public const string InvalidBlobOrBlock = "InvalidBlobOrBlock";
+
+        /// <summary>
+        /// Error code that may be returned when a block list is invalid.
+        /// </summary>
+        public const string InvalidBlockList = "InvalidBlockList";
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/BlobListingDetails.cs b/microsoft-azure-api/StorageClient/BlobListingDetails.cs
new file mode 100644
index 0000000000000..a5942cf383116
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobListingDetails.cs
@@ -0,0 +1,56 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobListingDetails.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobListingDetails enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Specifies which items to include when listing a set of blobs.
+    /// </summary>
+    [Flags]
+    public enum BlobListingDetails
+    {
+        /// <summary>
+        /// List only committed blobs, and do not return blob metadata.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        /// List committed blobs and blob snapshots.
+        /// </summary>
+        Snapshots = 0x1,
+
+        /// <summary>
+        /// Retrieve blob metadata for each blob returned in the listing.
+        /// </summary>
+        Metadata = 0x2,
+
+        /// <summary>
+        /// List committed and uncommitted blobs.
+        /// </summary>
+        UncommittedBlobs = 0x4,
+
+        /// <summary>
+        /// List all available committed blobs, uncommitted blobs, and snapshots, and return all metadata for those blobs.
+        /// </summary>
+        All = 0x7
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobProperties.cs b/microsoft-azure-api/StorageClient/BlobProperties.cs
new file mode 100644
index 0000000000000..cfe582e792c9f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobProperties.cs
@@ -0,0 +1,130 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobProperties.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobProperties class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using Protocol;
+
+    /// <summary>
+    /// Represents the system properties for a blob.
+    /// </summary>
+    public class BlobProperties
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobProperties"/> class.
+        /// </summary>
+        public BlobProperties()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobProperties"/> class based on an existing instance.
+        /// </summary>
+        /// <param name="other">The set of properties to clone.</param>
+        public BlobProperties(BlobProperties other)
+        {
+            this.BlobType = other.BlobType;
+            this.ContentEncoding = other.ContentEncoding;
+            this.ContentLanguage = other.ContentLanguage;
+            this.Length = other.Length;
+            this.ContentType = other.ContentType;
+            this.ETag = other.ETag;
+            this.LastModifiedUtc = other.LastModifiedUtc;
+            this.LeaseStatus = other.LeaseStatus;
+        }
+
+        /// <summary>
+        /// Gets or sets the cache-control value stored for the blob.
+        /// </summary>
+        /// <value>The blob's cache-control value.</value>
+        public string CacheControl { get; set; }
+
+        /// <summary>
+        /// Gets or sets the content-encoding value stored for the blob.
+        /// </summary>
+        /// <value>The blob's content-encoding value.</value>
+        /// <remarks>
+        /// If this property has not been set for the blob, it returns null.
+        /// </remarks>
+        public string ContentEncoding { get; set; }
+
+        /// <summary>
+        /// Gets or sets the content-language value stored for the blob.
+        /// </summary>
+        /// <value>The blob's content-language value.</value>
+        /// <remarks>
+        /// If this property has not been set for the blob, it returns null.
+        /// </remarks>
+        public string ContentLanguage { get; set; }
+
+        /// <summary>
+        /// Gets the size of the blob, in bytes.
+        /// </summary>
+        /// <value>The blob's size in bytes.</value>
+        public long Length { get; internal set; }
+
+        /// <summary>
+        /// Gets or sets the content-MD5 value stored for the blob.
+        /// </summary>
+        /// <value>The blob's content-MD5 hash.</value>
+        public string ContentMD5 { get; set; }
+
+        /// <summary>
+        /// Gets or sets the content-type value stored for the blob.
+        /// </summary>
+        /// <value>The blob's content-type value.</value>
+        /// <remarks>
+        /// If this property has not been set for the blob, it returns null.
+        /// </remarks>
+        public string ContentType { get; set; }
+
+        /// <summary>
+        /// Gets the blob's ETag value.
+        /// </summary>
+        /// <value>The blob's ETag value.</value>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1702:CompoundWordsShouldBeCasedCorrectly",
+            MessageId = "ETag",
+            Justification = "ETag is the proper capitalization.")]
+        public string ETag { get; internal set; }
+
+        /// <summary>
+        /// Gets the the last-modified time for the blob, expressed as a UTC value.
+        /// </summary>
+        /// <value>The blob's last-modified time, in UTC format.</value>
+        public DateTime LastModifiedUtc { get; internal set; }
+
+        /// <summary>
+        /// Gets the type of the blob.
+        /// </summary>
+        /// <value>A <see cref="BlobType"/> object that indicates the type of the blob.</value>
+        public BlobType BlobType { get; internal set; }
+
+        /// <summary>
+        /// Gets the blob's lease status.
+        /// </summary>
+        /// <value>A <see cref="LeaseStatus"/> object that indicates the blob's lease status.</value>
+        public LeaseStatus LeaseStatus { get; internal set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobReadStream.cs b/microsoft-azure-api/StorageClient/BlobReadStream.cs
new file mode 100644
index 0000000000000..451719f47fa6d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobReadStream.cs
@@ -0,0 +1,1047 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobReadStream.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobReadStream class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Security.Cryptography;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Tasks.ITask>;
+
+    /// <summary>
+    /// This class represents a seekable, read-only stream on a blob.
+    /// </summary>
+    internal class BlobReadStream : BlobStream
+    {
+        /// <summary>
+        /// The threshold beyond which we start a new read-Ahead.
+        /// </summary>
+        private const double ReadAheadThreshold = 0.25;
+
+        /// <summary>
+        /// The current position with the stream.
+        /// </summary>
+        private long position;
+
+        /// <summary>
+        /// The number of bytes to read forward on every request.
+        /// </summary>
+        private long readAheadSize;
+
+        /// <summary>
+        /// The options applied to the stream.
+        /// </summary>
+        private BlobRequestOptions options;
+
+        /// <summary>
+        /// True if the AccessCondition has been changed to match a single ETag.
+        /// </summary>
+        private bool setEtagCondition;
+
+        /// <summary>
+        /// The list of blocks for this blob.
+        /// </summary>
+        private List<ListBlockItem> blockList;
+
+        /// <summary>
+        /// The already available blocks for reading. This member is the only possible point of thread contention between the user's requests and ReadAhead async work. 
+        /// At any particular time, the ReadAhead thread may be adding more items into the list. The second thread will never remove/modify an existing item within the list.
+        /// </summary>
+        private DownloadedBlockCollection downloadedBlocksList;
+
+        /// <summary>
+        /// A handle to the parallel download of data for ReadAhead.
+        /// </summary>
+        private IAsyncResult readAheadResult;
+
+        /// <summary>
+        /// Initializes a new instance of the BlobReadStream class. 
+        /// </summary>
+        /// <param name="blob">The blob used for downloads.</param>
+        /// <param name="options">Modifiers to be applied to the blob. After first request, the ETag is always applied.</param>
+        /// <param name="readAheadInBytes">The number of bytes to read ahead.</param>
+        /// <param name="verifyBlocks">Controls whether block's signatures are verified.</param>
+        internal BlobReadStream(CloudBlob blob, BlobRequestOptions options, long readAheadInBytes, bool verifyBlocks)
+        {
+            CommonUtils.AssertNotNull("blob", blob);
+            CommonUtils.AssertNotNull("options", options);
+            CommonUtils.AssertInBounds("readAheadInBytes", readAheadInBytes, 0, Protocol.Constants.MaxBlobSize);
+
+            this.Blob = blob;
+            this.IntegrityControlVerificationEnabled = verifyBlocks;
+            this.options = options;
+            this.ReadAheadSize = readAheadInBytes;
+
+            this.downloadedBlocksList = new DownloadedBlockCollection();
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports reading.
+        /// </summary>
+        /// <value>Returns <c>true</c> if the stream supports reading; otherwise, <c>false</c>.</value>
+        public override bool CanRead
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports seeking.
+        /// </summary>
+        /// <value>Returns <c>true</c> if the stream supports seeking; otherwise, <c>false</c>.</value>
+        public override bool CanSeek
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports writing.
+        /// </summary>
+        /// <value>Returns <c>true</c> if the stream supports writing; otherwise, <c>false</c>.</value>
+        public override bool CanWrite
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream can time out.
+        /// </summary>
+        /// <value>A value that determines whether the current stream can time out.</value>
+        public override bool CanTimeout
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value, in miliseconds, that determines how long the stream will attempt to read before timing out.
+        /// </summary>
+        /// <value>A value, in miliseconds, that determines how long the stream will attempt to read before timing out.</value>
+        public override int ReadTimeout
+        {
+            get
+            {
+                return this.options.Timeout.RoundUpToMilliseconds();
+            }
+
+            set
+            {
+                this.options.Timeout = TimeSpan.FromMilliseconds(value);
+            }
+        }
+
+        /// <summary>
+        /// Gets the length of the blob. 
+        /// </summary>
+        /// <remarks>May need to do a roundtrip to retrieve it.</remarks>
+        public override long Length
+        {
+            get
+            {
+                if (!this.LengthAvailable)
+                {
+                    this.RetrieveSize();
+                }
+
+                return this.Blob.Properties.Length;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the position within the stream.
+        /// </summary>
+        public override long Position
+        {
+            get
+            {
+                return this.position;
+            }
+
+            set
+            {
+                this.Seek(value, SeekOrigin.Begin);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the number of bytes to read ahead. 
+        /// </summary>
+        public override long ReadAheadSize
+        {
+            get
+            {
+                return this.readAheadSize;
+            }
+
+            set
+            {
+                this.readAheadSize = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the signature of each downloaded block should be verified. 
+        /// </summary>
+        /// <remarks>This requires having a blocklist, having blockIDs to be in the appropriate format. This causes all reads to be rounded to the nearest block.</remarks>
+        public override bool IntegrityControlVerificationEnabled { get; internal set; }
+
+        /// <summary>
+        /// Gets the number of bytes that are cached locally but not yet read by user.
+        /// </summary>
+        internal long BufferedDataLength
+        {
+            get
+            {
+                long start, end;
+                this.downloadedBlocksList.CalculateGapLength(this.position, this.readAheadSize, out start, out end);
+                return start - this.position;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether length is available.
+        /// </summary>
+        private bool LengthAvailable
+        {
+            get
+            {
+                return (!string.IsNullOrEmpty(this.Blob.Properties.ETag) && (this.Blob.Properties.Length > 0)) || this.setEtagCondition;
+            }
+        }
+
+        /// <summary>
+        /// Setting the length of the blob is not supported.
+        /// </summary>
+        /// <param name="value">The desired length.</param>
+        /// <exception cref="NotSupportedException">Always thrown.</exception>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Write is not supported.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the current stream.</param>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Flush is not supported on read-only stream.
+        /// </summary>
+        public override void Flush()
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Seeks to the desired position. Any seek outside of the buffered/read-ahead data will cancel read-ahead and clear the buffered data.
+        /// </summary>
+        /// <param name="offset">A byte offset relative to the origin parameter.</param>
+        /// <param name="origin">A value of type System.IO.SeekOrigin indicating the reference point used to obtain the new position.</param>
+        /// <returns>The new position within the current stream.</returns>
+        /// <exception cref="ArgumentException">Thrown if offset is invalid for SeekOrigin</exception>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            switch (origin)
+            {
+                case SeekOrigin.Begin:
+                    this.CheckBounds(offset);
+
+                    this.position = offset;
+                    break;
+                case SeekOrigin.Current:
+                    this.CheckBounds(this.position + offset);
+
+                    this.position += offset;
+                    break;
+                case SeekOrigin.End:
+                    this.CheckBounds(this.Length + offset);
+
+                    this.position = this.Length + offset;
+                    break;
+            }
+
+            if (this.readAheadResult != null)
+            {
+                if (!this.readAheadResult.IsCompleted)
+                {
+                    this.readAheadResult.AsyncWaitHandle.WaitOne();
+                }
+
+                this.readAheadResult = null;
+            }
+
+            // Check any blocks that are not useful anymore
+            this.downloadedBlocksList.RemoveExtraBlocks(this.position, this.readAheadSize);
+            return this.position;
+        }
+
+        /// <summary>
+        /// Copies the specified amount of data from internal buffers to the buffer and advances the position.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values 
+        ///                     between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns> The total number of bytes read into the buffer. This can be less than the number of bytes requested 
+        /// if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
+        /// </returns>
+        /// <exception cref="System.ArgumentException">The sum of offset and count is larger than the buffer length.</exception>
+        /// <exception cref="System.ArgumentNullException">The buffer parameter is null.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">The offset or count parameters are negative.</exception>
+        /// <exception cref="System.IO.IOException">An I/O error occurs.</exception>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return TaskImplHelper.ExecuteImpl<int>((result) => { return this.ReadImplWrapper(buffer, offset, count, result); });
+        }
+
+        /// <summary>
+        /// Reads a byte from the stream and advances the position within the stream by one byte, or returns -1 if at the end of the stream.
+        /// </summary>
+        /// <returns>The unsigned byte cast to an Int32, or -1 if at the end of the stream.</returns>
+        public override int ReadByte()
+        {
+            return base.ReadByte();
+        }
+
+        /// <summary>
+        /// Begins an asynchronous read operation.
+        /// </summary>
+        /// <param name="buffer">The buffer to read the data into.</param>
+        /// <param name="offset">The byte offset in <paramref name="buffer"/> at which to begin writing data read from the stream.</param>
+        /// <param name="count">The maximum number of bytes to read.</param>
+        /// <param name="callback">An optional asynchronous callback, to be called when the read is complete.</param>
+        /// <param name="state">A user-provided object that distinguishes this particular asynchronous read request from other requests.</param>
+        /// <returns>
+        /// An <see cref="T:System.IAsyncResult"/> that represents the asynchronous read, which could still be pending.
+        /// </returns>
+        /// <exception cref="T:System.IO.IOException">
+        /// Attempted an asynchronous read past the end of the stream, or a disk error occurs.
+        /// </exception>
+        /// <exception cref="T:System.ArgumentException">
+        /// One or more of the arguments is invalid.
+        /// </exception>
+        /// <exception cref="T:System.ObjectDisposedException">
+        /// Methods were called after the stream was closed.
+        /// </exception>
+        /// <exception cref="T:System.NotSupportedException">
+        /// The current Stream implementation does not support the read operation.
+        /// </exception>
+        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImpl<int>((result) => this.ReadImplWrapper(buffer, offset, count, result), callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous read operation.
+        /// </summary>
+        /// <param name="asyncResult">The reference to the pending asynchronous request to finish.</param>
+        /// <returns>
+        /// The number of bytes read from the stream, between zero (0) and the number of bytes you requested. 
+        /// Streams return zero (0) only at the end of the stream, otherwise, they should block until at least one byte is available.
+        /// </returns>
+        /// <exception cref="T:System.ArgumentNullException">
+        /// <paramref name="asyncResult"/> is null.
+        /// </exception>
+        /// <exception cref="T:System.ArgumentException">
+        /// <paramref name="asyncResult"/> did not originate from a <see cref="M:System.IO.Stream.BeginRead(System.Byte[],System.Int32,System.Int32,System.AsyncCallback,System.Object)"/> method on the current stream.
+        /// </exception>
+        /// <exception cref="T:System.IO.IOException">
+        /// The stream is closed or an internal error has occurred.
+        /// </exception>
+        public override int EndRead(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<int>(asyncResult);
+        }
+
+        /// <summary>
+        /// Wraps the Read operation to remap any exceptions into IOException.
+        /// </summary>
+        /// <param name="buffer">The buffer to read the data into.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <param name="setResult">The action to be done upon completion to return the number of bytes read.</param>
+        /// <returns>A task sequence representing the operation.</returns>
+        /// <exception cref="System.ArgumentException">The sum of offset and count is larger than the buffer length.</exception>
+        /// <exception cref="System.ArgumentNullException">The buffer parameter is null.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">The offset or count parameters are negative</exception>
+        /// <exception cref="System.IO.IOException">An I/O error occurs.</exception>
+        private TaskSequence ReadImplWrapper(byte[] buffer, int offset, int count, Action<int> setResult)
+        {
+            StreamUtilities.CheckBufferArguments(buffer, offset, count);
+            try
+            {
+                return this.ReadImpl(buffer, offset, count, setResult);
+            }
+            catch (System.Exception ex)
+            {
+                throw new IOException("Error while reading blob", ex);
+            }
+        }
+
+        /// <summary>
+        /// Performs the read operation.
+        /// </summary>
+        /// <param name="buffer">The buffer to read the data into.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <param name="setResult">The action to be done upon completion to return the number of bytes read.</param>
+        /// <returns>A task sequence representing the operation.</returns>
+        /// <remarks>
+        /// If verification is on, retrieve the blocklist.
+        /// If there are downloaded blocks, read from there.
+        /// Otherwise, if there's an outstanding request, wait for completion and read from there.
+        /// Otherwise perform a new request.
+        /// </remarks>
+        private TaskSequence ReadImpl(byte[] buffer, int offset, int count, Action<int> setResult)
+        {
+            if (this.Blob.Properties.BlobType == BlobType.Unspecified)
+            {
+                this.Blob.FetchAttributes(this.options);
+            }
+
+            var origCount = count;
+
+            // If we don't have a blocklist and need it, get it.
+            if (this.Blob.Properties.BlobType == BlobType.BlockBlob && this.IntegrityControlVerificationEnabled && this.blockList == null)
+            {
+                var blockListTask = TaskImplHelper.GetRetryableAsyncTask<IEnumerable<ListBlockItem>>(
+                    (result) =>
+                    {
+                        return this.Blob.ToBlockBlob.GetDownloadBlockList(
+                            BlockListingFilter.Committed,
+                            this.options,
+                            result);
+                    },
+                    this.options.RetryPolicy);
+
+                yield return blockListTask;
+
+                this.blockList = blockListTask.Result.ToList();
+
+                // Verify we got a blocklist and it's in valid state. This will disable verification if it's invalid state
+                this.VerifyBlocks();
+            }
+
+            bool readComplete = false;
+
+            // Clear any pending read-aheads
+            if (this.readAheadResult != null && this.readAheadResult.IsCompleted)
+            {
+                this.readAheadResult = null;
+            }
+
+            // If we have any data, read existing data
+            if (this.downloadedBlocksList.Any())
+            {
+                readComplete = this.ReadBufferedData(buffer, ref offset, ref count);
+            }
+
+            // If we didn't complete our read and have outstanding readAhead, wait on it
+            if (!readComplete && this.readAheadResult != null && !this.readAheadResult.IsCompleted)
+            {
+                this.readAheadResult.AsyncWaitHandle.WaitOne();
+                this.readAheadResult = null;
+
+                // We now have more data, so we can do some read
+                readComplete = this.ReadBufferedData(buffer, ref offset, ref count);
+            }
+
+            long gapStart, gapEnd;
+            this.downloadedBlocksList.CalculateGapLength(this.position, count + this.readAheadSize, out gapStart, out gapEnd);
+
+            // Figure out if we need to do a server request. There are two reasons:
+            // * We have satisfied the read request, but the remaining data is low enough to warrant a ReadAhead
+            // * We didn't satisfy any of the read request and therefore must do it now
+            if (this.CalculateIfBufferTooLow(gapStart) || !readComplete)
+            {
+                long startReadAhead;
+                long readAheadCount;
+                this.CalculateReadAheadBounds(gapStart, gapEnd, count, out startReadAhead, out readAheadCount);
+
+                var blocksLeft = startReadAhead != -1;
+                var outsideBounds = this.LengthAvailable && (this.Position >= this.Length || startReadAhead >= this.Length);
+
+                // If we didn't find any blocks, that means there's no data left.
+                // If we have length, we can ensure we are within bounds. This will prevent extra round trips
+                if (!blocksLeft || outsideBounds)
+                {
+                    setResult(origCount - count);
+                    yield break;
+                }
+
+                // If we are doing an optional read-ahead, save the async result for future use
+                if (readComplete)
+                {
+                    // We should only have a single outstanding ReadAhed
+                    if (this.readAheadResult == null)
+                    {
+                        this.readAheadResult = TaskImplHelper.BeginImplWithRetry(
+                            () =>
+                            {
+                                return this.ReadAheadImpl(startReadAhead, readAheadCount);
+                            },
+                            this.options.RetryPolicy,
+                            (result) =>
+                            {
+                                this.EndReadAhead(result);
+                            },
+                            null);
+                    }
+                }
+                else
+                {
+                    var task = TaskImplHelper.GetRetryableAsyncTask(() => this.ReadAheadImpl(startReadAhead, readAheadCount), this.options.RetryPolicy);
+
+                    yield return task;
+
+                    var scratch = task.Result;
+
+                    // We now have data, so we read it
+                    readComplete = this.ReadBufferedData(buffer, ref offset, ref count);
+                }            
+            }
+
+            setResult(origCount - count);
+        }
+
+        /// <summary>
+        /// Locks download to a specific ETag.
+        /// </summary>
+        private void LockToEtag()
+        {
+            // Add the ETag
+            if (this.setEtagCondition == false && !string.IsNullOrEmpty(this.Blob.Properties.ETag))
+            {
+                this.setEtagCondition = true;
+
+                // If we have any existing conditions, see if they failed.
+                if (!this.options.AccessCondition.Equals(AccessCondition.None))
+                {
+                    if (!this.options.AccessCondition.VerifyConditionHolds(
+                        this.Blob.Properties.ETag,
+                        this.Blob.Properties.LastModifiedUtc))
+                    {
+                        throw new StorageClientException(
+                            StorageErrorCode.ConditionFailed,
+                            SR.ConditionNotMatchedError,
+                            System.Net.HttpStatusCode.PreconditionFailed,
+                            null,
+                            null);
+                    }
+                }
+
+                this.options.AccessCondition = AccessCondition.IfMatch(this.Blob.Properties.ETag);
+            }
+        }
+
+        /// <summary>
+        /// Reads the data from the service starting at the specified location. Verifies the block's signature (if required) and adds it to the buffered data.
+        /// </summary>
+        /// <param name="startPosition">The starting position of the read-ahead.</param>
+        /// <param name="length">The number of bytes to read ahead.</param>
+        /// <returns> An TaskSequence that represents the asynchronous read action. </returns>
+        private TaskSequence ReadAheadImpl(long startPosition, long length)
+        {
+            var webResponseTask = new InvokeTaskSequenceTask<Stream>((result) => { return this.Blob.GetStreamImpl(options, startPosition, length, result); });
+            yield return webResponseTask;
+
+            using (var stream = webResponseTask.Result)
+            {
+                this.LockToEtag();
+
+                if (this.IntegrityControlVerificationEnabled && this.Blob.Properties.BlobType == BlobType.BlockBlob)
+                {
+                    long blockStartPosition = 0;
+                    foreach (var block in this.blockList)
+                    {
+                        var blockSize = block.Size;
+
+                        // Find the starting block
+                        if (blockStartPosition < startPosition)
+                        {
+                            blockStartPosition += blockSize;
+                            continue;
+                        }
+
+                        // Start creating blocks
+                        var memoryStream = new SmallBlockMemoryStream(Constants.DefaultBufferSize);
+                        var md5Check = MD5.Create();
+                        int totalCopied = 0, numRead = 0;
+                        do
+                        {
+                            byte[] buffer = new byte[Constants.DefaultBufferSize];
+                            var numToRead = (int)Math.Min(buffer.Length, blockSize - totalCopied);
+                            var readTask = stream.ReadAsync(buffer, 0, numToRead);
+                            yield return readTask;
+
+                            numRead = readTask.Result;
+
+                            if (numRead != 0)
+                            {
+                                // Verify the content
+                                StreamUtilities.ComputeHash(buffer, 0, numRead, md5Check);
+
+                                var writeTask = memoryStream.WriteAsync(buffer, 0, numRead);
+                                yield return writeTask;
+                                var scratch = writeTask.Result; // Materialize any exceptions
+                                totalCopied += numRead;
+                            }
+                        }
+                        while (numRead != 0 && totalCopied < blockSize);
+
+                        // If we read something, act on it
+                        if (totalCopied != 0)
+                        {
+                            // Verify the hash
+                            string blockNameMD5Value = Utilities.ExtractMD5ValueFromBlockID(block.Name);
+
+                            if (blockNameMD5Value != StreamUtilities.GetHashValue(md5Check))
+                            {
+                                throw new InvalidDataException("Blob data corrupted (integrity check failed)");
+                            }
+
+                            memoryStream.Position = 0; // Rewind the stream to allow for reading
+
+                            this.downloadedBlocksList.Add(new DownloadedBlock(startPosition, memoryStream));
+
+                            startPosition += blockSize;
+                            blockStartPosition += blockSize;
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                }
+                else
+                {
+                    var memoryStream = new SmallBlockMemoryStream(Constants.DefaultBufferSize);
+                    var copyTask = new InvokeTaskSequenceTask(() => { return stream.WriteTo(memoryStream); });
+                    yield return copyTask;
+
+                    var scratch = copyTask.Result; // Materialize any errors
+
+                    memoryStream.Position = 0; // Rewind the stream to allow for reading
+                    this.downloadedBlocksList.Add(new DownloadedBlock(startPosition, memoryStream));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Ends an asynchronous read-ahead operation.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <exception cref="ArgumentNullException">asyncResult is null</exception>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        private void EndReadAhead(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Retrieves the size of the blob.
+        /// </summary>
+        /// <remarks>If verification is on, it will retrieve the blocklist as well</remarks>
+        private void RetrieveSize()
+        {
+            try
+            {
+                this.Blob.FetchAttributes(this.options);
+            }
+            catch (System.Exception ex)
+            {
+                throw new IOException("Error while retrieving size", ex);
+            }
+        }
+
+        /// <summary>
+        /// Verifies if the blocks are in expected format. Disables the integrity control if they are not appropriate for validation.
+        /// </summary>
+        private void VerifyBlocks()
+        {
+            this.LockToEtag();
+
+            if (this.blockList == null || this.blockList.Count == 0)
+            {
+                this.IntegrityControlVerificationEnabled = false;
+                return;
+            }
+
+           if (this.blockList[0].Name.Length == Constants.V2MD5blockIdExpectedLength &&
+                this.blockList[0].Name.StartsWith(Constants.V2blockPrefix))
+            {
+                // New V2 style Block IDs
+                foreach (var block in this.blockList)
+                {
+                    if (block.Name.Length != Constants.V2MD5blockIdExpectedLength ||
+                        !block.Name.StartsWith(Constants.V2blockPrefix))
+                    {
+                        this.IntegrityControlVerificationEnabled = false;
+                        break;
+                    }
+                }
+            }
+           else if (this.blockList[0].Name.Length == Constants.V1MD5blockIdExpectedLength && this.blockList[0].Name.StartsWith(Constants.V1BlockPrefix))
+           {
+               // Old 1.3 and lower style Block IDs
+               foreach (var block in this.blockList)
+               {
+                   if (block.Name.Length != Constants.V1MD5blockIdExpectedLength || !block.Name.StartsWith(Constants.V1BlockPrefix))
+                   {
+                       this.IntegrityControlVerificationEnabled = false;
+                       break;
+                   }
+               }
+           }
+           else
+           {
+               this.IntegrityControlVerificationEnabled = false;
+           }
+        }
+
+        /// <summary>
+        /// Calculates the ReadAhead bounds (start and count) as required by the existing data.
+        /// </summary>
+        /// <param name="gapStart">The desired start position.</param>
+        /// <param name="gapEnd">The end of the existing gap.</param>
+        /// <param name="count">The desired number of bytes.</param>
+        /// <param name="startReadAhead">The start position rounded down to the nearest block start.</param>
+        /// <param name="readAheadCount">The number of bytes with readAheadSize included and rounded up to the end of the nearest block.</param>
+        /// <remarks>This calculates the bounds based on the blocklist, not any existing data.</remarks>
+        private void CalculateReadAheadBounds(long gapStart, long gapEnd, int count, out long startReadAhead, out long readAheadCount)
+        {
+            readAheadCount = startReadAhead = -1;
+            var minReadCount = Math.Min(gapEnd - gapStart, count + this.readAheadSize);
+
+            if (this.IntegrityControlVerificationEnabled && this.Blob.Properties.BlobType == BlobType.BlockBlob)
+            {
+                long blockStart = 0;
+                foreach (var block in this.blockList)
+                {
+                    long blockEnd = blockStart + block.Size;
+
+                    // If the start hasn't been set, calculate it
+                    if (startReadAhead == -1)
+                    {
+                        if (gapStart >= blockStart
+                            && gapStart < blockEnd)
+                        {
+                            startReadAhead = blockStart;
+                            readAheadCount = blockEnd - startReadAhead;
+                        }
+                    }
+
+                    // Start is set, so calculate the end
+                    if (startReadAhead != -1)
+                    {
+                        var desiredEnd = gapStart + minReadCount;
+                        if (desiredEnd >= blockStart
+                            && desiredEnd < blockEnd)
+                        {
+                            readAheadCount = blockEnd - startReadAhead;
+                            break;
+                        }
+                    }
+
+                    blockStart = blockEnd;
+                }
+            }
+            else
+            {
+                startReadAhead = gapStart;
+                var endReadAheadPosition = startReadAhead + minReadCount;
+                readAheadCount = endReadAheadPosition - startReadAhead;
+            }
+        }
+
+        /// <summary>
+        /// Reads from the verified blocks as much data as is available and needed.
+        /// </summary>
+        /// <param name="buffer">The buffer to read the data into.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns>True if there was any data read.</returns>
+        private bool ReadBufferedData(byte[] buffer, ref int offset, ref int count)
+        {
+            bool readCompleated = false;
+            while (count != 0 && this.downloadedBlocksList.Any())
+            {
+                var currentBlock = this.downloadedBlocksList.GetBlockByPosition(this.position);
+                if (currentBlock == null)
+                {
+                    return readCompleated;
+                }
+
+                // Make sure the block's position is correct relative to global position
+                currentBlock.BlockContent.Position = this.position - currentBlock.StartOffset;
+
+                var blockRemainingSize = currentBlock.BlockContent.Length - currentBlock.BlockContent.Position;
+
+                var numRead = currentBlock.BlockContent.Read(buffer, offset, (int)Math.Min(count, blockRemainingSize));
+                readCompleated = true;
+                this.position += numRead;
+                offset += numRead;
+                count -= numRead;
+
+                // Check if the block is exhausted
+                if (currentBlock.BlockContent.Position == currentBlock.BlockContent.Length)
+                {
+                    lock (this.downloadedBlocksList)
+                    {
+                        this.downloadedBlocksList.Remove(currentBlock.StartOffset);
+                    }
+                }
+            }
+
+            return readCompleated;
+        }
+
+        /// <summary>
+        /// Calculates if the currently held data is less than <see cref="ReadAheadThreshold"/> percentage depleted.
+        /// </summary>
+        /// <param name="gapStart">The start position for any ReadAhead based on the last block.</param>
+        /// <returns>True if more data is needed.</returns>
+        private bool CalculateIfBufferTooLow(long gapStart)
+        {
+            var remainingSize = gapStart - this.position;
+            return remainingSize < (ReadAheadThreshold * this.readAheadSize);
+        }
+
+        /// <summary>
+        /// Verifies if the given offset is within the bounds of the stream. 
+        /// </summary>
+        /// <param name="offset">The offset to be checked.</param>
+        /// <remarks>This may do a server round-trip if the length is not known.</remarks>
+        private void CheckBounds(long offset)
+        {
+            if (offset < 0)
+            {
+                throw new ArgumentException(SR.SeekTooLowError, "offset");
+            }
+        }
+
+        /// <summary>
+        /// Represents a single block of data that was downloaded.
+        /// </summary>
+        internal class DownloadedBlock
+        {
+            /// <summary>
+            /// Initializes a new instance of the <see cref="DownloadedBlock"/> class.
+            /// </summary>
+            /// <param name="startOffset">The start offset.</param>
+            /// <param name="content">The content.</param>
+            internal DownloadedBlock(long startOffset, Stream content)
+            {
+                this.StartOffset = startOffset;
+                this.BlockContent = content;
+            }
+
+            /// <summary>
+            /// Gets the starting location of the block.
+            /// </summary>
+            public long StartOffset { get; private set; }
+
+            /// <summary>
+            /// Gets the content of the block.
+            /// </summary>
+            public Stream BlockContent { get; private set; }
+        }
+
+        /// <summary>
+        /// Encapsulates the collection of downloaded blocks and provides appropriate locking mechanism.
+        /// </summary>
+        internal class DownloadedBlockCollection
+        {
+            /// <summary>
+            /// Holds the downloaded blocks.
+            /// </summary>
+            private SortedList<long, DownloadedBlock> downloadedBlocksList = new SortedList<long, DownloadedBlock>();
+
+            /// <summary>
+            /// Finds the block that contains the data for the <paramref name="desiredPosition"/>.
+            /// </summary>
+            /// <param name="desiredPosition">The position which is requested.</param>
+            /// <returns>A block that contains the data for the <paramref name="desiredPosition"/> or null.</returns>
+            internal DownloadedBlock GetBlockByPosition(long desiredPosition)
+            {
+                // Need to lock the list to make sure it's not modified while traversing
+                lock (this.downloadedBlocksList)
+                {
+                    foreach (var kvp in this.downloadedBlocksList)
+                    {
+                        var block = kvp.Value;
+                        if (desiredPosition >= block.StartOffset)
+                        {
+                            // If we are within the block, return it. Otherwise we don't have a valid block. That shouldn't happen.
+                            if ((desiredPosition - block.StartOffset) < block.BlockContent.Length)
+                            {
+                                return block;
+                            }
+                            else
+                            {
+                                return null;
+                            }
+                        }
+                    }
+                }
+
+                return null;
+            }
+
+            /// <summary>
+            /// Removes any downloaded blocks that are outside the current bounds (position and readAheadSize).
+            /// </summary>
+            /// <param name="position">The position before which all blocks should be purged.</param>
+            /// <param name="bufferedLength">Size of the read-ahead beyond position for blocks to be kept.</param>
+            internal void RemoveExtraBlocks(long position, long bufferedLength)
+            {
+                if (this.downloadedBlocksList.Count != 0)
+                {
+                    var farPoint = position + bufferedLength;
+                    lock (this.downloadedBlocksList)
+                    {
+                        for (int blockID = 0; blockID < this.downloadedBlocksList.Count; blockID++)
+                        {
+                            var block = this.downloadedBlocksList.Values[blockID];
+
+                            // Check for a block that's already passed
+                            if (position >= block.StartOffset + block.BlockContent.Length)
+                            {
+                                this.downloadedBlocksList.Remove(block.StartOffset);
+                                blockID--;
+                                continue;
+                            }
+
+                            // Remove the downloaded blocks after rewinding.
+                            if (position < block.StartOffset)
+                            {
+                                this.downloadedBlocksList.Remove(block.StartOffset);
+                                blockID--;
+                            }
+                        }
+                    }
+                }
+            }
+
+            /// <summary>
+            /// Calculates the length of the gap relative to <paramref name="position"/>.
+            /// </summary>
+            /// <param name="position">The position from which to find the gap.</param>
+            /// <param name="desiredLength">Size of the desired.</param>
+            /// <param name="gapStart">The gap start.</param>
+            /// <param name="gapEnd">The gap end.</param>
+            internal void CalculateGapLength(long position, long desiredLength, out long gapStart, out long gapEnd)
+            {
+                var readAheadStartPosition = position;
+
+                if (this.Any())
+                {
+                    gapStart = gapEnd = -1;
+                    DownloadedBlock block = null;
+                    lock (this.downloadedBlocksList)
+                    {
+                        // Walk all blocks and find the next gap starting 
+                        foreach (var kvp in this.downloadedBlocksList)
+                        {
+                            // If we aren't beyond a block, we need to read from there. 
+                            block = kvp.Value;
+                            if (gapStart == -1 && readAheadStartPosition < block.StartOffset)
+                            {
+                                gapStart = readAheadStartPosition;
+                                gapEnd = block.StartOffset - 1;
+                                break;
+                            }
+
+                            readAheadStartPosition = block.StartOffset + block.BlockContent.Length;
+                        }
+                    }
+
+                    // If we walked the whole list and didn't find a gap, we are close to the end.
+                    if (gapStart == -1)
+                    {
+                        gapStart = block.StartOffset + block.BlockContent.Length;
+                        gapEnd = gapStart + desiredLength;
+                    }
+                }
+                else
+                {
+                    gapStart = position;
+                    gapEnd = position + desiredLength;
+                }
+
+                System.Diagnostics.Debug.Assert(gapStart != -1, "Ensure that the gap bounds are not negative.");
+                System.Diagnostics.Debug.Assert(gapEnd != -1, "Ensure that the gap bounds are not negative.");
+            }
+
+            /// <summary>
+            /// Tells if there are any blocks available.
+            /// </summary>
+            /// <returns>Returns <c>true</c> if there are any blocks; otherwise, <c>false</c>.</returns>
+            internal bool Any()
+            {
+                return this.downloadedBlocksList.Count != 0;
+            }
+
+            /// <summary>
+            /// Adds the specified downloaded block.
+            /// </summary>
+            /// <param name="downloadedBlock">The downloaded block.</param>
+            internal void Add(DownloadedBlock downloadedBlock)
+            {
+                lock (this.downloadedBlocksList)
+                {
+                    this.downloadedBlocksList.Add(downloadedBlock.StartOffset, downloadedBlock);
+                }
+            }
+
+            /// <summary>
+            /// Removes the specified block based on the startOffset key.
+            /// </summary>
+            /// <param name="key">The key for the block.</param>
+            internal void Remove(long key)
+            {
+                lock (this.downloadedBlocksList)
+                {
+                    this.downloadedBlocksList.Remove(key);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/BlobRequestOptions.cs b/microsoft-azure-api/StorageClient/BlobRequestOptions.cs
new file mode 100644
index 0000000000000..e03f322d13b7b
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobRequestOptions.cs
@@ -0,0 +1,164 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobRequestOptions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobRequestOptions.cs class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Represents a set of options that may be specified on a request.
+    /// </summary>
+    public class BlobRequestOptions
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobRequestOptions"/> class.
+        /// </summary>
+        public BlobRequestOptions()
+        {
+            this.AccessCondition = AccessCondition.None;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobRequestOptions"/> class based on an 
+        /// existing instance.
+        /// </summary>
+        /// <param name="other">The set of request options to clone.</param>
+        public BlobRequestOptions(BlobRequestOptions other)
+        {
+            this.Timeout = other.Timeout;
+            this.RetryPolicy = other.RetryPolicy;
+            this.AccessCondition = other.AccessCondition;
+
+            this.CopySourceAccessCondition = other.CopySourceAccessCondition;
+            this.DeleteSnapshotsOption = other.DeleteSnapshotsOption;
+            this.BlobListingDetails = other.BlobListingDetails;
+            this.UseFlatBlobListing = other.UseFlatBlobListing;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobRequestOptions"/> class.
+        /// </summary>
+        /// <param name="service">An object of type <see cref="CloudBlobClient"/>.</param>
+        internal BlobRequestOptions(CloudBlobClient service)
+            : this()
+        {
+            this.ApplyDefaults(service);
+        }
+
+        /// <summary>
+        /// Gets or sets the retry policy for the request.
+        /// </summary>
+        /// <value>The retry policy delegate.</value>
+        public RetryPolicy RetryPolicy { get; set; }
+
+        /// <summary>
+        /// Gets or sets the server and client timeout for the request. 
+        /// </summary>
+        /// <value>The server and client timeout interval for the request.</value>
+        public TimeSpan? Timeout { get; set; }
+
+        /// <summary>
+        /// Gets or sets the access condition for the request.
+        /// </summary>
+        /// <value>A structure that specifies any conditional parameters on the request.</value>
+        public AccessCondition AccessCondition { get; set; }
+
+        /// <summary>
+        /// Gets or sets the access condition on the source blob, when the request is to copy a blob.
+        /// </summary>
+        /// <value>A structure that specifies any conditional parameters on the request.</value>
+        /// <remarks>
+        /// This property is applicable only to a request that will copy a blob.
+        /// </remarks>
+        public AccessCondition CopySourceAccessCondition { get; set; }
+
+        /// <summary>
+        /// Gets or sets options for deleting snapshots when a blob is to be deleted.
+        /// </summary>
+        /// <value>One of the enumeration values that specifies whether to delete blobs and snapshots, delete blobs only, or delete snapshots only.</value>
+        /// <remarks>
+        /// This property is applicable only to a request that will delete a blob.
+        /// </remarks>
+        public DeleteSnapshotsOption DeleteSnapshotsOption { get; set; }
+
+        /// <summary>
+        /// Gets or sets options for listing blobs.
+        /// </summary>
+        /// <value>One of the enumeration values that indicates what items a listing operation will return.</value>
+        /// <remarks>
+        /// This property is applicable only to a request to list blobs.
+        /// </remarks>
+        public BlobListingDetails BlobListingDetails { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the blob listing operation will list all blobs in a container in a flat listing,
+        /// or whether it will list blobs hierarchically, by virtual directory.
+        /// </summary>
+        /// <value><c>True</c> if blobs will be listed in a flat listing; otherwise, <c>false</c>. The default value is <c>false</c>.</value>
+        /// <remarks>
+        /// This property is applicable only to a request to list blobs.
+        /// </remarks>
+        public bool UseFlatBlobListing { get; set; }
+
+        /// <summary>
+        /// Creates the full modifier.
+        /// </summary>
+        /// <typeparam name="T">The type of the options.</typeparam>
+        /// <param name="service">The service.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A full modifier of the requested type.</returns>
+        internal static T CreateFullModifier<T>(CloudBlobClient service, T options)
+            where T : BlobRequestOptions, new()
+        {
+            T fullModifier = null;
+
+            if (options != null)
+            {
+                fullModifier = options.Clone() as T;
+            }
+            else
+            {
+                fullModifier = new T();
+            }
+
+            fullModifier.ApplyDefaults(service);
+            return fullModifier;
+        }
+
+        /// <summary>
+        /// Clones this instance.
+        /// </summary>
+        /// <returns>A clone of the instance.</returns>
+        internal virtual BlobRequestOptions Clone()
+        {
+            return new BlobRequestOptions(this);
+        }
+
+        /// <summary>
+        /// Applies the defaults.
+        /// </summary>
+        /// <param name="service">The service.</param>
+        internal virtual void ApplyDefaults(CloudBlobClient service)
+        {
+            this.Timeout = this.Timeout ?? service.Timeout;
+            this.RetryPolicy = this.RetryPolicy ?? service.RetryPolicy;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobStream.cs b/microsoft-azure-api/StorageClient/BlobStream.cs
new file mode 100644
index 0000000000000..6ae71387bbefd
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobStream.cs
@@ -0,0 +1,126 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobStream.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobStream class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.IO;
+
+    /// <summary>
+    /// Represents a stream for reading and writing to a blob.
+    /// </summary>
+    public abstract class BlobStream : Stream
+    {
+        /// <summary>
+        /// Gets a reference to the blob on which the stream is opened.
+        /// </summary>
+        /// <value>The blob this stream accesses.</value>
+        public CloudBlob Blob { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether the signature of each block should be verified.
+        /// </summary>
+        /// <value>
+        /// Returns <c>true</c> if integrity control verification is enabled; otherwise, <c>false</c>.
+        /// </value>
+        public virtual bool IntegrityControlVerificationEnabled
+        {
+            get
+            {
+                return true;
+            }
+
+            internal set
+            {
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the number of bytes to read ahead.
+        /// </summary>
+        /// <value>The number of bytes to read ahead.</value>
+        /// <remarks>
+        /// This operation is not currently supported.
+        /// </remarks>
+        public virtual long ReadAheadSize
+        {
+            get { throw new NotSupportedException(); }
+             set { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        /// Gets or sets the block size.
+        /// </summary>
+        /// <value>The size of the block.</value>
+        /// <remarks>
+        /// This operation is not currently supported.
+        /// </remarks>
+        public virtual long BlockSize
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+
+        /// <summary>
+        /// Aborts the operation to write to the blob. 
+        /// </summary>
+        public virtual void Abort()
+        {
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to commit a blob.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        /// <remarks>
+        /// This operation is not currently supported.
+        /// </remarks>
+        public virtual IAsyncResult BeginCommit(AsyncCallback callback, object state)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to commit the blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <exception cref="ArgumentNullException">asyncResult is null</exception>
+        /// <remarks>
+        /// This operation is not currently supported.
+        /// </remarks>
+        public virtual void EndCommit(IAsyncResult asyncResult)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Commits the blob.
+        /// </summary>
+        /// <remarks>
+        /// This operation is not currently supported.
+        /// </remarks>
+        public virtual void Commit()
+        {
+            throw new NotSupportedException();
+        }        
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobType.cs b/microsoft-azure-api/StorageClient/BlobType.cs
new file mode 100644
index 0000000000000..71f2eab35db05
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobType.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobType.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobType enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// The type of a blob.
+    /// </summary>
+    public enum BlobType
+    {
+        /// <summary>
+        /// Not specified.
+        /// </summary>
+        Unspecified,
+
+        /// <summary>
+        /// A page blob.
+        /// </summary>
+        PageBlob,
+
+        /// <summary>
+        /// A block blob.
+        /// </summary>
+        BlockBlob,
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/BlobWriteStream.cs b/microsoft-azure-api/StorageClient/BlobWriteStream.cs
new file mode 100644
index 0000000000000..6b392e3a14b0e
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlobWriteStream.cs
@@ -0,0 +1,689 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobWriteStream.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobWriteStream class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Security.Cryptography;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Tasks.ITask>;
+
+    /// <summary>
+    /// The class is an append-only stream for writing into storage.
+    /// </summary>
+    internal class BlobWriteStream : BlobStream
+    {
+        /// <summary>
+        /// Internal Block ID sequence number. Used in generating Block IDs.
+        /// </summary>
+        private long blockIdSequenceNumber = -1;
+
+        /// <summary>
+        /// The stream is writable until committed/close.
+        /// </summary>
+        private bool canWrite;
+
+        /// <summary>
+        /// The current position within the blob.
+        /// </summary>
+        private long position;
+
+        /// <summary>
+        /// The size of the blocks to use.
+        /// </summary>
+        private long blockSize;
+
+        /// <summary>
+        /// The list of uploaded blocks.
+        /// </summary>
+        private List<string> blockList;
+
+        /// <summary>
+        /// A memory stream holding the current block information.
+        /// </summary>
+        private SmallBlockMemoryStream blockBuffer;
+
+        /// <summary>
+        /// The hash of the current block.
+        /// </summary>
+        private HashAlgorithm blockHash;
+
+        /// <summary>
+        /// The ongoing blob hash.
+        /// </summary>
+        private HashAlgorithm blobHash;
+
+        /// <summary>
+        /// The set of options applying to the current blob.
+        /// </summary>
+        private BlobRequestOptions currentModifier;
+
+        /// <summary>
+        /// Initializes a new instance of the BlobWriteStream class. 
+        /// </summary>
+        /// <param name="blob">The blob used for uploads.</param>
+        /// <param name="options">The options used for the stream.</param>
+        /// <param name="blockSize">The size of the blocks to use.</param>
+        internal BlobWriteStream(CloudBlockBlob blob, BlobRequestOptions options, long blockSize)
+        {
+            CommonUtils.AssertNotNull("blob", blob);
+            CommonUtils.AssertNotNull("options", options);
+
+            this.Blob = blob;
+            this.blobHash = MD5.Create();
+            ((BlobWriteStream)this).BlockSize = blockSize;
+            this.blockList = new List<string>();
+            this.currentModifier = options;
+            this.canWrite = true;
+
+            Random rand = new Random();
+            this.blockIdSequenceNumber = (long)rand.Next() << 32;
+            this.blockIdSequenceNumber += rand.Next();
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports reading.
+        /// </summary>
+        /// <value>Returns <c>true</c> if the stream supports reading; otherwise, <c>false</c>.</value>
+        public override bool CanRead
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports seeking.
+        /// </summary>
+        /// <value>Returns <c>true</c> if the stream supports seeking; otherwise, <c>false</c>.</value>
+        public override bool CanSeek
+        {
+            get
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports writing.
+        /// </summary>
+        /// <value>Returns <c>true</c> if the stream supports writing; otherwise, <c>false</c>.</value>
+        public override bool CanWrite
+        {
+            get
+            {
+                return this.canWrite;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream can time out.
+        /// </summary>
+        /// <value>A value that determines whether the current stream can time out.</value>
+        public override bool CanTimeout
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value, in milliseconds, that determines how long the stream will attempt to write before timing out.
+        /// </summary>
+        public override int WriteTimeout
+        {
+            get
+            {
+                return this.currentModifier.Timeout.RoundUpToMilliseconds();
+            }
+
+            set
+            {
+                this.currentModifier.Timeout = TimeSpan.FromMilliseconds(value);
+            }
+        }
+
+        /// <summary>
+        /// Gets the current length (equal to the position).
+        /// </summary>
+        /// <value>
+        /// A long value representing the length of the stream in bytes.
+        /// </value>
+        /// <exception cref="T:System.NotSupportedException">
+        /// A class derived from Stream does not support seeking.
+        /// </exception>
+        /// <exception cref="T:System.ObjectDisposedException">
+        /// Methods were called after the stream was closed.
+        /// </exception>
+        public override long Length
+        {
+            get
+            {
+                return this.Position;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the current position.
+        /// </summary>
+        /// <value>
+        /// The current position within the stream.
+        /// </value>
+        /// <exception cref="T:System.IO.IOException">
+        /// An I/O error occurs.
+        /// </exception>
+        /// <exception cref="T:System.NotSupportedException">
+        /// The stream does not support seeking.
+        /// </exception>
+        /// <exception cref="T:System.ObjectDisposedException">
+        /// Methods were called after the stream was closed.
+        /// </exception>
+        public override long Position
+        {
+            get
+            {
+                return this.position;
+            }
+
+            set
+            {
+                this.Seek(value, SeekOrigin.Begin);
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the block size.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Usage",
+            "CA2208:InstantiateArgumentExceptionsCorrectly",
+            Justification = "This is for BlockSize variable itself")]
+        public override long BlockSize
+        {
+            get
+            {
+                return this.blockSize;
+            }
+
+            set
+            {
+                // Prevent changing to no-blocklist once a block is written
+                if (this.blockList != null && this.blockList.Count != 0 && value == 0)
+                {
+                    throw new InvalidOperationException(SR.BlocksExistError);
+                }
+
+                if (this.blockBuffer != null && this.blockBuffer.Length >= value)
+                {
+                    throw new ArgumentOutOfRangeException("BlockSize", SR.BlobSizeReductonError);
+                }
+
+                if (value > Protocol.Constants.MaxBlockSize)
+                {
+                    throw new ArgumentOutOfRangeException("BlockSize", String.Format(CultureInfo.CurrentCulture, SR.BlockTooLargeError, Protocol.Constants.MaxBlockSize));
+                }
+
+                if (value < 0)
+                {
+                    throw new ArgumentOutOfRangeException("BlockSize", SR.BlocksTooSmallError);
+                }
+
+                this.blockSize = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the upload is done in blocks.
+        /// </summary>
+        /// <value>Returns <c>true</c> if blocks are to be used; otherwise, <c>false</c>.</value>
+        private bool UseBlocks
+        {
+            get
+            {
+                return this.BlockSize != 0;
+            }
+        }
+
+        /// <summary>
+        /// The stream does not support reading.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values 
+        ///                     between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns> The total number of bytes read into the buffer. This can be less than the number of bytes requested 
+        /// if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
+        /// </returns>
+        /// <exception cref="System.NotSupportedException">Not supported operation as this is a write-only stream</exception>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// The stream does not support seeking.
+        /// </summary>
+        /// <param name="offset">A byte offset relative to the origin parameter.</param>
+        /// <param name="origin">A value of type System.IO.SeekOrigin indicating the reference point used to obtain the new position.</param>
+        /// <returns>The new position within the current stream.</returns>
+        /// <exception cref="System.NotSupportedException">Not supported operation as this is a write-only stream</exception>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// The stream does not support setting of length.
+        /// </summary>
+        /// <param name="value">The desired length of the current stream in bytes.</param>
+        /// <exception cref="System.NotSupportedException">Growing a stream is not possible without writing.</exception>
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+
+        /// <summary>
+        /// Write the provided data into the underlying stream.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the current stream.</param>
+        /// <exception cref="System.ArgumentNullException"><paramref name="buffer"/> is null.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">offset or count is negative.</exception>
+        /// <exception cref="System.ObjectDisposedException">Thrown if blob is already committed/closed</exception>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            this.EndWrite(this.BeginWrite(buffer, offset, count, null, null));
+        }
+
+        /// <summary>
+        /// Copies a single byte into the stream.
+        /// </summary>
+        /// <param name="value">The byte of data to be written.</param>
+        public override void WriteByte(byte value)
+        {
+            base.WriteByte(value);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous write operation.
+        /// </summary>
+        /// <param name="buffer">The buffer to write data from.</param>
+        /// <param name="offset">The byte offset in buffer from which to begin writing.</param>
+        /// <param name="count">The  number of bytes to write.</param>
+        /// <param name="callback">An optional asynchronous callback, to be called when the write is complete.</param>
+        /// <param name="state">A user-provided object that distinguishes this particular asynchronous write request from other requests.</param>
+        /// <returns>An IAsyncResult that represents the asynchronous write, which could still be pending.</returns>
+        /// <exception cref="System.ArgumentNullException"><paramref name="buffer"/> is null.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">offset or count is negative.</exception>
+        /// <exception cref="System.ObjectDisposedException">Thrown if blob is already committed/closed</exception>
+        /// <remarks>The operation will be completed synchronously if the buffer is not filled</remarks>
+        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
+        {
+            this.CheckWriteState();
+            StreamUtilities.CheckBufferArguments(buffer, offset, count);
+
+            Task<NullTaskReturn> task = null;
+
+            if (this.UseBlocks)
+            {
+                task = new InvokeTaskSequenceTask(() =>
+                {
+                    return this.WriteBlockBlobImpl(buffer, offset, count);
+                });
+            }
+            else
+            {
+                task = this.WriteNonBlockedBlobImpl(buffer, offset, count);
+            }
+
+            return task.ToAsyncResult(callback, state);
+        }
+
+        /// <summary>B
+        /// Ends an asynchronous write operation.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <exception cref="ArgumentNullException">asyncResult is null</exception>
+        public override void EndWrite(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Causes any buffered data to be written to the remote storage. If the blob is not using blocks, the blob is fully committed.
+        /// </summary>
+        /// <exception cref="System.IO.IOException">An I/O error occurs while writing to storage.</exception>
+        public override void Flush()
+        {
+            this.CheckWriteState();
+
+            TaskImplHelper.ExecuteImpl(this.FlushInternal);
+        }
+
+        /// <summary>
+        /// Aborts the upload of the blob. 
+        /// </summary>
+        public override void Abort()
+        {
+            this.blockList = null;
+            this.blobHash = null;
+            this.canWrite = false;
+            this.ResetBlock();
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to commit the blob.
+        /// </summary>
+        /// <param name="callback">An optional asynchronous callback, to be called when the commit is complete.</param>
+        /// <param name="state">A user-provided object that distinguishes this particular asynchronous commit request from other requests.</param>
+        /// <returns>An IAsyncResult that represents the asynchronous commit, which could still be pending.</returns>
+        public override IAsyncResult BeginCommit(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImpl(this.CommitImpl, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to commit the blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <exception cref="ArgumentNullException">asyncResult is null</exception>
+        public override void EndCommit(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Commits the blob on the server.
+        /// </summary>
+        public override void Commit()
+        {
+            TaskImplHelper.ExecuteImpl(this.CommitImpl);
+        }
+
+        /// <summary>
+        /// Implements the disposing logic of committing the blob.
+        /// </summary>
+        /// <param name="disposing">True to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing && this.CanWrite)
+            {
+                this.Commit();
+                this.ResetBlock();
+                this.canWrite = false;
+            }
+
+            base.Dispose(disposing);
+        }
+
+        /// <summary>
+        /// Generates a blockID using the block's hash and a prefix.
+        /// </summary>
+        /// <returns>The base64 encoded blockID.</returns>
+        private string GetBlockID()
+        {
+            this.blockIdSequenceNumber += 1;
+            return Utilities.GenerateBlockIDWithHash(StreamUtilities.GetHashValue(this.blockHash), this.blockIdSequenceNumber);
+        }
+
+        /// <summary>
+        /// Implements the block writing task.
+        /// </summary>
+        /// <param name="buffer">The buffer to write data from.</param>
+        /// <param name="offset">The byte offset in buffer from which to begin writing.</param>
+        /// <param name="count">The  number of bytes to write.</param>
+        /// <returns>The sequence representing the uploading of the blocks.</returns>
+        private TaskSequence WriteBlockBlobImpl(byte[] buffer, int offset, int count)
+        {
+            if (this.blockList.Count + (count / this.blockSize) > Constants.MaxBlockNumber)
+            {
+                throw new ArgumentOutOfRangeException("count", String.Format(CultureInfo.CurrentCulture, SR.TooManyBlocksError, Constants.MaxBlockNumber));
+            }
+
+            while (count != 0)
+            {
+                // Create a buffer if we don't have one
+                if (this.blockBuffer == null)
+                {
+                    this.CreateNewBlock();
+                }
+
+                // Copy enough data to fill the buffer.
+                int numCopied = (int)Math.Min(count, this.blockSize - this.blockBuffer.Length);
+                this.blockBuffer.Write(buffer, offset, numCopied);
+
+                StreamUtilities.ComputeHash(buffer, offset, numCopied, this.blockHash);
+                StreamUtilities.ComputeHash(buffer, offset, numCopied, this.blobHash);
+
+                // Advance the location
+                this.position += numCopied;
+                offset += numCopied;
+                count -= numCopied;
+
+                // If buffer is full, flush
+                if (this.blockBuffer.Length == this.blockSize)
+                {
+                    var newTask = new InvokeTaskSequenceTask(this.FlushInternal);
+                    yield return newTask;
+
+                    // Make sure task completed successfully by materializing the exception
+                    var result = newTask.Result;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a task that writes data for a full blob.
+        /// </summary>
+        /// <param name="buffer">The buffer to write data from.</param>
+        /// <param name="offset">The byte offset in buffer from which to begin writing.</param>
+        /// <param name="count">The  number of bytes to write.</param>
+        /// <returns>The (synchronous) sequence that copies the data into a buffer.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown if the buffer is larger than maximum blob size.</exception>
+        /// <remarks>Since a non-block based blob is always fully buffered before upload, this task is a synchronous copy.</remarks>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Usage",
+            "CA2208:InstantiateArgumentExceptionsCorrectly",
+            Justification = "Param name is count")]
+        private SynchronousTask WriteNonBlockedBlobImpl(byte[] buffer, int offset, int count)
+        {
+            return new SynchronousTask(() =>
+            {
+                if (this.blockBuffer == null)
+                {
+                    this.CreateNewBlock();
+                }
+
+                // Verify we don't go beyond single-upload size
+                if (this.Length + count > Protocol.Constants.MaxSingleUploadBlobSize)
+                {
+                    throw new ArgumentOutOfRangeException("count", String.Format(CultureInfo.CurrentCulture, SR.BlobTooLargeError, Protocol.Constants.MaxSingleUploadBlobSize));
+                }
+
+                this.blockBuffer.Write(buffer, offset, count);
+                this.position += count;
+                StreamUtilities.ComputeHash(buffer, offset, count, this.blockHash);
+                StreamUtilities.ComputeHash(buffer, offset, count, this.blobHash); // Update both, in case someone changes their mind mid-stream
+            });
+        }
+
+        /// <summary>
+        /// Implements the flushing sequence.
+        /// </summary>
+        /// <returns>The sequence of events for a flush.</returns>
+        private TaskSequence FlushInternal()
+        {
+            // If there's nothing to flush, just return;
+            if (this.blockBuffer == null)
+            {
+                yield break;
+            }
+
+            // Rewind the stream before upload
+            this.blockBuffer.Position = 0;
+
+            InvokeTaskSequenceTask newTask;
+
+            if (this.UseBlocks)
+            {
+                newTask = new InvokeTaskSequenceTask(this.UploadBlock);
+            }
+            else
+            {
+                newTask = new InvokeTaskSequenceTask(this.UploadBlob);
+            }
+
+            yield return newTask;
+            var result = newTask.Result; // Materialize the results to ensure exception propagation
+        }
+
+        /// <summary>
+        /// Commits the blob by uploading any remaining data and the blocklist asynchronously. 
+        /// </summary>
+        /// <returns>A sequence of events required for commit.</returns>
+        private TaskSequence CommitImpl()
+        {
+            this.CheckWriteState();
+
+            if (this.blockBuffer != null && this.blockBuffer.Length != 0)
+            {
+                var task = new InvokeTaskSequenceTask(this.FlushInternal);
+                yield return task;
+                var result = task.Result; // Materialize the errors
+            }
+
+            // If all blocks are uploaded, commit 
+            if (this.UseBlocks)
+            {
+                this.SetBlobMD5();
+
+                var task = TaskImplHelper.GetRetryableAsyncTask(
+                   () =>
+                   {
+                       // At the convenience layer we always upload uncommitted blocks
+                       List<PutBlockListItem> putBlockList = new List<PutBlockListItem>();
+                       foreach (var id in this.blockList)
+                       {
+                           putBlockList.Add(new PutBlockListItem(id, BlockSearchMode.Uncommitted));
+                       }
+
+                       return this.Blob.ToBlockBlob.UploadBlockList(putBlockList, this.currentModifier);
+                   },
+                   this.currentModifier.RetryPolicy);
+                yield return task;
+                var result = task.Result;
+            }
+
+            // Now we can set the full size.
+            this.Blob.Properties.Length = this.Length;
+
+            // Clear the internal state
+            this.Abort();
+        }
+
+        /// <summary>
+        /// Implements a sequence of events to upload a full blob.
+        /// </summary>
+        /// <returns>The sequence of events required to upload the blob.</returns>
+        private TaskSequence UploadBlob()
+        {
+            this.SetBlobMD5();
+
+            var task = this.Blob.ToBlockBlob.UploadFullBlobWithRetryImpl(this.blockBuffer, this.currentModifier);
+            yield return task;
+            var result = task.Result;
+
+            // Reset all of the state
+            this.Abort();
+        }
+
+        /// <summary>
+        /// Sets the MD5 of the blob.
+        /// </summary>
+        private void SetBlobMD5()
+        {
+            var hashValue = StreamUtilities.GetHashValue(this.blobHash);
+
+            this.Blob.Properties.ContentMD5 = hashValue;
+        }
+
+        /// <summary>
+        /// Implements a sequence to upload a block.
+        /// </summary>
+        /// <returns>The sequence of events for upload.</returns>
+        private TaskSequence UploadBlock()
+        {
+            // Calculate the MD5 of the buffer
+            var blockID = this.GetBlockID();
+
+            // Upload the current data as block         
+            string hash = Utilities.ExtractMD5ValueFromBlockID(blockID);
+            var task = this.Blob.ToBlockBlob.UploadBlockWithRetry(this.blockBuffer, blockID, hash, this.currentModifier);
+            yield return task;
+            var result = task.Result;
+
+            // Add the block to the list of blocks.
+            this.blockList.Add(blockID);
+            this.ResetBlock();
+        }
+
+        /// <summary>
+        /// Verifies that the blob is in writable state.
+        /// </summary>
+        /// <exception cref="ObjectDisposedException">Thrown if stream is non-writable.</exception>
+        private void CheckWriteState()
+        {
+            if (!this.CanWrite)
+            {
+                throw new ObjectDisposedException("BlobWriteStream", "Blob is in non-writable state");
+            }
+        }
+
+        /// <summary>
+        /// Resets the block and the block hash.
+        /// </summary>
+        private void ResetBlock()
+        {
+            if (this.blockBuffer != null)
+            {
+                this.blockBuffer.Dispose();
+            }
+
+            this.blockBuffer = null;
+            this.blockHash = null;
+        }
+
+        /// <summary>
+        /// Creates the new block and the block hash.
+        /// </summary>
+        private void CreateNewBlock()
+        {
+            this.blockBuffer = new SmallBlockMemoryStream(Constants.DefaultBufferSize);
+            this.blockHash = MD5.Create();
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/BlockListingFilter.cs b/microsoft-azure-api/StorageClient/BlockListingFilter.cs
new file mode 100644
index 0000000000000..5141e8b27180f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/BlockListingFilter.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlockListingFilter.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlockListingFilter enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Indicates whether to list only committed blocks, only uncommitted blocks, or all blocks.
+    /// </summary>
+    public enum BlockListingFilter
+    {
+        /// <summary>
+        /// Committed blocks.
+        /// </summary>
+        Committed,
+
+        /// <summary>
+        /// Uncommitted blocks.
+        /// </summary>
+        Uncommitted,
+
+        /// <summary>
+        /// Both committed and uncommitted blocks.
+        /// </summary>
+        All
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/CloudBlob.cs b/microsoft-azure-api/StorageClient/CloudBlob.cs
new file mode 100644
index 0000000000000..80fbcd4bf9ab9
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudBlob.cs
@@ -0,0 +1,2072 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudBlob.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudBlob class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a Windows Azure blob.
+    /// </summary>
+    public class CloudBlob : IListBlobItem
+    {
+        /// <summary>
+        /// Stores the blob's attributes.
+        /// </summary>
+        private readonly BlobAttributes attributes;
+
+        /// <summary>
+        /// Stores the <see cref="CloudBlobContainer"/> that contains this blob.
+        /// </summary>
+        private CloudBlobContainer container;
+
+        /// <summary>
+        /// Stores the name of this blob.
+        /// </summary>
+        private string name;
+
+        /// <summary>
+        /// Stores the blob's parent <see cref="CloudBlobDirectory"/>.
+        /// </summary>
+        private CloudBlobDirectory parent;
+
+        /// <summary>
+        /// Stores the blob's transformed address.
+        /// </summary>
+        private Uri transformedAddress;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class using an absolute URI to the blob.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">The absolute URI to the blob.</param>
+        public CloudBlob(string blobAbsoluteUri)
+            : this(null, blobAbsoluteUri)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class using an absolute URI to the blob
+        /// and a set of credentials.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">The absolute URI to the blob.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudBlob(string blobAbsoluteUri, StorageCredentials credentials)
+            : this(blobAbsoluteUri, new CloudBlobClient(NavigationHelper.GetServiceClientBaseAddress(blobAbsoluteUri, null), credentials))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class using an absolute URI to the blob, and the snapshot timestamp,
+        /// if the blob is a snapshot.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">The absolute URI to the blob.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudBlob(string blobAbsoluteUri, DateTime? snapshotTime, StorageCredentials credentials)
+            : this(blobAbsoluteUri, snapshotTime, new CloudBlobClient(NavigationHelper.GetServiceClientBaseAddress(blobAbsoluteUri, null), credentials))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class using a relative URI to the blob, and the snapshot timestamp,
+        /// if the blob is a snapshot.
+        /// </summary>
+        /// <param name="blobUri">The relative URI to the blob, beginning with the container name.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="serviceClient">A client object that specifies the endpoint for the Blob service.</param>
+        public CloudBlob(string blobUri, DateTime? snapshotTime, CloudBlobClient serviceClient)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAbsoluteUri", blobUri);
+            CommonUtils.AssertNotNull("serviceClient", serviceClient);
+
+            this.attributes = new BlobAttributes();
+            this.ServiceClient = serviceClient;
+
+            var completeUri = NavigationHelper.AppendPathToUri(this.ServiceClient.BaseUri, blobUri);
+
+            this.ParseQueryAndVerify(completeUri, this.ServiceClient, this.ServiceClient.UsePathStyleUris);
+            
+            if (snapshotTime != null)
+            {
+                if (this.SnapshotTime != null)
+                {
+                    throw new ArgumentException(SR.SnapshotTimePassedTwice);
+                }
+                else
+                {
+                    this.SnapshotTime = snapshotTime;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class using a relative URI to the blob.
+        /// </summary>
+        /// <param name="blobUri">The relative URI to the blob, beginning with the container name.</param>
+        /// <param name="serviceClient">A client object that specifies the endpoint for the Blob service.</param>
+        public CloudBlob(string blobUri, CloudBlobClient serviceClient)
+            : this(blobUri, null, serviceClient)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class based on an existing instance.
+        /// </summary>
+        /// <param name="cloudBlob">An existing reference to a blob.</param>
+        public CloudBlob(CloudBlob cloudBlob)
+        {
+            this.attributes = cloudBlob.Attributes;
+            this.container = cloudBlob.container;
+            this.parent = cloudBlob.parent;
+
+            this.ServiceClient = cloudBlob.ServiceClient;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">Absolute Uri.</param>
+        /// <param name="usePathStyleUris">True to use path style Uri.</param>
+        /// <remarks>
+        /// Any authentication information inside the address will be used.
+        /// Otherwise a blob for anonymous access is created.
+        /// Any snapshot information as part of the address will be recorded
+        /// Explicity specify whether to use host style or path style Uri
+        /// </remarks>
+        internal CloudBlob(string blobAbsoluteUri, bool usePathStyleUris)
+            : this(usePathStyleUris, blobAbsoluteUri)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class creating a new service client.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">Complete Uri.</param>
+        /// <param name="credentials">Storage credentials.</param>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        internal CloudBlob(string blobAbsoluteUri, StorageCredentials credentials, bool usePathStyleUris)
+            : this(blobAbsoluteUri, new CloudBlobClient(NavigationHelper.GetServiceClientBaseAddress(blobAbsoluteUri, usePathStyleUris), credentials))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class with the given absolute Uri.
+        /// </summary>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <param name="blobAbsoluteUri">The absolute blob Uri.</param>
+        internal CloudBlob(bool? usePathStyleUris, string blobAbsoluteUri)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAbsoluteUriString", blobAbsoluteUri);
+
+            this.attributes = new BlobAttributes();
+
+            var completeUri = new Uri(blobAbsoluteUri);
+
+            this.ParseQueryAndVerify(completeUri, null, usePathStyleUris);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class with existing attributes.
+        /// </summary>
+        /// <param name="attributes">The attributes (NOTE: Saved by reference, does not make a copy).</param>
+        /// <param name="serviceClient">The service client.</param>
+        /// <param name="snapshotTime">The snapshot time.</param>
+        internal CloudBlob(BlobAttributes attributes, CloudBlobClient serviceClient, string snapshotTime)
+        {
+            this.attributes = attributes;
+            this.ServiceClient = serviceClient;
+
+            this.ParseQueryAndVerify(attributes.Uri, this.ServiceClient, this.ServiceClient.UsePathStyleUris);
+
+            if (!string.IsNullOrEmpty(snapshotTime))
+            {
+                this.SnapshotTime = this.ParseSnapshotTime(snapshotTime);
+            }
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class using the specified blob Uri.
+        /// Note that this is just a reference to a blob instance and no requests are issued to the service
+        /// yet to update the blob properties, attribute or metaddata. FetchAttributes is the API that 
+        /// issues such request to the service.
+        /// </summary>
+        /// <param name="blobUri">A relative Uri to the blob.</param>
+        /// <param name="serviceClient">A <see cref="CloudBlobClient"/> object that specifies the endpoint for the Blob service.</param>
+        /// <param name="containerReference">The reference to the parent container.</param>
+        internal CloudBlob(string blobUri, CloudBlobClient serviceClient, CloudBlobContainer containerReference)
+            : this(blobUri, null, serviceClient)
+        {
+            this.container = containerReference;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlob"/> class using the specified relative blob Uri.
+        /// If snapshotTime is not null, the blob instance represents a Snapshot.
+        /// Note that this is just a reference to a blob instance and no requests are issued to the service
+        /// yet to update the blob properties, attribute or metaddata. FetchAttributes is the API that 
+        /// issues such request to the service.
+        /// </summary>
+        /// <param name="blobUri">A relative Uri to the blob.</param>
+        /// <param name="snapshotTime">Snapshot time in case the blob is a snapshot.</param>
+        /// <param name="serviceClient">A <see cref="CloudBlobClient"/> object that specifies the endpoint for the Blob service.</param>
+        /// <param name="containerReference">The reference to the parent container.</param>
+        internal CloudBlob(string blobUri, DateTime? snapshotTime, CloudBlobClient serviceClient, CloudBlobContainer containerReference)
+            : this(blobUri, snapshotTime, serviceClient)
+        {
+            this.container = containerReference;
+        }
+
+        /// <summary>
+        /// Gets the <see cref="DateTime"/> value that uniquely identifies the snapshot, if this blob is a snapshot.
+        /// </summary>
+        /// <value>A value that uniquely identfies the snapshot.</value>
+        /// <remarks>
+        /// If the blob is not a snapshot, this property returns <c>null</c>.
+        /// </remarks>
+        public DateTime? SnapshotTime
+        {
+            get { return this.attributes.Snapshot; }
+            internal set { this.attributes.Snapshot = value; }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="CloudBlobClient"/> object that represents the Blob service.
+        /// </summary>
+        /// <value>A client object that specifies the Blob service endpoint.</value>
+        public CloudBlobClient ServiceClient { get; private set; }
+
+        /// <summary>
+        /// Gets the URI that identifies the blob.
+        /// </summary>
+        /// <value>The address of the blob.</value>
+        public Uri Uri
+        {
+            get
+            {
+                return this.attributes.Uri;
+            }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="BlobAttributes"/> object that represents the blob's attributes.
+        /// </summary>
+        /// <value>The blob's attributes.</value>
+        public BlobAttributes Attributes
+        {
+            get { return this.attributes; }
+        }
+
+        /// <summary>
+        /// Gets the blob's user-defined metadata.
+        /// </summary>
+        /// <value>The blob's metadata.</value>
+        public NameValueCollection Metadata
+        {
+            get
+            {
+                return this.attributes.Metadata;
+            }
+
+            internal set
+            {
+                this.attributes.Metadata = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the blob's system properties.
+        /// </summary>
+        /// <value>The blob's system properties.</value>
+        public BlobProperties Properties
+        {
+            get
+            {
+                return this.attributes.Properties;
+            }
+
+            internal set
+            {
+                this.attributes.Properties = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the blob's name.
+        /// </summary>
+        /// <value>The blob's name.</value>
+        public string Name
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(this.name))
+                {
+                    this.name = Uri.UnescapeDataString(NavigationHelper.GetBlobName(this.Uri, this.ServiceClient.UsePathStyleUris));
+                }
+
+                return this.name;
+            }
+        }
+
+        /// <summary>
+        /// Gets a <see cref="CloudBlobContainer"/> object representing the blob's container.
+        /// </summary>
+        /// <value>The blob's container.</value>
+        public CloudBlobContainer Container
+        {
+            get
+            {
+                if (this.container == null)
+                {
+                    this.container = new CloudBlobContainer(
+                        NavigationHelper.GetContainerAddress(this.Uri, this.ServiceClient.UsePathStyleUris),
+                        this.ServiceClient.Credentials);
+                }
+
+                return this.container;
+            }
+        }
+
+        /// <summary>
+        /// Gets the <see cref="CloudBlobDirectory"/> object representing the
+        /// virtual parent directory for the blob.
+        /// </summary>
+        /// <value>The blob's virtual parent directory.</value>
+        public CloudBlobDirectory Parent
+        {
+            get
+            {
+                if (this.parent == null)
+                {
+                    this.parent = new CloudBlobDirectory(
+                        NavigationHelper.GetParentAddress(
+                            this.Uri,
+                            this.ServiceClient.DefaultDelimiter,
+                            this.ServiceClient.UsePathStyleUris),
+                        this.ServiceClient);
+                }
+
+                return this.parent;
+            }
+        }
+
+        /// <summary>
+        /// Gets a <see cref="CloudPageBlob"/> object based on this blob.
+        /// </summary>
+        /// <value>A reference to a page blob.</value>
+        public CloudPageBlob ToPageBlob
+        {
+            get
+            {
+                var pageBlob = this as CloudPageBlob;
+
+                if (pageBlob != null)
+                {
+                    return pageBlob;
+                }
+
+                return new CloudPageBlob(this);
+            }
+        }
+
+        /// <summary>
+        /// Gets a <see cref="CloudBlockBlob"/> object based on this blob.
+        /// </summary>
+        /// <value>A reference to a block blob.</value>
+        public CloudBlockBlob ToBlockBlob
+        {
+            get
+            {
+                var blockBlob = this as CloudBlockBlob;
+
+                if (blockBlob != null)
+                {
+                    return blockBlob;
+                }
+
+                return new CloudBlockBlob(this);
+            }
+        }
+
+        /// <summary>
+        /// Gets the Uri after applying authentication transformation.
+        /// </summary>
+        /// <value>The transformed address.</value>
+        internal Uri TransformedAddress
+        {
+            get
+            {
+                if (this.ServiceClient.Credentials.NeedsTransformUri)
+                {
+                    // This is required to support key rotation
+                    // Potential Improvement: Could get the latest credentials and compare against a cached
+                    this.transformedAddress = new Uri(this.ServiceClient.Credentials.TransformUri(this.Uri.AbsoluteUri));
+
+                    return this.transformedAddress;
+                }
+                else
+                {
+                    return this.Uri;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Populates a blob's properties and metadata.
+        /// </summary>
+        public void FetchAttributes()
+        {
+            this.FetchAttributes(null);
+        }
+
+        /// <summary>
+        /// Populates a blob's properties and metadata.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void FetchAttributes(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.FetchAttributesImpl(fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to populate the blob's properties and metadata.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginFetchAttributes(AsyncCallback callback, object state)
+        {
+            return this.BeginFetchAttributes(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to populate the blob's properties and metadata.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginFetchAttributes(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.FetchAttributesImpl(fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to populate the blob's properties and metadata.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public void EndFetchAttributes(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Updates the blob's metadata.
+        /// </summary>
+        public void SetMetadata()
+        {
+            this.SetMetadata(null);
+        }
+
+        /// <summary>
+        /// Updates the blob's metadata.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void SetMetadata(BlobRequestOptions options)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.SetMetadataImpl(fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to update the blob's metadata.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetMetadata(AsyncCallback callback, object state)
+        {
+            return this.BeginSetMetadata(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to update the blob's metadata.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetMetadata(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.SetMetadataImpl(fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to update the blob's metadata.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public void EndSetMetadata(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Updates the blob's properties.
+        /// </summary>
+        public void SetProperties()
+        {
+            this.SetProperties(null);
+        }
+
+        /// <summary>
+        /// Updates the blob's properties.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void SetProperties(BlobRequestOptions options)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.SetPropertiesImpl(fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to update the blob's properties.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetProperties(AsyncCallback callback, object state)
+        {
+            return this.BeginSetProperties(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to update the blob's properties.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetProperties(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.SetPropertiesImpl(fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to update the blob's properties.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public void EndSetProperties(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Copies an existing blob's contents, properties, and metadata to a new blob.
+        /// </summary>
+        /// <param name="source">The source blob.</param>
+        public void CopyFromBlob(CloudBlob source)
+        {
+            this.CopyFromBlob(source, null);
+        }
+
+        /// <summary>
+        /// Copies a blob's contents, properties, and metadata to a new blob.
+        /// </summary>
+        /// <param name="source">The source blob.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void CopyFromBlob(CloudBlob source, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.CopyFromBlobImpl(source, fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to copy a blob's contents, properties, and metadata to a new blob.
+        /// </summary>
+        /// <param name="source">The source blob.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCopyFromBlob(CloudBlob source, AsyncCallback callback, object state)
+        {
+            return this.BeginCopyFromBlob(source, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to copy another blob's contents, properties, and metadata to the blob referenced by this <see cref="CloudBlob"/> object.
+        /// </summary>
+        /// <param name="source">The source blob.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCopyFromBlob(CloudBlob source, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(
+                () => this.CopyFromBlobImpl(source, fullModifiers),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to copy a blob's contents, properties, and metadata to a new blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public void EndCopyFromBlob(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Deletes the blob.
+        /// </summary>
+        public void Delete()
+        {
+            this.Delete(null);
+        }
+
+        /// <summary>
+        /// Deletes the blob.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void Delete(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.DeleteBlobImpl(fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete the blob.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDelete(AsyncCallback callback, object state)
+        {
+            return this.BeginDelete(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete the blob.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDelete(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.DeleteBlobImpl(fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to delete the blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public void EndDelete(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Deletes the blob if it exists.
+        /// </summary>
+        /// <returns><c>true</c> if the blob was deleted; otherwise, <c>false</c>.</returns>
+        public bool DeleteIfExists()
+        {
+            return this.DeleteIfExists(null);
+        }
+
+        /// <summary>
+        /// Deletes the blob if it exists.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns><c>true</c> if the blob was deleted; otherwise, <c>false</c>.</returns>
+        public bool DeleteIfExists(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<bool>((setResult) => this.DeleteBlobIfExistsImpl(fullModifiers, setResult), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete the blob if it exists.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDeleteIfExists(AsyncCallback callback, object state)
+        {
+            return this.BeginDeleteIfExists(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete the blob if it exists.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDeleteIfExists(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<bool>((setResult) => this.DeleteBlobIfExistsImpl(fullModifiers, setResult), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to delete the blob if it exists.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns><c>true</c> if the blob was successfully deleted; otherwise, <c>false</c>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public bool EndDeleteIfExists(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<bool>(asyncResult);
+        }
+
+        /// <summary>
+        /// Opens a stream for writing to the blob.
+        /// </summary>
+        /// <returns>A stream to be used for writing to the blob.</returns>
+        public virtual BlobStream OpenWrite()
+        {
+            return this.OpenWrite(null);
+        }
+
+        /// <summary>
+        /// Opens a stream for writing to the blob.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A stream to be used for writing to the blob.</returns>
+        public virtual BlobStream OpenWrite(BlobRequestOptions options)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return new BlobWriteStream(this.ToBlockBlob, fullModifier, this.ServiceClient.WriteBlockSizeInBytes);
+        }
+
+        /// <summary>
+        /// Uploads a stream to a block blob. 
+        /// </summary>
+        /// <param name="source">The stream providing the blob content.</param>
+        public virtual void UploadFromStream(Stream source)
+        {
+            this.UploadFromStream(source, null);
+        }
+
+        /// <summary>
+        /// Uploads a stream to a block blob. 
+        /// </summary>
+        /// <param name="source">The stream providing the blob content.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public virtual void UploadFromStream(Stream source, BlobRequestOptions options)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImpl(() => { return UploadFromStreamDispatch(source, fullModifier); });
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to upload a stream to a block blob.
+        /// </summary>
+        /// <param name="source">The stream providing the blob content.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public virtual IAsyncResult BeginUploadFromStream(Stream source, AsyncCallback callback, object state)
+        {
+            return this.BeginUploadFromStream(source, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to upload a stream to a block blob. 
+        /// </summary>
+        /// <param name="source">The stream providing the blob content.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public virtual IAsyncResult BeginUploadFromStream(Stream source, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImpl(() => { return this.UploadFromStreamDispatch(source, fullModifier); }, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to upload a stream to a block blob. 
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        public virtual void EndUploadFromStream(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Uploads a string of text to a block blob. 
+        /// </summary>
+        /// <param name="content">The text to upload, encoded as a UTF-8 string.</param>
+        public virtual void UploadText(string content)
+        {
+            this.UploadText(content, Encoding.UTF8, null);
+        }
+
+        /// <summary>
+        /// Uploads a string of text to a block blob. 
+        /// </summary>
+        /// <param name="content">The text to upload.</param>
+        /// <param name="encoding">An object that indicates the text encoding to use.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public virtual void UploadText(string content, Encoding encoding, BlobRequestOptions options)
+        {
+            this.UploadByteArray(encoding.GetBytes(content), options);
+        }
+
+        /// <summary>
+        /// Uploads a file from the file system to a block blob.
+        /// </summary>
+        /// <param name="fileName">The path and file name of the file to upload.</param>
+        public virtual void UploadFile(string fileName)
+        {
+            this.UploadFile(fileName, null);
+        }
+
+        /// <summary>
+        /// Uploads a file from the file system to a block blob.
+        /// </summary>
+        /// <param name="fileName">The path and file name of the file to upload.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public virtual void UploadFile(string fileName, BlobRequestOptions options)
+        {
+            using (var data = File.OpenRead(fileName))
+            {
+                this.UploadFromStream(data, options);
+            }
+        }
+
+        /// <summary>
+        /// Uploads an array of bytes to a block blob.
+        /// </summary>
+        /// <param name="content">The array of bytes to upload.</param>
+        public virtual void UploadByteArray(byte[] content)
+        {
+            this.UploadByteArray(content, null);
+        }
+
+        /// <summary>
+        /// Uploads an array of bytes to a blob.
+        /// </summary>
+        /// <param name="content">The array of bytes to upload.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public virtual void UploadByteArray(byte[] content, BlobRequestOptions options)
+        {
+            using (var data = new MemoryStream(content))
+            {
+                this.UploadFromStream(data, options);
+            }
+        }
+
+        /// <summary>
+        /// Opens a stream for reading the blob's contents.
+        /// </summary>
+        /// <returns>A stream to use for reading from the blob.</returns>
+        public BlobStream OpenRead()
+        {
+            return this.OpenRead(null);
+        }
+
+        /// <summary>
+        /// Opens a stream for reading the blob's contents.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A stream to use for reading from the blob.</returns>
+        public BlobStream OpenRead(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+            return new BlobReadStream(this, fullModifiers, this.ServiceClient.ReadAheadInBytes, this.ServiceClient.UseIntegrityControlForStreamReading);
+        }
+
+        /// <summary>
+        /// Downloads the contents of a blob to a stream.
+        /// </summary>
+        /// <param name="target">The target stream.</param>
+        public void DownloadToStream(Stream target)
+        {
+            this.DownloadToStream(target, null);
+        }
+
+        /// <summary>
+        /// Downloads the contents of a blob to a stream.
+        /// </summary>
+        /// <param name="target">The target stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void DownloadToStream(Stream target, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+            TaskImplHelper.ExecuteSyncTaskWithRetry(this.DownloadToStreamSyncImpl(target, fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to download the contents of a blob to a stream.
+        /// </summary>
+        /// <param name="target">The target stream.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDownloadToStream(Stream target, AsyncCallback callback, object state)
+        {
+            return this.BeginDownloadToStream(target, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to download the contents of a blob to a stream.
+        /// </summary>
+        /// <param name="target">The target stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDownloadToStream(Stream target, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+            return TaskImplHelper.BeginImplWithRetry(() => this.DownloadToStreamImpl(target, fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to download the contents of a blob to a stream.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public void EndDownloadToStream(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Downloads the blob's contents.
+        /// </summary>
+        /// <returns>The contents of the blob, as a string.</returns>
+        public string DownloadText()
+        {
+            return this.DownloadText(null);
+        }
+
+        /// <summary>
+        /// Downloads the blob's contents.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>The contents of the blob, as a string.</returns>
+        public string DownloadText(BlobRequestOptions options)
+        {
+            Encoding encoding = GetDefaultEncoding();
+
+            byte[] array = this.DownloadByteArray(options);
+
+            return encoding.GetString(array);
+        }
+
+        /// <summary>
+        /// Downloads the blob's contents to a file.
+        /// </summary>
+        /// <param name="fileName">The path and file name of the target file.</param>
+        public void DownloadToFile(string fileName)
+        {
+            this.DownloadToFile(fileName, null);
+        }
+
+        /// <summary>
+        /// Downloads the blob's contents to a file.
+        /// </summary>
+        /// <param name="fileName">The path and file name of the target file.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void DownloadToFile(string fileName, BlobRequestOptions options)
+        {
+            using (var fileStream = File.Create(fileName))
+            {
+                this.DownloadToStream(fileStream, options);
+            }
+        }
+
+        /// <summary>
+        /// Downloads the blob's contents as an array of bytes.
+        /// </summary>
+        /// <returns>The contents of the blob, as an array of bytes.</returns>
+        public byte[] DownloadByteArray()
+        {
+            return this.DownloadByteArray(null);
+        }
+
+        /// <summary>
+        /// Downloads the blob's contents as an array of bytes. 
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>The contents of the blob, as an array of bytes.</returns>
+        public byte[] DownloadByteArray(BlobRequestOptions options)
+        {
+            using (var memoryStream = new MemoryStream())
+            {
+                this.DownloadToStream(memoryStream, options);
+
+                return memoryStream.ToArray();
+            }
+        }
+
+        /// <summary>
+        /// Creates a snapshot of the blob.
+        /// </summary>
+        /// <returns>A blob snapshot.</returns>
+        public CloudBlob CreateSnapshot()
+        {
+            return this.CreateSnapshot(null, null);
+        }
+
+        /// <summary>
+        /// Creates a snapshot of the blob.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A blob snapshot.</returns>
+        public CloudBlob CreateSnapshot(BlobRequestOptions options)
+        {
+            return this.CreateSnapshot(null, options);
+        }
+
+        /// <summary>
+        /// Creates a snapshot of the blob.
+        /// </summary>
+        /// <param name="metadata">A collection of name-value pairs defining the metadata of the snapshot.</param>
+        /// <param name="options">An object that specifies any additional options for the request, or <c>null</c>.</param>
+        /// <returns>A blob snapshot.</returns>
+        public CloudBlob CreateSnapshot(NameValueCollection metadata, BlobRequestOptions options)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            BlobRequestOptions fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<CloudBlob>(
+                (setResult) => this.CreateSnapshotImpl(metadata, fullModifiers, setResult),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a snapshot of the blob.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateSnapshot(AsyncCallback callback, object state)
+        {
+            return this.BeginCreateSnapshot(null, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a snapshot of the blob.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateSnapshot(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            return this.BeginCreateSnapshot(null, options, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a snapshot of the blob.
+        /// </summary>
+        /// <param name="metadata">A collection of name-value pairs defining the metadata of the snapshot.</param>
+        /// <param name="options">An object that specifies any additional options for the request, or <c>null</c>.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateSnapshot(NameValueCollection metadata, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            this.VerifyNoWriteOperationForSnapshot();
+
+            BlobRequestOptions fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<CloudBlob>(
+                (setResult) => this.CreateSnapshotImpl(metadata, fullModifiers, setResult),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to create a snapshot of the blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A blob snapshot.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public CloudBlob EndCreateSnapshot(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<CloudBlob>(asyncResult);
+        }
+
+        /// <summary>
+        /// Returns a shared access signature for the blob.
+        /// </summary>
+        /// <param name="policy">The access policy for the shared access signature.</param>
+        /// <returns>A shared access signature.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the current credentials don't support creating a shared access signature.</exception>
+        /// <exception cref="NotSupportedException">Thrown if blob is a snapshot.</exception>
+        public string GetSharedAccessSignature(SharedAccessPolicy policy)
+        {
+            return this.GetSharedAccessSignature(policy, null);
+        }
+
+        /// <summary>
+        /// Returns a shared access signature for the blob.
+        /// </summary>
+        /// <param name="policy">The access policy for the shared access signature.</param>
+        /// <param name="groupPolicyIdentifier">A container-level access policy.</param>
+        /// <returns>A shared access signature.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if the current credentials don't support creating a shared access signature.</exception>
+        /// <exception cref="NotSupportedException">Thrown if blob is a snapshot.</exception>
+        public string GetSharedAccessSignature(SharedAccessPolicy policy, string groupPolicyIdentifier)
+        {
+            if (!this.ServiceClient.Credentials.CanSignRequest)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
+                throw new InvalidOperationException(errorMessage);
+            }
+
+            if (this.SnapshotTime != null)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASForSnapshot);
+                throw new NotSupportedException(errorMessage);
+            }
+
+            string resourceName = this.GetCanonicalName(true);
+
+            string signature = SharedAccessSignatureHelper.GetSharedAccessSignatureHashImpl(policy, groupPolicyIdentifier, resourceName, this.ServiceClient);
+
+            // Future resource type changes from "b" => "blob"
+            var builder = SharedAccessSignatureHelper.GetShareAccessSignatureImpl(policy, groupPolicyIdentifier, "b", signature);
+
+            return builder.ToString();
+        }
+
+        /// <summary>
+        /// Dispatches the stream upload to a specific implementation method.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the stream.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "Stream provides no way to determine if Length is accessible so we must catch all exceptions.")]
+        internal TaskSequence UploadFromStreamDispatch(Stream source, BlobRequestOptions options)
+        {
+            options = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+            var blockSize = this.ServiceClient.WriteBlockSizeInBytes;
+            long streamLength = -1;
+
+            // If the stream is unseekable, buffer it for retries
+            if (!source.CanSeek)
+            {
+                if (this.ServiceClient.ParallelOperationThreadCount == 1)
+                {
+                    return this.UploadBlobWithBuffering(source, options, blockSize);
+                }
+                else
+                {
+                    return this.ParallelUploadBlobWithBlocks(source, blockSize, options);
+                }
+            }
+
+            // Check if the source stream has length. If length is unavailable, buffer it up for sending.
+            // Otherwise set streamLength as delta between lenght and position
+            try
+            {
+                streamLength = source.Length - source.Position;
+            }
+            catch (System.Exception)
+            {
+                if (this.ServiceClient.ParallelOperationThreadCount == 1)
+                {
+                    return this.UploadUnknownSizeStream(source, options, blockSize);
+                }
+                else
+                {
+                    return this.ParallelUploadBlobWithBlocks(source, blockSize, options);
+                }
+            }
+
+            // If the blob is below the upload threshold, upload it as single version
+            if (streamLength < this.ServiceClient.SingleBlobUploadThresholdInBytes)
+            {
+                return this.UploadFullBlobWithRetrySequenceImpl(source, options);
+            }
+
+            if (this.ServiceClient.ParallelOperationThreadCount == 1)
+            {
+                return this.UploadBlobWithBlocks(source, options, blockSize);
+            }
+            else
+            {
+                return this.ParallelUploadBlobWithBlocks(source, blockSize, options);
+            }
+        }
+
+        /// <summary>
+        /// Uploads the blob with buffering.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="blockSize">The size of the block.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the blob.</returns>
+        internal TaskSequence UploadBlobWithBuffering(Stream source, BlobRequestOptions options, long blockSize)
+        {
+            CommonUtils.AssertNotNull("modifers", options);
+
+            var target = this.OpenWrite(options);
+
+            target.BlockSize = blockSize;
+            return source.WriteToAndCloseOutput(target);
+        }
+
+        /// <summary>
+        /// Uploads the full blob with retry.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the blob.</returns>
+        internal Task<NullTaskReturn> UploadFullBlobWithRetryImpl(Stream source, BlobRequestOptions options)
+        {
+            var position = source.Position;
+
+            // The stream should be always seekable, since they are under our control
+            var retryPolicy = source.CanSeek ? options.RetryPolicy : RetryPolicies.NoRetry();
+
+            return TaskImplHelper.GetRetryableAsyncTask(
+                () =>
+                {
+                    // This shouldn't ever be false happen, since source streams are under our control
+                    if (source.CanSeek)
+                    {
+                        source.Position = position;
+                    }
+
+                    return UploadFullBlobImpl(source, options);
+                },
+                retryPolicy);
+        }
+
+        /// <summary>
+        /// Uploads the full blob.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the blob.</returns>
+        internal TaskSequence UploadFullBlobImpl(Stream source, BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("modifers", options);
+
+            this.Properties.BlobType = BlobType.BlockBlob;
+            var request = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.Put(this.TransformedAddress, timeout, this.Properties, this.Properties.BlobType, null, 0));
+            BlobRequest.AddMetadata(request, this.Metadata);
+            var length = source.Length - source.Position;
+            CommonUtils.ApplyRequestOptimizations(request, length);
+            this.ServiceClient.Credentials.SignRequest(request);
+
+            var uploadTask = new InvokeTaskSequenceTask<WebResponse>((result) =>
+            {
+                return UploadData(request, source, result);
+            });
+            yield return uploadTask;
+
+            using (var response = uploadTask.Result as HttpWebResponse)
+            {
+                // Retrieve the ETag/LastModified
+                this.ParseSizeAndLastModified(response);
+
+                this.Properties.Length = length;
+            }
+        }
+
+        /// <summary>
+        /// Uploads the blob in parallel with blocks.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="blockSize">The size of the block.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the blob.</returns>
+        internal TaskSequence ParallelUploadBlobWithBlocks(Stream source, long blockSize, BlobRequestOptions options)
+        {
+            ParallelUpload uploader = new ParallelUpload(source, options, blockSize, this.ToBlockBlob);
+
+            return uploader.ParallelExecute(this.UploadBlockWithRetry);
+        }
+
+        /// <summary>
+        /// Uploads the block with retry.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="blockId">The block IS.</param>
+        /// <param name="contentMD5">The content MD5.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="Task&lt;NullTaskReturn&gt;"/> that uploads the block.</returns>
+        internal Task<NullTaskReturn> UploadBlockWithRetry(Stream source, string blockId, string contentMD5, BlobRequestOptions options)
+        {
+            // Used by our internal code. We always try to set the blockId as MD5
+            var position = source.Position;
+            var retryPolicy = source.CanSeek ? options.RetryPolicy : RetryPolicies.NoRetry();
+
+            return TaskImplHelper.GetRetryableAsyncTask(
+                () =>
+                {
+                    if (source.CanSeek)
+                    {
+                        source.Position = position;
+                    }
+
+                    return UploadBlock(source, blockId, contentMD5, options);
+                },
+                retryPolicy);
+        }
+
+        /// <summary>
+        /// Uploads the block.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="blockId">The block ID.</param>
+        /// <param name="contentMD5">The content MD5.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the block.</returns>
+        internal TaskSequence UploadBlock(Stream source, string blockId, string contentMD5, BlobRequestOptions options)
+        {
+            int id = Environment.TickCount;
+            TraceHelper.WriteLine("Starting upload for id {0}", id);
+            CommonUtils.AssertNotNull("options", options);
+
+            var request = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.PutBlock(this.TransformedAddress, timeout, blockId, null));
+            options.AccessCondition.ApplyCondition(request);
+            var length = source.Length - source.Position;
+            CommonUtils.ApplyRequestOptimizations(request, length);
+
+            if (!string.IsNullOrEmpty(contentMD5))
+            {
+                request.Headers.Set(HttpRequestHeader.ContentMd5, contentMD5);
+            }
+
+            this.ServiceClient.Credentials.SignRequest(request);
+
+            var uploadTask = new InvokeTaskSequenceTask<WebResponse>((result) =>
+            {
+                return UploadData(request, source, result);
+            });
+
+            yield return uploadTask;
+
+            uploadTask.Result.Close();
+
+            TraceHelper.WriteLine("Ending upload for id {0}", id);
+        }
+
+        /// <summary>
+        /// Uploads the data into the web request.
+        /// </summary>
+        /// <param name="request">The request that is setup for a put.</param>
+        /// <param name="source">The source of data.</param>
+        /// <param name="result">The response from the server.</param>
+        /// <returns>The sequence used for uploading data.</returns>
+        internal TaskSequence UploadData(HttpWebRequest request, Stream source, Action<WebResponse> result)
+        {
+            // Retrieve the stream
+            var requestStreamTask = request.GetRequestStreamAsync();
+            yield return requestStreamTask;
+
+            // Copy the data
+            using (var outputStream = requestStreamTask.Result)
+            {
+                var copyTask = new InvokeTaskSequenceTask(() => { return source.WriteTo(outputStream); });
+                yield return copyTask;
+
+                // Materialize any exceptions
+                var scratch = copyTask.Result;
+            }
+
+            // Get the response
+            var responseTask = request.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return responseTask;
+
+            // Return the response object
+            var response = responseTask.Result;
+
+            result(response);
+        }
+
+        /// <summary>
+        /// Implements the FetchAttributes method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that fetches the attributes.</returns>
+        internal TaskSequence FetchAttributesImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.GetProperties(this.TransformedAddress, timeout, this.SnapshotTime, null));
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                BlobAttributes attributes = BlobResponse.GetAttributes(webResponse);
+
+                // If BlobType is not unspecified and the value returned from cloud is different, 
+                // then it's a client error and we need to throw.
+                if (this.attributes.Properties.BlobType != BlobType.Unspecified && this.attributes.Properties.BlobType != attributes.Properties.BlobType)
+                {
+                    throw new InvalidOperationException(SR.BlobTypeMismatchExceptionMessage);
+                }
+
+                this.attributes.Properties = attributes.Properties;
+                this.attributes.Metadata = attributes.Metadata;
+            }
+        }
+
+        /// <summary>
+        /// Implements the DownloadToStream method.
+        /// </summary>
+        /// <param name="target">The target stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that downloads the blob to the stream.</returns>
+        internal TaskSequence DownloadToStreamImpl(Stream target, BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webResponseTask = new InvokeTaskSequenceTask<Stream>((result) => { return GetStreamImpl(options, result); });
+            yield return webResponseTask;
+
+            using (var responseStream = webResponseTask.Result)
+            {
+                var copyTask = new InvokeTaskSequenceTask(() => { return responseStream.WriteTo(target); });
+                yield return copyTask;
+
+                // Materialize any exceptions
+                var scratch = copyTask.Result;
+            }
+        }
+
+        /// <summary>
+        /// Implements the DownloadToStream method.
+        /// </summary>
+        /// <param name="target">The target stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="SynchronousTask"/> that downloads the blob to the stream.</returns>
+        internal SynchronousTask DownloadToStreamSyncImpl(Stream target, BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            return new SynchronousTask(() =>
+            {
+                using (var responseStream = GetStreamSyncImpl(options))
+                {
+                    responseStream.WriteToSync(target);
+                }
+            });
+        }
+
+        /// <summary>
+        /// Implements getting the stream.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="offset">The offset.</param>
+        /// <param name="count">The count.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that gets the stream.</returns>
+        internal TaskSequence GetStreamImpl(BlobRequestOptions options, long offset, long count, Action<Stream> setResult)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.Get(this.TransformedAddress, timeout, this.SnapshotTime, offset, count, null));
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            // Retrieve the stream
+            var responseTask = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return responseTask;
+
+            // Retrieve the response
+            var response = responseTask.Result as HttpWebResponse;
+
+            BlobAttributes attributes = BlobResponse.GetAttributes(response);
+            this.attributes.Metadata = attributes.Metadata;
+            this.attributes.Properties = attributes.Properties;
+
+            setResult(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Implements getting the stream without specifying a range.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="SynchronousTask"/> that gets the stream.</returns>
+        internal Stream GetStreamSyncImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.Get(this.TransformedAddress, timeout, this.SnapshotTime, null));
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            // Retrieve the response
+            webRequest.Timeout = (int)options.Timeout.Value.TotalMilliseconds;
+            
+            var response = this.ServiceClient.GetResponse(webRequest) as HttpWebResponse;
+            
+            BlobAttributes attributes = BlobResponse.GetAttributes(response);
+            this.attributes.Metadata = attributes.Metadata;
+            this.attributes.Properties = attributes.Properties;
+
+            return response.GetResponseStream();
+        }
+
+        /// <summary>
+        /// Implements getting the stream without specifying a range.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that gets the stream.</returns>
+        internal TaskSequence GetStreamImpl(BlobRequestOptions options, Action<Stream> setResult)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.Get(this.TransformedAddress, timeout, this.SnapshotTime, null));
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            // Retrieve the stream
+            var responseTask = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return responseTask;
+
+            // Retrieve the response
+            var response = responseTask.Result as HttpWebResponse;
+
+            BlobAttributes attributes = BlobResponse.GetAttributes(response);
+            this.attributes.Metadata = attributes.Metadata;
+            this.attributes.Properties = attributes.Properties;
+
+            setResult(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Retreive ETag and LastModified date time from response.
+        /// </summary>
+        /// <param name="response">The response to parse.</param>
+        protected void ParseSizeAndLastModified(HttpWebResponse response)
+        {
+            var newProperties = BlobResponse.GetAttributes(response);
+            this.Properties.ETag = newProperties.Properties.ETag ?? this.Properties.ETag;
+            this.Properties.LastModifiedUtc = newProperties.Properties.LastModifiedUtc;
+            if (newProperties.Properties.Length != 0)
+            {
+                this.Properties.Length = newProperties.Properties.Length;
+            }
+        }
+
+        /// <summary>
+        /// Parses the blob address query and returns snapshot and SAS.
+        /// </summary>
+        /// <param name="query">The query to parse.</param>
+        /// <param name="snapshot">The snapshot value, if any.</param>
+        /// <param name="sasCreds">The SAS credentials.</param>
+        private static void ParseBlobAddressQuery(string query, out string snapshot, out StorageCredentialsSharedAccessSignature sasCreds)
+        {
+            snapshot = null;
+            sasCreds = null;
+
+            var queryParameters = HttpUtility.ParseQueryString(query);
+
+            if (queryParameters.AllKeys.Contains(Constants.QueryConstants.Snapshot))
+            {
+                snapshot = queryParameters[Constants.QueryConstants.Snapshot];
+            }
+
+            SharedAccessSignatureHelper.ParseQuery(queryParameters, out sasCreds);
+        }
+
+        /// <summary>
+        /// Gets the default encoding for the blob, which is UTF-8.
+        /// </summary>
+        /// <returns>The default <see cref="Encoding"/> object.</returns>
+        private static Encoding GetDefaultEncoding()
+        {
+            Encoding encoding = Encoding.UTF8;
+
+            return encoding;
+        }
+
+        /// <summary>
+        /// Gets the canonical name of the blob, formatted as /&lt;account-name&gt;/&lt;container-name&gt;/&lt;blob-name&gt;.
+        /// If <c>ignoreSnapshotTime</c> is <c>false</c> and this blob is a snapshot, the canonical name is augmented with a
+        /// query of the form ?snapshot=&lt;snapshot-time&gt;.
+        /// <para>This is used by both Shared Access and Copy blob operations.</para>
+        /// Used by both Shared Access and Copy blob operation.
+        /// </summary>
+        /// <param name="ignoreSnapshotTime">Indicates if the snapshot time is ignored.</param>
+        /// <returns>The canonical name of the blob.</returns>
+        private string GetCanonicalName(bool ignoreSnapshotTime)
+        {
+            string accountName = this.ServiceClient.Credentials.AccountName;
+            string containerName = this.Container.Name;
+            string blobName = this.Name;
+
+            string canonicalName = string.Format("/{0}/{1}/{2}", accountName, containerName, blobName);
+
+            if (!ignoreSnapshotTime && this.SnapshotTime != null)
+            {
+                canonicalName += "?snapshot=" + Request.ConvertDateTimeToSnapshotString(this.SnapshotTime.Value.ToUniversalTime());
+            }
+
+            return canonicalName;
+        }
+
+        /// <summary>
+        /// Uploads a stream that doesn't have a known length. In this case we can't do any optimizations like creating a request before we read all of the data.
+        /// </summary>
+        /// <param name="source">The stream that is the source of data.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="blockSize">The block size to be used (null - no blocks).</param>
+        /// <returns>A sequence that represents uploading the blob.</returns>
+        /// <remarks>This is implemented by creating a BlobStream and using that to buffer data until we have sufficient amount to be sent.</remarks>
+        private TaskSequence UploadUnknownSizeStream(Stream source, BlobRequestOptions options, long blockSize)
+        {
+            // Potential Improvement: is there a better uploading scheme in absense of a known length
+            // This function is more a defensive measure; it should be rarely called, if ever. (Can seekable stream not have length?
+            // Cannot close as this is deferred execution
+            var target = this.OpenWrite(options);
+
+            target.BlockSize = blockSize;
+            return source.WriteToAndCloseOutput(target);
+        }
+
+        /// <summary>
+        /// Uploads the blob with blocks.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="blockSize">The size of the block.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the blob.</returns>
+        private TaskSequence UploadBlobWithBlocks(Stream source, BlobRequestOptions options, long blockSize)
+        {
+            CommonUtils.AssertNotNull("modifers", options);
+
+            var target = this.OpenWrite(options);
+
+            target.BlockSize = blockSize;
+            return source.WriteToAndCloseOutput(target);
+        }
+
+        /// <summary>
+        /// Uploads the full blob with a retry sequence.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the blob.</returns>
+        private TaskSequence UploadFullBlobWithRetrySequenceImpl(Stream source, BlobRequestOptions options)
+        {
+            var task = this.UploadFullBlobWithRetryImpl(source, options);
+
+            yield return task;
+
+            var scratch = task.Result;
+        }
+
+        /// <summary>
+        /// Implementation of the CopyFromBlob method.
+        /// </summary>
+        /// <param name="source">The source blob.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that copies the blob.</returns>
+        private TaskSequence CopyFromBlobImpl(CloudBlob source, BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            string sourceBlobUri = source.GetCanonicalName(false);
+
+            ConditionHeaderKind header;
+            string value;
+            AccessCondition.GetSourceConditions(options.CopySourceAccessCondition, out header, out value);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.CopyFrom(this.TransformedAddress, timeout, sourceBlobUri, this.SnapshotTime, header, value, null));
+
+            BlobRequest.AddMetadata(webRequest, this.Metadata);
+            
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var copyTask = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return copyTask;
+
+            // Parse the response
+            using (HttpWebResponse webResponse = copyTask.Result as HttpWebResponse)
+            {
+                this.ParseSizeAndLastModified(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Implements the DeleteBlob method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that deletes the blob.</returns>
+        private TaskSequence DeleteBlobImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.Delete(this.TransformedAddress, timeout, this.SnapshotTime, options.DeleteSnapshotsOption, null));
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the DeleteIfExists method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that deletes the blob if it exists.</returns>
+        private TaskSequence DeleteBlobIfExistsImpl(BlobRequestOptions options, Action<bool> setResult)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var task = new InvokeTaskSequenceTask(() => this.DeleteBlobImpl(options));
+
+            yield return task;
+
+            try
+            {
+                // Materialize exceptions
+                var scratch = task.Result;
+
+                setResult(true);
+            }
+            catch (StorageClientException e)
+            {
+                if (e.StatusCode == HttpStatusCode.NotFound)
+                {
+                    setResult(false);
+                }
+                else
+                {
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the CreateSnapshot method.
+        /// </summary>
+        /// <param name="metadata">A collection of name-value pairs defining the metadata of the snapshot, or null.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that creates the snapshot.</returns>
+        /// <remarks>If the <c>metadata</c> parameter is <c>null</c> then no metadata is associated with the request.</remarks>
+        private TaskSequence CreateSnapshotImpl(NameValueCollection metadata, BlobRequestOptions options, Action<CloudBlob> setResult)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.Snapshot(this.TransformedAddress, timeout));
+
+            BlobAttributes snapshotAttributes = new BlobAttributes(this.attributes);
+            
+            // If metadata was supplied it should be passed to the request.
+            // Otherwise, no metadata should be sent.
+            if (metadata != null)
+            {
+                BlobRequest.AddMetadata(webRequest, metadata);
+
+                // Update the snapshot's attributes to reflect the new metadata.
+                snapshotAttributes.Metadata.Clear();
+                snapshotAttributes.Metadata.Add(metadata);
+            }
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                string snapshotTime = BlobResponse.GetSnapshotTime(webResponse);
+
+                CloudBlob snapshot = new CloudBlob(snapshotAttributes, this.ServiceClient, snapshotTime);
+
+                snapshot.ParseSizeAndLastModified(webResponse);
+
+                setResult(snapshot);
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the SetMetadata method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that sets the metadata.</returns>
+        private TaskSequence SetMetadataImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.SetMetadata(this.TransformedAddress, timeout, null));
+
+            BlobRequest.AddMetadata(webRequest, this.Metadata);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+
+            yield return task;
+
+            // Parse the response
+            using (HttpWebResponse webResponse = task.Result as HttpWebResponse)
+            {
+                this.ParseSizeAndLastModified(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the SetProperties method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that sets the properties.</returns>
+        private TaskSequence SetPropertiesImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            if (this.Properties == null)
+            {
+                throw new InvalidOperationException("BlobProperties is null");
+            }
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.SetProperties(this.TransformedAddress, timeout, this.Properties, null, null));
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+
+            yield return task;
+
+            // Parse the response
+            using (HttpWebResponse webResponse = task.Result as HttpWebResponse)
+            {
+                this.ParseSizeAndLastModified(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Verifies that write operation is not done for snapshot.
+        /// </summary>
+        private void VerifyNoWriteOperationForSnapshot()
+        {
+            if (this.SnapshotTime != null)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotModifySnapshot);
+                throw new ArgumentException(errorMessage);
+            }
+        }
+
+        /// <summary>
+        /// Parses the snapshot time.
+        /// </summary>
+        /// <param name="snapshotTime">The snapshot time.</param>
+        /// <returns>The parsed snapshot time.</returns>
+        private DateTime ParseSnapshotTime(string snapshotTime)
+        {
+            DateTime snapshotDateTime;
+
+            if (!DateTime.TryParse(
+                snapshotTime,
+               CultureInfo.InvariantCulture,
+               DateTimeStyles.AdjustToUniversal,
+               out snapshotDateTime))
+            {
+                CommonUtils.ArgumentOutOfRange("snapshotTime", snapshotTime);
+            }
+
+            if (this.SnapshotTime != null && this.SnapshotTime != snapshotDateTime)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.MultipleSnapshotTimesProvided, snapshotDateTime, this.SnapshotTime);
+                throw new ArgumentException(errorMessage);
+            }
+
+            return snapshotDateTime;
+        }
+
+        /// <summary>
+        /// Parse Uri for any snapshot and SAS (Shared access signature) information. Validate that no other query parameters are passed in.
+        /// </summary>
+        /// <param name="completeUri">The complete Uri.</param>
+        /// <param name="existingClient">The existing blob client.</param>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <remarks>
+        /// Any snapshot information will be saved.
+        /// Any SAS information will be recorded as corresponding credentials instance.
+        /// If existingClient is passed in, any SAS information found will not be supported.
+        /// Otherwise a new client is created based on SAS information or as anonymous credentials.
+        /// </remarks>
+        private void ParseQueryAndVerify(Uri completeUri, CloudBlobClient existingClient, bool? usePathStyleUris)
+        {
+            CommonUtils.AssertNotNull("completeUri", completeUri);
+
+            if (!completeUri.IsAbsoluteUri)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.RelativeAddressNotPermitted, completeUri.ToString());
+                throw new ArgumentException(errorMessage, "completeUri");
+            }
+
+            this.attributes.Uri = new Uri(completeUri.GetLeftPart(UriPartial.Path));
+
+            string snapshot;
+            StorageCredentialsSharedAccessSignature sasCreds;
+            ParseBlobAddressQuery(completeUri.Query, out snapshot, out sasCreds);
+
+            if (!string.IsNullOrEmpty(snapshot))
+            {
+                this.SnapshotTime = this.ParseSnapshotTime(snapshot);
+            }
+
+            if (existingClient != null)
+            {
+                if (sasCreds != null && existingClient.Credentials != null && !sasCreds.Equals(existingClient.Credentials))
+                {
+                    string error = string.Format(CultureInfo.CurrentCulture, SR.MultipleCredentialsProvided);
+                    throw new ArgumentException(error);
+                }
+            }
+            else
+            {
+                StorageCredentials credentials = (StorageCredentials)sasCreds ?? StorageCredentialsAnonymous.Anonymous;
+                this.ServiceClient = new CloudBlobClient(usePathStyleUris, new Uri(NavigationHelper.GetServiceClientBaseAddress(this.Uri.AbsoluteUri, usePathStyleUris)), credentials);
+            }
+        }
+    }
+}
+
diff --git a/microsoft-azure-api/StorageClient/CloudBlobClient.cs b/microsoft-azure-api/StorageClient/CloudBlobClient.cs
new file mode 100644
index 0000000000000..afcd5c50475bc
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudBlobClient.cs
@@ -0,0 +1,1057 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudBlobClient.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudBlobClient class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using System.Threading;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Tasks.ITask>;
+
+    /// <summary>
+    /// Provides a client for accessing the Windows Azure Blob service.
+    /// </summary>
+    public class CloudBlobClient
+    {
+        /// <summary>
+        /// Constant for the max value of ParallelOperationThreadCount.
+        /// </summary>
+        private const int MaxParallelOperationThreadCount = 64;
+
+        /// <summary>
+        /// Stores the default delimiter.
+        /// </summary>
+        private string defaultDelimiter;
+
+        /// <summary>
+        /// Stores the parallelism factor.
+        /// </summary>
+        private int parallelismFactor = -1;
+
+        /// <summary>
+        /// Default is 32 MB.
+        /// </summary>
+        private long singleBlobUploadThresholdInBytes = Constants.MaxSingleUploadBlobSize / 2;
+
+        /// <summary>
+        /// Default is 4 MB.
+        /// </summary>
+        private long writeBlockSizeInBytes = Constants.DefaultWriteBlockSizeBytes;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobClient"/> class to be used for anonymous access.
+        /// </summary>
+        /// <param name="baseAddress">The Blob service endpoint to use to create the client.</param>
+        public CloudBlobClient(string baseAddress)
+            : this(baseAddress, StorageCredentialsAnonymous.Anonymous)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobClient"/> class using the specified Blob service endpoint
+        /// and account credentials.
+        /// </summary>
+        /// <param name="baseAddress">The Blob service endpoint to use to create the client.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudBlobClient(string baseAddress, StorageCredentials credentials)
+            : this(new Uri(baseAddress), credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobClient"/> class using the specified Blob service endpoint
+        /// and account credentials.
+        /// </summary>
+        /// <param name="baseUri">The Blob service endpoint to use to create the client.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudBlobClient(Uri baseUri, StorageCredentials credentials)
+            : this(null, baseUri, credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobClient"/> class.
+        /// </summary>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <param name="baseUri">The base Uri.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal CloudBlobClient(bool? usePathStyleUris, Uri baseUri, StorageCredentials credentials)
+        {
+            CommonUtils.AssertNotNull("baseUri", baseUri);
+            if (credentials == null)
+            {
+                credentials = StorageCredentialsAnonymous.Anonymous;
+            }
+
+            if (!baseUri.IsAbsoluteUri)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.RelativeAddressNotPermitted, baseUri.ToString());
+                throw new ArgumentException(errorMessage, "baseUri");
+            }
+
+            this.BaseUri = baseUri;
+            this.Credentials = credentials;
+            this.RetryPolicy = RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultClientBackoff);
+            this.Timeout = Constants.DefaultClientSideTimeout;
+            this.DefaultDelimiter = "/";
+            this.ReadAheadInBytes = Constants.DefaultReadAheadSizeBytes;
+            this.UseIntegrityControlForStreamReading = true;
+
+            if (usePathStyleUris.HasValue)
+            {
+                this.UsePathStyleUris = usePathStyleUris.Value;
+            }
+            else
+            {
+                // Automatically decide whether to use host style uri or path style uri
+                this.UsePathStyleUris = CommonUtils.UsePathStyleAddressing(this.BaseUri);
+            }
+        }
+
+        /// <summary>
+        /// Occurs when a response is received from the server.
+        /// </summary>
+        public event EventHandler<ResponseReceivedEventArgs> ResponseReceived;
+
+        /// <summary>
+        /// Gets the account credentials used to create the Blob service client.
+        /// </summary>
+        /// <value>The account credentials.</value>
+        public StorageCredentials Credentials { get; private set; }
+
+        /// <summary>
+        /// Gets the base URI for the Blob service client.
+        /// </summary>
+        /// <value>The base URI used to construct the Blob service client.</value>
+        public Uri BaseUri { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the default retry policy for requests made via the Blob service client.
+        /// </summary>
+        /// <value>The retry policy.</value>
+        public RetryPolicy RetryPolicy { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default server and client timeout for requests made by the Blob service client.
+        /// </summary>
+        /// <value>The server and client timeout interval.</value>
+        public TimeSpan Timeout { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default delimiter that may be used to create a virtual directory structure of blobs.
+        /// </summary>
+        /// <value>The default delimiter.</value>
+        public string DefaultDelimiter
+        {
+            get
+            {
+                return this.defaultDelimiter;
+            }
+
+            set
+            {
+                CommonUtils.AssertNotNullOrEmpty("DefaultDelimiter", value);
+                this.defaultDelimiter = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum size of a blob in bytes that may be uploaded as a single blob. 
+        /// </summary>
+        /// <value>The maximum size of a blob, in bytes, that may be uploaded as a single blob,
+        /// ranging from between 1 and 64 MB inclusive.</value>
+        public long SingleBlobUploadThresholdInBytes
+        {
+            get
+            {
+                return this.singleBlobUploadThresholdInBytes;
+            }
+
+            set
+            {
+                if (value > Constants.MaxSingleUploadBlobSize || value < 1 * Constants.MB)
+                {
+                    throw new ArgumentOutOfRangeException("SingleBlobUploadThresholdInBytes");
+                }
+
+                this.singleBlobUploadThresholdInBytes = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum block size for writing to a block blob.
+        /// </summary>
+        /// <value>The maximum size of a block, in bytes, ranging from between 1 and 4 MB inclusive.</value>
+        public long WriteBlockSizeInBytes
+        {
+            get
+            {
+                return this.writeBlockSizeInBytes;
+            }
+
+            set
+            {
+                if (value > Constants.DefaultWriteBlockSizeBytes || value < 1 * Constants.MB)
+                {
+                    throw new ArgumentOutOfRangeException("WriteBlockSizeInBytes");
+                }
+
+                this.writeBlockSizeInBytes = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the number of bytes to pre-fetch when reading from a stream.
+        /// </summary>
+        /// <value>The number of bytes to read ahead from a stream.</value>
+        public long ReadAheadInBytes { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the integrity of each block should be verified when reading from a stream.
+        /// </summary>
+        /// <value><c>True</c> if using integrity control for stream reading; otherwise, <c>false</c>. The default value is <c>true</c>.</value>
+        public bool UseIntegrityControlForStreamReading { get; set; }
+
+        /// <summary>
+        /// Gets or sets the number of blocks that may be simultaneously uploaded when uploading a blob that is greater than 
+        /// the value specified by the <see cref="SingleBlobUploadThresholdInBytes"/> property.
+        /// in size.
+        /// </summary>
+        /// <value>The number of parallel operations that may proceed.</value>
+        public int ParallelOperationThreadCount
+        {
+            get
+            {
+                if (this.parallelismFactor == -1)
+                {
+                    int workerThreads;
+                    int ioThreads;
+                    ThreadPool.GetMinThreads(out workerThreads, out ioThreads);
+                    this.parallelismFactor = ioThreads;
+                }
+
+                return this.parallelismFactor;
+            }
+
+            set
+            {
+                CommonUtils.AssertInBounds("UploadParallelActiveTasks", value, 1, MaxParallelOperationThreadCount);
+
+                this.parallelismFactor = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the service client is used with Path style or Host style.
+        /// </summary>
+        /// <value>Is <c>true</c> if use path style uris; otherwise, <c>false</c>.</value>
+        internal bool UsePathStyleUris { get; private set; }
+
+        /// <summary>
+        /// Gets the properties of the blob service.
+        /// </summary>
+        /// <returns>The blob service properties.</returns>
+        public ServiceProperties GetServiceProperties()
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<ServiceProperties>((setResult) => this.GetServicePropertiesImpl(setResult), this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to get the properties of the blob service.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user defined object to be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetServiceProperties(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ServiceProperties>((setResult) => this.GetServicePropertiesImpl(setResult), this.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to get the properties of the blob service.
+        /// </summary>
+        /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginGetServiceProperties"/>.</param>
+        /// <returns>The blob service properties.</returns>
+        public ServiceProperties EndGetServiceProperties(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ServiceProperties>(asyncResult);
+        }
+
+        /// <summary>
+        /// Sets the properties of the blob service.
+        /// </summary>
+        /// <param name="properties">The blob service properties.</param>
+        public void SetServiceProperties(ServiceProperties properties)
+        {
+            TaskImplHelper.ExecuteImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to set the properties of the blob service.
+        /// </summary>
+        /// <param name="properties">The blob service properties.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user defined object to be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to set the properties of the blob service.
+        /// </summary>
+        /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginSetServiceProperties"/>.</param>
+        public void EndSetServiceProperties(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudPageBlob"/> object with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <returns>A reference to a page blob.</returns>
+        [Obsolete]
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public CloudPageBlob GetPageBlob(string blobAddress)
+        {
+            return this.GetPageBlobReference(blobAddress);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudPageBlob"/> object with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <returns>A reference to a page blob.</returns>
+        public CloudPageBlob GetPageBlobReference(string blobAddress)
+        {
+            return this.GetPageBlobReference(blobAddress, null);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudPageBlob"/> object with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <returns>A reference to a page blob.</returns>
+        public CloudPageBlob GetPageBlobReference(string blobAddress, DateTime? snapshotTime)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAbsoluteUriString", blobAddress);
+            return new CloudPageBlob(blobAddress, snapshotTime, this);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudBlockBlob"/> object with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <returns>A reference to a block blob.</returns>
+        [Obsolete]
+        [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
+        public CloudBlockBlob GetBlockBlob(string blobAddress)
+        {
+            return this.GetBlockBlobReference(blobAddress);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudBlockBlob"/> with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <returns>A reference to a block blob.</returns>
+        public CloudBlockBlob GetBlockBlobReference(string blobAddress)
+        {
+            return this.GetBlockBlobReference(blobAddress, null);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudBlockBlob"/> with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <returns>A reference to a block blob.</returns>
+        public CloudBlockBlob GetBlockBlobReference(string blobAddress, DateTime? snapshotTime)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAbsoluteUriString", blobAddress);
+            return new CloudBlockBlob(blobAddress, snapshotTime, this);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudBlob"/> with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <returns>A reference to a blob.</returns>
+        public CloudBlob GetBlobReference(string blobAddress)
+        {
+            return this.GetBlobReference(blobAddress, null);
+        }
+
+        /// <summary>
+        /// Returns a reference to a blob with the specified address.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob, or a relative URI beginning with the container name.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <returns>A reference to a blob.</returns>
+        public CloudBlob GetBlobReference(string blobAddress, DateTime? snapshotTime)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAbsoluteUriString", blobAddress);
+            return new CloudBlob(blobAddress, snapshotTime, this);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudBlobContainer"/> object with the specified address.
+        /// </summary>
+        /// <param name="containerAddress">The name of the container, or an absolute URI to the container.</param>
+        /// <returns>A reference to a container.</returns>
+        public CloudBlobContainer GetContainerReference(string containerAddress)
+        {
+            CommonUtils.AssertNotNullOrEmpty("containerAddress", containerAddress);
+            return new CloudBlobContainer(containerAddress, this);
+        }
+
+        /// <summary>
+        /// Returns a reference to a <see cref="CloudBlobDirectory"/> object with the specified address.
+        /// </summary>
+        /// <param name="blobDirectoryAddress">The absolute URI to the virtual directory, 
+        /// or a relative URI beginning with the container name.</param>
+        /// <returns>A reference to a virtual directory.</returns>
+        public CloudBlobDirectory GetBlobDirectoryReference(string blobDirectoryAddress)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobDirectoryAddress", blobDirectoryAddress);
+            return new CloudBlobDirectory(blobDirectoryAddress, this);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of containers.
+        /// </summary>
+        /// <returns>An enumerable collection of containers.</returns>
+        public IEnumerable<CloudBlobContainer> ListContainers()
+        {
+            return this.ListContainers(null, ContainerListingDetails.None);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of containers whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The container name prefix.</param>
+        /// <returns>An enumerable collection of containers.</returns>
+        public IEnumerable<CloudBlobContainer> ListContainers(string prefix)
+        {
+            return this.ListContainers(prefix, ContainerListingDetails.None);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of containers whose names 
+        /// begin with the specified prefix and that are retrieved lazily.
+        /// </summary>
+        /// <param name="prefix">The container name prefix.</param>
+        /// <param name="detailsIncluded">A value that indicates whether to return container metadata with the listing.</param>
+        /// <returns>An enumerable collection of containers that are retrieved lazily.</returns>
+        public IEnumerable<CloudBlobContainer> ListContainers(string prefix, ContainerListingDetails detailsIncluded)
+        {
+            return CommonUtils.LazyEnumerateSegmented<CloudBlobContainer>(
+                (setResult) => this.ListContainersImpl(prefix, detailsIncluded, null, null, setResult),
+                this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of containers.
+        /// </summary>
+        /// <returns>A result segment of containers.</returns>
+        public ResultSegment<CloudBlobContainer> ListContainersSegmented()
+        {
+            return this.ListContainersSegmented(null);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of containers
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The container name prefix.</param>
+        /// <returns>A result segment of containers.</returns>
+        public ResultSegment<CloudBlobContainer> ListContainersSegmented(string prefix)
+        {
+            return this.ListContainersSegmented(prefix, ContainerListingDetails.None, 0, null);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of containers
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The container name prefix.</param>
+        /// <param name="detailsIncluded">A value that indicates whether to return container metadata with the listing.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned 
+        /// in the result segment, up to the per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <returns>A result segment of containers.</returns>
+        public ResultSegment<CloudBlobContainer> ListContainersSegmented(
+            string prefix,
+            ContainerListingDetails detailsIncluded,
+            int maxResults,
+            ResultContinuation continuationToken)
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<CloudBlobContainer>>(
+                (setResult) => this.ListContainersImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
+                this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to return a result segment containing a collection of containers.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListContainersSegmented(AsyncCallback callback, object state)
+        {
+            return this.BeginListContainersSegmented(null, ContainerListingDetails.None, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to return a result segment containing a collection of containers
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The container name prefix.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListContainersSegmented(string prefix, AsyncCallback callback, object state)
+        {
+            return this.BeginListContainersSegmented(prefix, ContainerListingDetails.None, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to return a result segment containing a collection of containers
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The container name prefix.</param>
+        /// <param name="detailsIncluded">A value that indicates whether to return container metadata with the listing.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListContainersSegmented(string prefix, ContainerListingDetails detailsIncluded, AsyncCallback callback, object state)
+        {
+            return this.BeginListContainersSegmented(prefix, detailsIncluded, 0, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to return a result segment containing a collection of containers
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The container name prefix.</param>
+        /// <param name="detailsIncluded">A value that indicates whether to return container metadata with the listing.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned 
+        /// in the result segment, up to the per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListContainersSegmented(
+            string prefix,
+            ContainerListingDetails detailsIncluded,
+            int maxResults,
+            ResultContinuation continuationToken,
+            AsyncCallback callback,
+            object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<CloudBlobContainer>>(
+                (setResult) => this.ListContainersImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
+                this.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to return a result segment containing a collection of containers.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A result segment of containers.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public ResultSegment<CloudBlobContainer> EndListContainersSegmented(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<CloudBlobContainer>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of blob items whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute URI to the container.</param>
+        /// <returns>An enumerable collection of objects that implement <see cref="IListBlobItem"/>.</returns>
+        public IEnumerable<IListBlobItem> ListBlobsWithPrefix(string prefix)
+        {
+            return this.ListBlobsWithPrefix(prefix, null);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of blob items whose names begin with the specified prefix and that are retrieved lazily. 
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute URI to the container.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>An enumerable collection of objects that implement <see cref="IListBlobItem"/> and are retrieved lazily.</returns>
+        public IEnumerable<IListBlobItem> ListBlobsWithPrefix(string prefix, BlobRequestOptions options)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this, options);
+
+            return CommonUtils.LazyEnumerateSegmented<IListBlobItem>(
+                (setResult) => this.ListBlobImpl(prefix, null, null, fullModifier, setResult),
+                this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items whose names
+        /// begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsWithPrefixSegmented(string prefix)
+        {
+            return this.ListBlobsWithPrefixSegmented(prefix, 0, null, null);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items whose names
+        /// begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsWithPrefixSegmented(string prefix, BlobRequestOptions options)
+        {
+            return this.ListBlobsWithPrefixSegmented(prefix, 0, null, options);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items whose names
+        /// begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the per-operation limit of 5000. 
+        /// If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsWithPrefixSegmented(
+            string prefix,
+            int maxResults,
+            ResultContinuation continuationToken)
+        {
+            return this.ListBlobsWithPrefixSegmented(prefix, maxResults, continuationToken, null);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items whose names
+        /// begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the per-operation limit of 5000. 
+        /// If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsWithPrefixSegmented(
+            string prefix,
+            int maxResults,
+            ResultContinuation continuationToken,
+            BlobRequestOptions options)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<IListBlobItem>>(
+               (setResult) => this.ListBlobImpl(prefix, continuationToken, maxResults, fullModifier, setResult),
+               this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection 
+        /// of blob items whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsWithPrefixSegmented(string prefix, AsyncCallback callback, object state)
+        {
+            return this.BeginListBlobsWithPrefixSegmented(prefix, 0, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection 
+        /// of blob items whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The blob name prefix. This value must be preceded either by the name of the container or by the absolute path to the container.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsWithPrefixSegmented(
+            string prefix,
+            int maxResults,
+            ResultContinuation continuationToken,
+            AsyncCallback callback,
+            object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<IListBlobItem>>(
+                (setResult) => this.ListBlobImpl(prefix, continuationToken, maxResults, null, setResult),
+                this.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to return a result segment containing a collection 
+        /// of blob items whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public ResultSegment<IListBlobItem> EndListBlobsWithPrefixSegmented(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<IListBlobItem>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Selects the protocol response.
+        /// </summary>
+        /// <param name="protocolItem">The protocol item.</param>
+        /// <param name="service">The service.</param>
+        /// <param name="container">The container.</param>
+        /// <returns>The parsed <see cref="IListBlobItem"/>.</returns>
+        internal static IListBlobItem SelectProtocolResponse(IListBlobEntry protocolItem, CloudBlobClient service, CloudBlobContainer container)
+        {
+            BlobEntry blob = protocolItem as BlobEntry;
+            if (blob != null)
+            {
+                var attributes = blob.Attributes;
+                CloudBlob cloudBlob;
+                if (attributes.Properties.BlobType == BlobType.BlockBlob)
+                {
+                    cloudBlob = new CloudBlockBlob(attributes, service, ConvertDateTimeToSnapshotString(attributes.Snapshot));
+                }
+                else if (attributes.Properties.BlobType == BlobType.PageBlob)
+                {
+                    cloudBlob = new CloudPageBlob(attributes, service, ConvertDateTimeToSnapshotString(attributes.Snapshot));
+                }
+                else
+                {
+                    cloudBlob = new CloudBlob(attributes, service, ConvertDateTimeToSnapshotString(attributes.Snapshot));
+                }
+
+                return cloudBlob;
+            }
+
+            BlobPrefixEntry blobPrefix = protocolItem as BlobPrefixEntry;
+
+            if (blobPrefix != null)
+            {
+                if (container != null)
+                {
+                    return container.GetDirectoryReference(blobPrefix.Name);
+                }
+                else
+                {
+                    return new CloudBlobDirectory(blobPrefix.Name, service);
+                }
+            }
+
+            throw new InvalidOperationException("Invalid blob list item returned");
+        }
+
+        /// <summary>
+        /// Ends the asynchronous GetResponse operation.
+        /// </summary>
+        /// <param name="asyncresult">An <see cref="IAsyncResult"/> that references the asynchronous operation.</param>
+        /// <param name="req">The request to end the operation on.</param>
+        /// <returns>The <see cref="WebResponse"/> from the asynchronous request.</returns>
+        internal WebResponse EndGetResponse(IAsyncResult asyncresult, WebRequest req)
+        {
+            return EventHelper.ProcessWebResponse(req, asyncresult, this.ResponseReceived, this);
+        }
+
+        /// <summary>
+        /// Gets the response for the operation.
+        /// </summary>
+        /// <param name="req">The request to end the operation on.</param>
+        /// <returns>The <see cref="WebResponse"/> from the request.</returns>
+        internal WebResponse GetResponse(WebRequest req)
+        {
+            return EventHelper.ProcessWebResponseSync(req, this.ResponseReceived, this);
+        }
+
+        /// <summary>
+        /// Parses the user prefix.
+        /// </summary>
+        /// <param name="prefix">The prefix.</param>
+        /// <param name="containerName">Name of the container.</param>
+        /// <param name="listingPrefix">The listing prefix.</param>
+        private static void ParseUserPrefix(string prefix, out string containerName, out string listingPrefix)
+        {
+            containerName = null;
+            listingPrefix = null;
+
+            string[] prefixParts = prefix.Split(NavigationHelper.SlashAsSplitOptions, 2, StringSplitOptions.None);
+            if (prefixParts.Length == 1)
+            {
+                // No slash in prefix
+                // Case abc => container = $root, prefix=abc; Listing with prefix at root
+                listingPrefix = prefixParts[0];
+            }
+            else
+            {
+                // Case "/abc" => container=$root, prefix=abc; Listing with prefix at root
+                // Case "abc/" => container=abc, no prefix; Listing all under a container
+                // Case "abc/def" => container = abc, prefix = def; Listing with prefix under a container
+                // Case "/" => container=$root, no prefix; Listing all under root
+                containerName = prefixParts[0];
+                listingPrefix = prefixParts[1];
+            }
+
+            if (string.IsNullOrEmpty(containerName))
+            {
+                containerName = "$root";
+            }
+
+            if (string.IsNullOrEmpty(listingPrefix))
+            {
+                listingPrefix = null;
+            }
+        }
+
+        /// <summary>
+        /// Converts the date time to snapshot string.
+        /// </summary>
+        /// <param name="snapshot">The snapshot time to convert.</param>
+        /// <returns>A string representing the snapshot time.</returns>
+        private static string ConvertDateTimeToSnapshotString(DateTime? snapshot)
+        {
+            if (snapshot.HasValue)
+            {
+                return Protocol.Request.ConvertDateTimeToSnapshotString(snapshot.Value);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Implementation for the ListContainers method.
+        /// </summary>
+        /// <param name="prefix">The container prefix.</param>
+        /// <param name="detailsIncluded">The details included.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="maxResults">The maximum results to return.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that lists the containers.</returns>
+        private TaskSequence ListContainersImpl(
+            string prefix,
+            ContainerListingDetails detailsIncluded,
+            ResultContinuation continuationToken,
+            int? maxResults,
+            Action<ResultSegment<CloudBlobContainer>> setResult)
+        {
+            ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
+
+            return this.ListContainersImplCore(prefix, detailsIncluded, continuationToken, pagination, setResult);
+        }
+
+        /// <summary>
+        /// Core implementation for the ListContainers method.
+        /// </summary>
+        /// <param name="prefix">The container prefix.</param>
+        /// <param name="detailsIncluded">The details included.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="pagination">The pagination.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that lists the containers.</returns>
+        private TaskSequence ListContainersImplCore(
+            string prefix,
+            ContainerListingDetails detailsIncluded,
+            ResultContinuation continuationToken,
+            ResultPagination pagination,
+            Action<ResultSegment<CloudBlobContainer>> setResult)
+        {
+            CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Container);
+
+            ListingContext listingContext = new ListingContext(prefix, pagination.GetNextRequestPageSize())
+            {
+                Marker = continuationToken != null ? continuationToken.NextMarker : null
+            };
+
+            var containersList = new List<CloudBlobContainer>();
+
+            var request = ContainerRequest.List(this.BaseUri, this.Timeout.RoundUpToSeconds(), listingContext, detailsIncluded);
+
+            this.Credentials.SignRequest(request);
+
+            var listTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
+
+            yield return listTask;
+
+            string nextMarker;
+
+            using (var response = listTask.Result as HttpWebResponse)
+            {
+                ListContainersResponse listContainersResponse = ContainerResponse.List(response);
+
+                containersList.AddRange(listContainersResponse.Containers.Select((item) => new CloudBlobContainer(item.Attributes, this)));
+
+                nextMarker = listContainersResponse.NextMarker;
+            }
+
+            ResultContinuation newContinuationToken = new ResultContinuation() { NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Container };
+
+            ResultSegment.CreateResultSegment(
+                setResult,
+                containersList,
+                newContinuationToken,
+                pagination,
+                this.RetryPolicy,
+                (paginationArg, continuationArg, resultSegmentArg) =>
+                    this.ListContainersImplCore(
+                        prefix,
+                        detailsIncluded,
+                        continuationArg,
+                        paginationArg,
+                        resultSegmentArg));
+        }
+
+        /// <summary>
+        /// Implementation for the ListBlobs method.
+        /// </summary>
+        /// <param name="prefix">The blob prefix.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="maxResults">The max results.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>
+        /// A <see cref="TaskSequence"/> that lists the blobs.
+        /// </returns>
+        private TaskSequence ListBlobImpl(
+            string prefix,
+            ResultContinuation continuationToken,
+            int? maxResults,
+            BlobRequestOptions options,
+            Action<ResultSegment<IListBlobItem>> setResult)
+        {
+            CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Blob);
+
+            string containerName = null;
+            string listingPrefix = null;
+
+            ParseUserPrefix(prefix, out containerName, out listingPrefix);
+            var containerInfo = new CloudBlobContainer(containerName, this);
+
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this, options);
+
+            return containerInfo.ListBlobsImpl(listingPrefix, fullModifier, continuationToken, maxResults, setResult);
+        }
+
+        /// <summary>
+        /// Generates a task sequence for getting the properties of the blob service.
+        /// </summary>
+        /// <param name="setResult">A delegate to receive the service properties.</param>
+        /// <returns>A task sequence that gets the properties of the blob service.</returns>
+        private TaskSequence GetServicePropertiesImpl(Action<ServiceProperties> setResult)
+        {
+            HttpWebRequest request = BlobRequest.GetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(request, -1);
+            this.Credentials.SignRequest(request);
+
+            // Get the web response.
+            Task<WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
+            yield return responseTask;
+
+            using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
+            using (Stream responseStream = response.GetResponseStream())
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                // Download the service properties.
+                Task<NullTaskReturn> downloadTask = new InvokeTaskSequenceTask(() => { return responseStream.WriteTo(memoryStream); });
+                yield return downloadTask;
+
+                // Materialize any exceptions.
+                NullTaskReturn scratch = downloadTask.Result;
+
+                // Get the result from the memory stream.
+                memoryStream.Seek(0, SeekOrigin.Begin);
+                setResult(BlobResponse.ReadServiceProperties(memoryStream));
+            }
+        }
+
+        /// <summary>
+        /// Generates a task sequence for setting the properties of the blob service.
+        /// </summary>
+        /// <param name="properties">The blob service properties to set.</param>
+        /// <returns>A task sequence that sets the properties of the blob service.</returns>
+        private TaskSequence SetServicePropertiesImpl(ServiceProperties properties)
+        {
+            CommonUtils.AssertNotNull("properties", properties);
+
+            HttpWebRequest request = BlobRequest.SetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                try
+                {
+                    BlobRequest.WriteServiceProperties(properties, memoryStream);
+                }
+                catch (InvalidOperationException invalidOpException)
+                {
+                    throw new ArgumentException(invalidOpException.Message, "properties");
+                }
+
+                memoryStream.Seek(0, SeekOrigin.Begin);
+                CommonUtils.ApplyRequestOptimizations(request, memoryStream.Length);
+                this.Credentials.SignRequest(request);
+
+                // Get the request stream
+                Task<Stream> getStreamTask = request.GetRequestStreamAsync();
+                yield return getStreamTask;
+
+                using (Stream requestStream = getStreamTask.Result)
+                {
+                    // Upload the service properties.
+                    Task<NullTaskReturn> uploadTask = new InvokeTaskSequenceTask(() => { return (memoryStream as Stream).WriteTo(requestStream); });
+                    yield return uploadTask;
+
+                    // Materialize any exceptions.
+                    NullTaskReturn scratch = uploadTask.Result;
+                }
+            }
+
+            // Get the web response.
+            Task<WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
+            yield return responseTask;
+
+            // Materialize any exceptions.
+            using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
+            {
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudBlobContainer.cs b/microsoft-azure-api/StorageClient/CloudBlobContainer.cs
new file mode 100644
index 0000000000000..da852a5c1ccb8
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudBlobContainer.cs
@@ -0,0 +1,1225 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudBlobContainer.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudBlobContainer class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Web;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a container in the Windows Azure Blob service.
+    /// </summary>
+    public class CloudBlobContainer
+    {
+        /// <summary>
+        /// Stores the transformed address.
+        /// </summary>
+        private Uri transformedAddress;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobContainer"/> class.
+        /// </summary>
+        /// <param name="containerAddress">The absolute URI to the container.</param>
+        public CloudBlobContainer(string containerAddress)
+            : this(null, containerAddress)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobContainer"/> class.
+        /// </summary>
+        /// <param name="containerAddress">The absolute URI to the container.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudBlobContainer(string containerAddress, StorageCredentials credentials)
+            : this(containerAddress, new CloudBlobClient(NavigationHelper.GetServiceClientBaseAddress(containerAddress, null), credentials))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobContainer"/> class.
+        /// </summary>
+        /// <param name="containerAddress">Either the absolute URI to the container, or the container name.</param>
+        /// <param name="service">A client object that specifies the endpoint for the Blob service.</param>
+        public CloudBlobContainer(string containerAddress, CloudBlobClient service)
+        {
+            this.Attributes = new BlobContainerAttributes();
+            this.ServiceClient = service;
+
+            Uri completeUri = NavigationHelper.AppendPathToUri(this.ServiceClient.BaseUri, containerAddress);
+
+            this.ParseQueryAndVerify(completeUri, this.ServiceClient, this.ServiceClient.UsePathStyleUris);
+
+            this.Name = NavigationHelper.GetContainerNameFromContainerAddress(this.Uri, this.ServiceClient.UsePathStyleUris);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobContainer"/> class with the given address and path style Uri preference.
+        /// </summary>
+        /// <param name="containerAddress">The container's address.</param>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        internal CloudBlobContainer(string containerAddress, bool usePathStyleUris)
+            : this(usePathStyleUris, containerAddress)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobContainer"/> class.
+        /// </summary>
+        /// <param name="containerAddress">The container address.</param>
+        /// <param name="credentials">The credentials.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> path style Uris are used.</param>
+        internal CloudBlobContainer(string containerAddress, StorageCredentials credentials, bool usePathStyleUris)
+            : this(containerAddress, new CloudBlobClient(NavigationHelper.GetServiceClientBaseAddress(containerAddress, usePathStyleUris), credentials))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobContainer"/> class.
+        /// </summary>
+        /// <param name="attrib">The attributes for the container (NOTE: Stored by reference).</param>
+        /// <param name="client">The client to be used.</param>
+        internal CloudBlobContainer(BlobContainerAttributes attrib, CloudBlobClient client)
+        {
+            this.ServiceClient = client;
+            this.Attributes = attrib;
+
+            Uri completeUri = NavigationHelper.AppendPathToUri(this.ServiceClient.BaseUri, attrib.Uri.AbsoluteUri);
+
+            this.ParseQueryAndVerify(completeUri, this.ServiceClient, this.ServiceClient.UsePathStyleUris);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobContainer"/> class.
+        /// </summary>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <param name="containerAddress">The container's address.</param>
+        internal CloudBlobContainer(bool? usePathStyleUris, string containerAddress)
+        {
+            this.Attributes = new BlobContainerAttributes();
+
+            Uri completeUri = new Uri(containerAddress);
+
+            this.ParseQueryAndVerify(completeUri, null, usePathStyleUris);
+        }
+
+        /// <summary>
+        /// Gets the service client for the container.
+        /// </summary>
+        /// <value>A client object that specifies the endpoint for the Blob service.</value>
+        public CloudBlobClient ServiceClient { get; private set; }
+
+        /// <summary>
+        /// Gets the container's URI.
+        /// </summary>
+        /// <value>The absolute URI to the container.</value>
+        public Uri Uri
+        {
+            get
+            {
+                return this.Attributes.Uri;
+            }
+
+            private set
+            {
+                this.Attributes.Uri = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the name of the container.
+        /// </summary>
+        /// <value>The container's name.</value>
+        public string Name
+        {
+            get
+            {
+                return this.Attributes.Name;
+            }
+
+            private set
+            {
+                this.Attributes.Name = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the container's metadata.
+        /// </summary>
+        /// <value>The container's metadata.</value>
+        public NameValueCollection Metadata
+        {
+            get
+            {
+                return this.Attributes.Metadata;
+            }
+        }
+
+        /// <summary>
+        /// Gets the container's attributes.
+        /// </summary>
+        /// <value>The container's attributes.</value>
+        public BlobContainerAttributes Attributes { get; internal set; }
+
+        /// <summary>
+        /// Gets the container's system properties.
+        /// </summary>
+        /// <value>The container's properties.</value>
+        public BlobContainerProperties Properties
+        {
+            get
+            {
+                return this.Attributes.Properties;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Uri after applying authentication transformation.
+        /// </summary>
+        internal Uri TransformedAddress
+        {
+            get
+            {
+                if (this.ServiceClient.Credentials.NeedsTransformUri)
+                {
+                    // This is required to support key rotation
+                    // Potential improvement: cache the value of credential and derived Uri to avoid recomputation
+                    this.transformedAddress = new Uri(this.ServiceClient.Credentials.TransformUri(this.Uri.AbsoluteUri));
+
+                    return this.transformedAddress;
+                }
+                else
+                {
+                    return this.Uri;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets a reference to a blob in this container.
+        /// </summary>
+        /// <param name="blobAddressUri">The name of the blob, or the absolute URI to the blob.</param>
+        /// <returns>A reference to a blob.</returns>
+        public CloudBlob GetBlobReference(string blobAddressUri)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAddressUri", blobAddressUri);
+
+            return new CloudBlob(this.GetBlobAbsoluteUri(blobAddressUri), this.ServiceClient, this);
+        }
+
+        /// <summary>
+        /// Gets a reference to a page blob in this container.
+        /// </summary>
+        /// <param name="blobAddressUri">The name of the blob, or the absolute URI to the blob.</param>
+        /// <returns>A reference to a page blob.</returns>
+        public CloudPageBlob GetPageBlobReference(string blobAddressUri)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAbsoluteUri", blobAddressUri);
+
+            return new CloudPageBlob(this.GetBlobAbsoluteUri(blobAddressUri), this.ServiceClient, this);
+        }
+
+        /// <summary>
+        /// Gets a reference to a block blob in this container.
+        /// </summary>
+        /// <param name="blobAddressUri">The name of the blob, or the absolute URI to the blob.</param>
+        /// <returns>A reference to a block blob.</returns>
+        public CloudBlockBlob GetBlockBlobReference(string blobAddressUri)
+        {
+            CommonUtils.AssertNotNullOrEmpty("blobAbsoluteUri", blobAddressUri);
+
+            return new CloudBlockBlob(this.GetBlobAbsoluteUri(blobAddressUri), this.ServiceClient, this);
+        }
+
+        /// <summary>
+        /// Gets a reference to a virtual blob directory beneath this container.
+        /// </summary>
+        /// <param name="relativeAddress">The name of the virtual blob directory, or the absolute URI to the virtual blob directory.</param>
+        /// <returns>A reference to a virtual blob directory.</returns>
+        public CloudBlobDirectory GetDirectoryReference(string relativeAddress)
+        {
+            CommonUtils.AssertNotNullOrEmpty("relativeAddress", relativeAddress);
+
+            var blobDirectoryUri = NavigationHelper.AppendPathToUri(this.Uri, relativeAddress);
+            return new CloudBlobDirectory(blobDirectoryUri.AbsoluteUri, this.ServiceClient);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of the blobs in the container.
+        /// </summary>
+        /// <returns>An enumerable collection of objects that implement <see cref="IListBlobItem"/>.</returns>
+        public IEnumerable<IListBlobItem> ListBlobs()
+        {
+            return this.ListBlobs(null);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of the blobs in the container that are retrieved lazily.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>An enumerable collection of objects that implement <see cref="IListBlobItem"/> and are retrieved lazily.</returns>
+        public IEnumerable<IListBlobItem> ListBlobs(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return CommonUtils.LazyEnumerateSegmented<IListBlobItem>(
+                (setResult) => this.ListBlobsImpl(null, fullModifiers, null, null, setResult),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items 
+        /// in the container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsSegmented(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<IListBlobItem>>(
+                (setResult) => this.ListBlobsImpl(null, fullModifiers, null, null, setResult),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items 
+        /// in the container.
+        /// </summary>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsSegmented(int maxResults, ResultContinuation continuationToken, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<IListBlobItem>>(
+                (setResult) => this.ListBlobsImpl(null, fullModifiers, continuationToken, maxResults, setResult),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of blob items 
+        /// in the container.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsSegmented(AsyncCallback callback, object state)
+        {
+            return this.BeginListBlobsSegmented(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of blob items 
+        /// in the container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsSegmented(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            return this.BeginListBlobsSegmented(0, null, options, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of blob items 
+        /// in the container.
+        /// </summary>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsSegmented(
+            int maxResults,
+            ResultContinuation continuationToken,
+            BlobRequestOptions options,
+            AsyncCallback callback,
+            object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<IListBlobItem>>(
+                (setResult) => this.ListBlobsImpl(null, fullModifiers, continuationToken, maxResults, setResult),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to return a result segment containing a collection of blob items 
+        /// in the container.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public ResultSegment<IListBlobItem> EndListBlobsSegmented(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<IListBlobItem>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Creates the container.
+        /// </summary>
+        public void Create()
+        {
+            this.Create(null);
+        }
+
+        /// <summary>
+        /// Creates the container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void Create(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(
+                () => this.CreateContainerImpl(fullModifiers),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a container.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreate(AsyncCallback callback, object state)
+        {
+            return this.BeginCreate(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreate(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(
+                () => this.CreateContainerImpl(fullModifiers),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to create a container.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndCreate(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Creates the container if it does not already exist.
+        /// </summary>
+        /// <returns><c>true</c> if the container did not already exist and was created; otherwise, <c>false</c>.</returns>
+        public bool CreateIfNotExist()
+        {
+            return this.CreateIfNotExist(null);
+        }
+
+        /// <summary>
+        /// Creates the container if it does not already exist.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns><c>true</c> if the container did not already exist and was created; otherwise <c>false</c>.</returns>
+        public bool CreateIfNotExist(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<bool>(
+                (setResult) => this.CreateContainerIfNotExistImpl(fullModifiers, setResult),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to create the container if it does not already exist.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateIfNotExist(AsyncCallback callback, object state)
+        {
+            return this.BeginCreateIfNotExist(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to create the container if it does not already exist.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateIfNotExist(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<bool>(
+                (setResult) => this.CreateContainerIfNotExistImpl(fullModifiers, setResult),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Returns the result of an asynchronous request to create the container if it does not already exist.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns><c>true</c> if the container did not already exist and was created; otherwise, <c>false</c>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public bool EndCreateIfNotExist(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<bool>(asyncResult);
+        }
+
+        /// <summary>
+        /// Deletes the container.
+        /// </summary>
+        public void Delete()
+        {
+            this.Delete(null);
+        }
+
+        /// <summary>
+        /// Deletes the container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void Delete(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.DeleteContainerImpl(fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete a container.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDelete(AsyncCallback callback, object state)
+        {
+            return this.BeginDelete(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete a container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDelete(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.DeleteContainerImpl(fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to delete a container.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndDelete(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Sets permissions for the container.
+        /// </summary>
+        /// <param name="permissions">The permissions to apply to the container.</param>
+        public void SetPermissions(BlobContainerPermissions permissions)
+        {
+            this.SetPermissions(permissions, null);
+        }
+
+        /// <summary>
+        /// Sets permissions for the container.
+        /// </summary>
+        /// <param name="permissions">The permissions to apply to the container.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void SetPermissions(BlobContainerPermissions permissions, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.SetPermissionsImpl(permissions, fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to set permissions for the container.
+        /// </summary>
+        /// <param name="permissions">The permissions to apply to the container.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetPermissions(BlobContainerPermissions permissions, AsyncCallback callback, object state)
+        {
+            return this.BeginSetPermissions(permissions, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to set permissions for the container.
+        /// </summary>
+        /// <param name="permissions">The permissions to apply to the container.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetPermissions(BlobContainerPermissions permissions, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(
+                () => this.SetPermissionsImpl(permissions, fullModifiers),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Returns the result of an asynchronous request to set permissions for the container.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndSetPermissions(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets the permissions settings for the container.
+        /// </summary>
+        /// <returns>The container's permissions.</returns>
+        public BlobContainerPermissions GetPermissions()
+        {
+            return this.GetPermissions(null);
+        }
+
+        /// <summary>
+        /// Gets the permissions settings for the container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>The container's permissions.</returns>
+        public BlobContainerPermissions GetPermissions(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<BlobContainerPermissions>(
+                (setResult) => this.GetPermissionsImpl(fullModifiers, setResult),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to get the permissions settings for the container.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetPermissions(AsyncCallback callback, object state)
+        {
+            return this.BeginGetPermissions(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to get the permissions settings for the container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetPermissions(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<BlobContainerPermissions>(
+                (setResult) => this.GetPermissionsImpl(fullModifiers, setResult),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Returns the asynchronous result of the request to get the permissions settings for the container.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>The container's permissions.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public BlobContainerPermissions EndGetPermissions(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<BlobContainerPermissions>(asyncResult);
+        }
+
+        /// <summary>
+        /// Retrieves the container's attributes.
+        /// </summary>
+        public void FetchAttributes()
+        {
+            this.FetchAttributes(null);
+        }
+
+        /// <summary>
+        /// Retrieves the container's attributes.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void FetchAttributes(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.FetchAttributesImpl(fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to retrieve the container's attributes.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginFetchAttributes(AsyncCallback callback, object state)
+        {
+            return this.BeginFetchAttributes(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to retrieve the container's attributes.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginFetchAttributes(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.FetchAttributesImpl(fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to retrieve the container's attributes.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndFetchAttributes(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Sets the container's user-defined metadata.
+        /// </summary>
+        public void SetMetadata()
+        {
+            this.SetMetadata(null);
+        }
+
+        /// <summary>
+        /// Sets the container's user-defined metadata.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void SetMetadata(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+            TaskImplHelper.ExecuteImplWithRetry(() => this.SetMetadataImpl(fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to set user-defined metadata on the container.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetMetadata(AsyncCallback callback, object state)
+        {
+            return this.BeginSetMetadata(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to set user-defined metadata on the container.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetMetadata(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.SetMetadataImpl(fullModifiers), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous request operation to set user-defined metadata on the container.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndSetMetadata(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Returns a shared access signature for the container.
+        /// </summary>
+        /// <param name="policy">The access policy for the shared access signature.</param>
+        /// <returns>A shared access signature.</returns>
+        public string GetSharedAccessSignature(SharedAccessPolicy policy)
+        {
+            return this.GetSharedAccessSignature(policy, null);
+        }
+
+        /// <summary>
+        /// Returns a shared access signature for the container.
+        /// </summary>
+        /// <param name="policy">The access policy for the shared access signature.</param>
+        /// <param name="groupPolicyIdentifier">A container-level access policy.</param>
+        /// <returns>A shared access signature.</returns>
+        public string GetSharedAccessSignature(SharedAccessPolicy policy, string groupPolicyIdentifier)
+        {
+            if (!this.ServiceClient.Credentials.CanSignRequest)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASWithoutAccountKey);
+                throw new InvalidOperationException(errorMessage);
+            }
+
+            string resourceName = this.GetSharedAccessCanonicalName();
+
+            string signature = SharedAccessSignatureHelper.GetSharedAccessSignatureHashImpl(policy, groupPolicyIdentifier, resourceName, this.ServiceClient);
+
+            // Future resource type changes from "c" => "container"
+            var builder = SharedAccessSignatureHelper.GetShareAccessSignatureImpl(policy, groupPolicyIdentifier, "c", signature);
+
+            return builder.ToString();
+        }
+
+        /// <summary>
+        /// Implementation for the ListBlobs method.
+        /// </summary>
+        /// <param name="prefix">The blob prefix.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="maxResults">The maximum result size.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that lists the blobs.</returns>
+        internal TaskSequence ListBlobsImpl(
+            string prefix,
+            BlobRequestOptions options,
+            ResultContinuation continuationToken,
+            int? maxResults,
+            Action<ResultSegment<IListBlobItem>> setResult)
+        {
+            ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
+
+            return this.ListBlobsImplCore(prefix, options, continuationToken, pagination, setResult);
+        }
+
+        /// <summary>
+        /// Converts the ACL string to a <see cref="BlobContainerPermissions"/> object.
+        /// </summary>
+        /// <param name="aclstring">The string to convert.</param>
+        /// <returns>The resulting <see cref="BlobContainerPermissions"/> object.</returns>
+        private static BlobContainerPermissions GetContainerAcl(string aclstring)
+        {
+            BlobContainerPublicAccessType accessType = BlobContainerPublicAccessType.Off;
+
+            if (!string.IsNullOrEmpty(aclstring))
+            {
+                switch (aclstring.ToLower())
+                {
+                    case "container":
+                        accessType = BlobContainerPublicAccessType.Container;
+                        break;
+                    case "blob":
+                        accessType = BlobContainerPublicAccessType.Blob;
+                        break;
+                    default:
+                        string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.InvalidAclType, aclstring);
+                        throw new InvalidOperationException(errorMessage);
+                }
+            }
+
+            return new BlobContainerPermissions()
+            {
+                PublicAccess = accessType
+            };
+        }
+
+        /// <summary>
+        /// Parse Uri for SAS (Shared access signature) information.
+        /// </summary>
+        /// <param name="completeUri">The complete Uri.</param>
+        /// <param name="existingClient">The client to use.</param>
+        /// <param name="usePathStyleUris">If true, path style Uris are used.</param>
+        /// <remarks>
+        /// Validate that no other query parameters are passed in.
+        /// Any SAS information will be recorded as corresponding credentials instance.
+        /// If existingClient is passed in, any SAS information found will not be supported.
+        /// Otherwise a new client is created based on SAS information or as anonymous credentials.
+        /// </remarks>
+        private void ParseQueryAndVerify(Uri completeUri, CloudBlobClient existingClient, bool? usePathStyleUris)
+        {
+            CommonUtils.AssertNotNull("completeUri", completeUri);
+
+            if (!completeUri.IsAbsoluteUri)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.RelativeAddressNotPermitted, completeUri.ToString());
+                throw new ArgumentException(errorMessage, "address");
+            }
+
+            this.Uri = new Uri(completeUri.GetLeftPart(UriPartial.Path));
+
+            StorageCredentialsSharedAccessSignature sasCreds;
+
+            var queryParameters = HttpUtility.ParseQueryString(completeUri.Query);
+            SharedAccessSignatureHelper.ParseQuery(queryParameters, out sasCreds);
+
+            if (existingClient != null)
+            {
+                if (sasCreds != null && existingClient.Credentials != null && sasCreds != existingClient.Credentials)
+                {
+                    string error = string.Format(CultureInfo.CurrentCulture, SR.MultipleCredentialsProvided);
+                    throw new ArgumentException(error);
+                }
+            }
+            else
+            {
+                this.ServiceClient = new CloudBlobClient(NavigationHelper.GetServiceClientBaseAddress(this.Uri.AbsoluteUri, usePathStyleUris), sasCreds);
+            }
+        }
+
+        /// <summary>
+        /// Returns the canonical name for shared access.
+        /// </summary>
+        /// <returns>The canonical name.</returns>
+        private string GetSharedAccessCanonicalName()
+        {
+            if (this.ServiceClient.UsePathStyleUris)
+            {
+                return this.Uri.AbsolutePath;
+            }
+            else
+            {
+                return NavigationHelper.GetCanonicalPathFromCreds(this.ServiceClient.Credentials, this.Uri.AbsolutePath);
+            }
+        }
+
+        /// <summary>
+        /// Gets the absolute Uri of the blob.
+        /// </summary>
+        /// <param name="blobName">Name of the blob.</param>
+        /// <returns>The blob's absolute Uri.</returns>
+        private string GetBlobAbsoluteUri(string blobName)
+        {
+            var blobUri = NavigationHelper.AppendPathToUri(this.Uri, blobName);
+            return blobUri.AbsoluteUri;
+        }
+
+        /// <summary>
+        /// Core implementation of the ListBlobs method.
+        /// </summary>
+        /// <param name="prefix">The blob prefix.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="pagination">The pagination.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that lists the blobs.</returns>
+        private TaskSequence ListBlobsImplCore(
+            string prefix,
+            BlobRequestOptions options,
+            ResultContinuation continuationToken,
+            ResultPagination pagination,
+            Action<ResultSegment<IListBlobItem>> setResult)
+        {
+            CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Blob);
+            CommonUtils.AssertNotNull("options", options);
+
+            if (!options.UseFlatBlobListing
+                && (options.BlobListingDetails & BlobListingDetails.Snapshots) == BlobListingDetails.Snapshots)
+            {
+                throw new ArgumentException(SR.ListSnapshotsWithDelimiterError, "options");
+            }
+
+            var delimiter = options.UseFlatBlobListing ? null : this.ServiceClient.DefaultDelimiter;
+
+            BlobListingContext listingContext = new BlobListingContext(prefix, pagination.GetNextRequestPageSize(), delimiter, options.BlobListingDetails)
+            {
+                Marker = continuationToken != null ? continuationToken.NextMarker : null
+            };
+
+            var blobList = new List<IListBlobItem>();
+
+            var request = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.List(this.TransformedAddress, timeout, listingContext));
+            this.ServiceClient.Credentials.SignRequest(request);
+            var listTask = request.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return listTask;
+
+            string nextMarker;
+            using (var response = listTask.Result as HttpWebResponse)
+            {
+                ListBlobsResponse listBlobResponse = BlobResponse.List(response);
+                blobList.AddRange(listBlobResponse.Blobs.Select(
+                    (item) => CloudBlobClient.SelectProtocolResponse(item, this.ServiceClient, this)));
+
+                nextMarker = listBlobResponse.NextMarker;
+            }
+
+            ResultContinuation newContinuationToken = new ResultContinuation() { NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Blob };
+
+            ResultSegment.CreateResultSegment(
+                setResult,
+                blobList,
+                newContinuationToken,
+                pagination,
+                options.RetryPolicy,
+                (paginationArg, continuationArg, resultSegmentArg) =>
+                    this.ListBlobsImplCore(prefix, options, continuationArg, paginationArg, resultSegmentArg));
+        }
+
+        /// <summary>
+        /// Implementation for the Create method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that creates the container.</returns>
+        private TaskSequence CreateContainerImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => ContainerRequest.Create(this.Uri, timeout));
+            ContainerRequest.AddMetadata(webRequest, this.Metadata);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                this.Attributes = ContainerResponse.GetAttributes(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the CreateIfNotExist method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that creates the container if it does not exist.</returns>
+        private TaskSequence CreateContainerIfNotExistImpl(BlobRequestOptions options, Action<bool> setResult)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var task = new InvokeTaskSequenceTask(() => this.CreateContainerImpl(options));
+            yield return task;
+
+            try
+            {
+                // Materialize exceptions
+                var scratch = task.Result;
+                setResult(true);
+            }
+            catch (StorageClientException e)
+            {
+                if (e.StatusCode == HttpStatusCode.Conflict && e.ExtendedErrorInformation.ErrorCode == StorageErrorCodeStrings.ContainerAlreadyExists)
+                {
+                    setResult(false);
+                }
+                else
+                {
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the Delete method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that deletes the container.</returns>
+        private TaskSequence DeleteContainerImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => ContainerRequest.Delete(this.TransformedAddress, timeout));
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the FetchAttributes method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that fetches the attributes.</returns>
+        private TaskSequence FetchAttributesImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => ContainerRequest.GetProperties(this.TransformedAddress, timeout));
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                this.Attributes = ContainerResponse.GetAttributes(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the SetMetadata method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that sets the metadata.</returns>
+        private TaskSequence SetMetadataImpl(BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => ContainerRequest.SetMetadata(this.TransformedAddress, timeout));
+            ContainerRequest.AddMetadata(webRequest, this.Metadata);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the SetPermissions method.
+        /// </summary>
+        /// <param name="acl">The permissions to set.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that sets the permissions.</returns>
+        private TaskSequence SetPermissionsImpl(BlobContainerPermissions acl, BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => ContainerRequest.SetAcl(this.TransformedAddress, timeout, acl.PublicAccess));
+
+            using (var memoryStream = new SmallBlockMemoryStream(Constants.DefaultBufferSize))
+            {
+                ContainerRequest.WriteSharedAccessIdentifiers(acl.SharedAccessPolicies, memoryStream);
+
+                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
+
+                CommonUtils.ApplyRequestOptimizations(webRequest, memoryStream.Length);
+
+                this.ServiceClient.Credentials.SignRequest(webRequest);
+
+                var requestStreamTask = webRequest.GetRequestStreamAsync();
+                yield return requestStreamTask;
+
+                using (var requestStream = requestStreamTask.Result)
+                {
+                    // Copy the data
+                    var copyTask = new InvokeTaskSequenceTask(() => { return memoryStream.WriteTo(requestStream); });
+                    yield return copyTask;
+
+                    // Materialize any exceptions
+                    var scratch = copyTask.Result;
+                }
+            }
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Implementation for the GetPermissions method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that gets the permissions.</returns>
+        private TaskSequence GetPermissionsImpl(BlobRequestOptions options, Action<BlobContainerPermissions> setResult)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => ContainerRequest.GetAcl(this.TransformedAddress, timeout));
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                string publicAccess = ContainerResponse.GetAcl(webResponse);
+                var containerAcl = GetContainerAcl(publicAccess);
+
+                // Materialize results so that we can close the response
+                AccessPolicyResponse policyResponse = new AccessPolicyResponse(webResponse.GetResponseStream());
+                foreach (var item in policyResponse.AccessIdentifiers)
+                {
+                    containerAcl.SharedAccessPolicies.Add(item.Key, item.Value);
+                }
+
+                setResult(containerAcl);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudBlobDirectory.cs b/microsoft-azure-api/StorageClient/CloudBlobDirectory.cs
new file mode 100644
index 0000000000000..b00a7bd81ba5d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudBlobDirectory.cs
@@ -0,0 +1,332 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudBlobDirectory.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudBlobDirectory class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Represents a virtual directory of blobs, designated by a delimiter character.
+    /// </summary>
+    public class CloudBlobDirectory : IListBlobItem
+    {
+        /// <summary>
+        /// Stores the parent directory.
+        /// </summary>
+        private CloudBlobDirectory parent;
+
+        /// <summary>
+        /// Stores the parent container.
+        /// </summary>
+        private CloudBlobContainer container;
+
+        /// <summary>
+        /// Stores the prefix this directory represents.
+        /// </summary>
+        private string prefix;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlobDirectory"/> class given an address and a client.
+        /// </summary>
+        /// <param name="address">The blob directory's address.</param>
+        /// <param name="service">The client to use.</param>
+        internal CloudBlobDirectory(string address, CloudBlobClient service)
+        {
+            CommonUtils.AssertNotNullOrEmpty("address", address);
+            CommonUtils.AssertNotNull("service", service);
+            
+            this.ServiceClient = service;
+            
+            if (!address.EndsWith(this.ServiceClient.DefaultDelimiter))
+            {
+                address = address + this.ServiceClient.DefaultDelimiter;
+            }
+
+            this.Uri = NavigationHelper.AppendPathToUri(service.BaseUri, address);            
+        }
+
+        /// <summary>
+        /// Gets the service client for the virtual directory.
+        /// </summary>
+        /// <value>A client object that specifies the endpoint for the Blob service.</value>
+        public CloudBlobClient ServiceClient { get; private set; }
+
+        /// <summary>
+        /// Gets the URI that identifies the virtual directory.
+        /// </summary>
+        /// <value>The URI to the virtual directory.</value>
+        public Uri Uri { get; private set; }
+
+        /// <summary>
+        /// Gets the container for the virtual directory.
+        /// </summary>
+        /// <value>The container for the virtual directory.</value>
+        public CloudBlobContainer Container
+        {
+            get
+            {
+                if (this.container == null)
+                {
+                    this.container = new CloudBlobContainer(
+                        NavigationHelper.GetContainerAddress(this.Uri, this.ServiceClient.UsePathStyleUris),
+                        this.ServiceClient.Credentials);
+                }
+
+                return this.container;
+            }
+        }
+
+        /// <summary>
+        /// Gets the parent directory for the virtual directory.
+        /// </summary>
+        /// <value>The virtual directory's parent directory.</value>
+        public CloudBlobDirectory Parent
+        {
+            get
+            {
+                if (this.parent == null)
+                {
+                    this.parent = new CloudBlobDirectory(
+                        NavigationHelper.GetParentAddress(
+                            this.Uri,
+                            this.ServiceClient.DefaultDelimiter,
+                            this.ServiceClient.UsePathStyleUris),
+                        this.ServiceClient);
+                }
+
+                return this.parent;
+            }
+        }
+
+        /// <summary>
+        /// Gets the prefix.
+        /// </summary>
+        /// <value>The prefix.</value>
+        internal string Prefix
+        {
+            get
+            {
+                if (this.prefix == null)
+                {
+                    this.InitializePrefix();
+                }
+
+                return this.prefix;
+            }
+        }
+
+        /// <summary>
+        /// Returns a reference to a blob in this virtual directory.
+        /// </summary>
+        /// <param name="itemName">The name of the blob.</param>
+        /// <returns>A reference to a blob.</returns>
+        public CloudBlob GetBlobReference(string itemName) 
+        {
+            return this.GetBlobReference(itemName, null);
+        }
+
+        /// <summary>
+        /// Returns a reference to a blob in this virtual directory.
+        /// </summary>
+        /// <param name="itemName">The name of the blob.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <returns>A reference to a blob.</returns>
+        public CloudBlob GetBlobReference(string itemName, DateTime? snapshotTime)
+        {
+            CommonUtils.AssertNotNull("itemName", itemName);
+
+            Uri blobUri = NavigationHelper.AppendPathToUri(this.Uri, itemName, this.ServiceClient.DefaultDelimiter);
+            return new CloudBlob(blobUri.AbsoluteUri, snapshotTime, this.ServiceClient);
+        }
+
+        /// <summary>
+        /// Returns a reference to a page blob in this virtual directory.
+        /// </summary>
+        /// <param name="itemName">The name of the page blob.</param>
+        /// <returns>A reference to a page blob.</returns>
+        public CloudPageBlob GetPageBlobReference(string itemName) 
+        {
+            return this.GetPageBlobReference(itemName, null);
+        }
+
+        /// <summary>
+        /// Returns a reference to a page blob in this virtual directory.
+        /// </summary>
+        /// <param name="itemName">The name of the page blob.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <returns>A reference to a page blob.</returns>
+        public CloudPageBlob GetPageBlobReference(string itemName, DateTime? snapshotTime)
+        {
+            CommonUtils.AssertNotNull("itemName", itemName);
+
+            Uri blobUri = NavigationHelper.AppendPathToUri(this.Uri, itemName, this.ServiceClient.DefaultDelimiter);
+            return new CloudPageBlob(blobUri.AbsoluteUri, snapshotTime, this.ServiceClient);
+        }
+
+        /// <summary>
+        /// Returns a reference to a block blob in this virtual directory.
+        /// </summary>
+        /// <param name="itemName">The name of the block blob.</param>
+        /// <returns>A reference to a block blob.</returns>
+        public CloudBlockBlob GetBlockBlobReference(string itemName) 
+        {
+            return this.GetBlockBlobReference(itemName, null);
+        }
+
+        /// <summary>
+        /// Returns a reference to a block blob in this virtual directory.
+        /// </summary>
+        /// <param name="itemName">The name of the block blob.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <returns>A reference to a block blob.</returns>
+        public CloudBlockBlob GetBlockBlobReference(string itemName, DateTime? snapshotTime)
+        {
+            CommonUtils.AssertNotNull("itemName", itemName);
+
+            Uri blobUri = NavigationHelper.AppendPathToUri(this.Uri, itemName, this.ServiceClient.DefaultDelimiter);
+            return new CloudBlockBlob(blobUri.AbsoluteUri, snapshotTime, this.ServiceClient);
+        }
+
+        /// <summary>
+        /// Returns a virtual subdirectory within this virtual directory.
+        /// </summary>
+        /// <param name="itemName">The name of the virtual subdirectory.</param>
+        /// <returns>A <see cref="CloudBlobDirectory"/> object representing the virtual subdirectory.</returns>
+        public CloudBlobDirectory GetSubdirectory(string itemName) 
+        {
+            CommonUtils.AssertNotNull("itemName", itemName);
+    
+            Uri subdirectoryUri = NavigationHelper.AppendPathToUri(this.Uri, itemName, this.ServiceClient.DefaultDelimiter);
+            return new CloudBlobDirectory(subdirectoryUri.AbsoluteUri, this.ServiceClient);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of blob items in this virtual directory that is lazily retrieved, either as a flat listing or by virtual subdirectory.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>An enumerable collection of objects that implement <see cref="IListBlobItem"/> and are retrieved lazily.</returns>
+        public IEnumerable<IListBlobItem> ListBlobs(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return CommonUtils.LazyEnumerateSegmented<IListBlobItem>((setResult) => this.Container.ListBlobsImpl(this.Prefix, fullModifiers, null, null, setResult), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of blob items in this virtual directory, either as a flat listing or by virtual subdirectory.
+        /// </summary>
+        /// <returns>An enumerable collection of objects that implement <see cref="IListBlobItem"/>.</returns>
+        public IEnumerable<IListBlobItem> ListBlobs()
+        {
+            return this.ListBlobs(null);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items. 
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsSegmented(BlobRequestOptions options)
+        {
+            return this.ListBlobsSegmented(0, null, options);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of blob items. 
+        /// </summary>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        public ResultSegment<IListBlobItem> ListBlobsSegmented(int maxResults, ResultContinuation continuationToken, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<IListBlobItem>>((setResult) => this.Container.ListBlobsImpl(this.Prefix, fullModifiers, continuationToken, maxResults, setResult), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to return a result segment containing a collection of blob items.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsSegmented(AsyncCallback callback, object state)
+        {
+            return this.BeginListBlobsSegmented(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to return a result segment containing a collection of blob items.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsSegmented(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            return this.BeginListBlobsSegmented(0, null, options, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to return a result segment containing a collection of blob items.
+        /// </summary>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListBlobsSegmented(int maxResults, ResultContinuation continuationToken, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<IListBlobItem>>((setResult) => this.Container.ListBlobsImpl(this.Prefix, fullModifiers, continuationToken, maxResults, setResult), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous request to return a result segment containing a collection of blob items.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A result segment containing objects that implement <see cref="IListBlobItem"/>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public ResultSegment<IListBlobItem> EndListBlobsSegmented(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<IListBlobItem>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Initializes the prefix.
+        /// </summary>
+        private void InitializePrefix()
+        {
+            // Need to add the trailing slash or MakeRelativeUri will return the containerName again
+            var parentUri = new Uri(this.Container.Uri + NavigationHelper.Slash);
+
+            this.prefix = Uri.UnescapeDataString(parentUri.MakeRelativeUri(this.Uri).OriginalString);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudBlockBlob.cs b/microsoft-azure-api/StorageClient/CloudBlockBlob.cs
new file mode 100644
index 0000000000000..564e8b44345bc
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudBlockBlob.cs
@@ -0,0 +1,517 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudBlockBlob.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudBlockBlob class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a blob that is uploaded as a set of blocks.
+    /// </summary>
+    public class CloudBlockBlob : CloudBlob
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using an absolute URI to the blob.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">The absolute URI to the blob.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudBlockBlob(string blobAbsoluteUri, StorageCredentials credentials)
+            : base(blobAbsoluteUri, credentials)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using a relative URI to the blob.
+        /// </summary>
+        /// <param name="blobUri">The relative URI to the blob, beginning with the container name.</param>
+        /// <param name="client">A client object that specifies the endpoint for the Blob service.</param>
+        public CloudBlockBlob(string blobUri, CloudBlobClient client)
+            : this(blobUri, null, client)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using a relative URI to the blob.
+        /// </summary>
+        /// <param name="blobUri">The relative URI to the blob, beginning with the container name.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="client">A client object that specifies the endpoint for the Blob service.</param>
+        public CloudBlockBlob(string blobUri, DateTime? snapshotTime, CloudBlobClient client)
+            : base(blobUri, snapshotTime, client)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using an absolute URI to the blob.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">The absolute URI to the blob.</param>
+        public CloudBlockBlob(string blobAbsoluteUri)
+            : base(blobAbsoluteUri)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using an absolute URI to the blob.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">The absolute URI to the blob.</param>
+        /// <param name="credentials">The account credentials.</param>
+        /// <param name="usePathStyleUris"><c>True</c> to use path-style URIs; otherwise, <c>false</c>.</param>
+        public CloudBlockBlob(string blobAbsoluteUri, StorageCredentials credentials, bool usePathStyleUris)
+            : base(blobAbsoluteUri, credentials, usePathStyleUris)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using an absolute URI to the blob.
+        /// </summary>
+        /// <param name="blobAbsoluteUri">The absolute URI to the blob.</param>
+        /// <param name="usePathStyleUris"><c>True</c> to use path-style URIs; otherwise, <c>false</c>.</param>
+        public CloudBlockBlob(string blobAbsoluteUri, bool usePathStyleUris)
+            : base(blobAbsoluteUri, usePathStyleUris)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class based on an existing blob.
+        /// </summary>
+        /// <param name="cloudBlob">The blob to clone.</param>
+        internal CloudBlockBlob(CloudBlob cloudBlob) : base(cloudBlob)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class.
+        /// </summary>
+        /// <param name="attributes">The attributes.</param>
+        /// <param name="serviceClient">The service client.</param>
+        /// <param name="snapshotTime">The snapshot time.</param>
+        internal CloudBlockBlob(BlobAttributes attributes, CloudBlobClient serviceClient, string snapshotTime)
+            : base(attributes, serviceClient, snapshotTime)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using the specified blob Uri.
+        /// Note that this is just a reference to a blob instance and no requests are issued to the service
+        /// yet to update the blob properties, attribute or metaddata. FetchAttributes is the API that 
+        /// issues such request to the service.
+        /// </summary>
+        /// <param name="blobUri">Relative Uri to the blob.</param>
+        /// <param name="client">Existing Blob service client which provides the base address.</param>
+        /// <param name="containerReference">The reference to the parent container.</param>
+        internal CloudBlockBlob(string blobUri, CloudBlobClient client, CloudBlobContainer containerReference)
+            : this(blobUri, null, client, containerReference)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudBlockBlob"/> class using the specified blob Uri.
+        /// If snapshotTime is not null, the blob instance represents a Snapshot.
+        /// Note that this is just a reference to a blob instance and no requests are issued to the service
+        /// yet to update the blob properties, attribute or metaddata. FetchAttributes is the API that 
+        /// issues such request to the service.
+        /// </summary>
+        /// <param name="blobUri">Relative Uri to the blob.</param>
+        /// <param name="snapshotTime">Snapshot time in case the blob is a snapshot.</param>
+        /// <param name="client">Existing Blob service client which provides the base address.</param>
+        /// <param name="containerReference">The reference to the parent container.</param>
+        internal CloudBlockBlob(string blobUri, DateTime? snapshotTime, CloudBlobClient client, CloudBlobContainer containerReference)
+            : base(blobUri, snapshotTime, client, containerReference)
+        {
+            this.Properties.BlobType = BlobType.BlockBlob;
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of the committed blocks comprising the blob.
+        /// </summary>
+        /// <returns>An enumerable collection of objects implementing <see cref="ListBlockItem"/>.</returns>
+        public IEnumerable<ListBlockItem> DownloadBlockList()
+        {
+            return this.DownloadBlockList(null);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of the committed blocks comprising the blob.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>An enumerable collection of objects implementing <see cref="ListBlockItem"/>.</returns>
+        public IEnumerable<ListBlockItem> DownloadBlockList(BlobRequestOptions options)
+        {
+            return this.DownloadBlockList(BlockListingFilter.Committed, options);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of the blob's blocks, using the specified block list filter.
+        /// </summary>
+        /// <param name="blockListingFilter">One of the enumeration values that indicates whether to return 
+        /// committed blocks, uncommitted blocks, or both.</param>
+        /// <returns>An enumerable collection of objects implementing <see cref="ListBlockItem"/>.</returns>
+        public IEnumerable<ListBlockItem> DownloadBlockList(BlockListingFilter blockListingFilter)
+        {
+            return this.DownloadBlockList(blockListingFilter, null);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of the blob's blocks, using the specified block list filter.
+        /// </summary>
+        /// <param name="blockListingFilter">One of the enumeration values that indicates whether to return 
+        /// committed blocks, uncommitted blocks, or both.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>An enumerable collection of objects implementing <see cref="ListBlockItem"/>.</returns>
+        public IEnumerable<ListBlockItem> DownloadBlockList(BlockListingFilter blockListingFilter, BlobRequestOptions options)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<IEnumerable<ListBlockItem>>(
+                (result) =>
+                    {
+                        return this.GetDownloadBlockList(blockListingFilter, fullModifier, result);
+                    },
+                fullModifier.RetryPolicy);
+        }
+        
+        /// <summary>
+        /// Begins an asynchronous operation to return an enumerable collection of the blob's blocks, 
+        /// using the specified block list filter.
+        /// </summary>
+        /// <param name="blockListingFilter">One of the enumeration values that indicates whether to return 
+        /// committed blocks, uncommitted blocks, or both.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDownloadBlockList(BlockListingFilter blockListingFilter, AsyncCallback callback, object state)
+        {
+            return this.BeginDownloadBlockList(blockListingFilter, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return an enumerable collection of the blob's blocks, 
+        /// using the specified block list filter.
+        /// </summary>
+        /// <param name="blockListingFilter">One of the enumeration values that indicates whether to return 
+        /// committed blocks, uncommitted blocks, or both.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDownloadBlockList(BlockListingFilter blockListingFilter, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<IEnumerable<ListBlockItem>>(
+                (result) =>
+                    {
+                        return this.GetDownloadBlockList(blockListingFilter, fullModifier, result);
+                    },
+                fullModifier.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to return an enumerable collection of the blob's blocks, 
+        /// using the specified block list filter.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>An enumerable collection of objects implementing <see cref="ListBlockItem"/>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public IEnumerable<ListBlockItem> EndDownloadBlockList(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<IEnumerable<ListBlockItem>>(asyncResult);
+        }
+        
+        /// <summary>
+        /// Uploads a single block.
+        /// </summary>
+        /// <param name="blockId">A base64-encoded block ID that identifies the block.</param>
+        /// <param name="blockData">A stream that provides the data for the block.</param>
+        /// <param name="contentMD5">An optional hash value that will be used to set the <see cref="BlobProperties.ContentMD5"/> property
+        /// on the blob. May be <c>null</c> or an empty string.</param>
+        public void PutBlock(string blockId, Stream blockData, string contentMD5)
+        {
+            this.PutBlock(blockId, blockData, contentMD5, null);
+        }
+
+        /// <summary>
+        /// Uploads a single block.
+        /// </summary>
+        /// <param name="blockId">A base64-encoded block ID that identifies the block.</param>
+        /// <param name="blockData">A stream that provides the data for the block.</param>
+        /// <param name="contentMD5">An optional hash value that will be used to set the <see cref="BlobProperties.ContentMD5"/> property
+        /// on the blob. May be <c>null</c> or an empty string.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void PutBlock(string blockId, Stream blockData, string contentMD5, BlobRequestOptions options)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+            var position = blockData.Position;
+            var retryPolicy = blockData.CanSeek ? fullModifier.RetryPolicy : RetryPolicies.NoRetry();
+
+            TaskImplHelper.ExecuteImplWithRetry(
+                () =>
+                    {
+                        if (blockData.CanSeek)
+                        {
+                            blockData.Position = position;
+                        }
+
+                        return this.UploadBlock(blockData, blockId, contentMD5, fullModifier);
+                    },
+                retryPolicy);
+        }
+        
+        /// <summary>
+        /// Begins an asynchronous operation to upload a single block.
+        /// </summary>
+        /// <param name="blockId">A base64-encoded block ID that identifies the block.</param>
+        /// <param name="blockData">A stream that provides the data for the block.</param>
+        /// <param name="contentMD5">An optional hash value that will be used to set the <see cref="BlobProperties.ContentMD5"/> property
+        /// on the blob. May be <c>null</c> or an empty string.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginPutBlock(string blockId, Stream blockData, string contentMD5, AsyncCallback callback, object state)
+        {
+            return this.BeginPutBlock(blockId, blockData, contentMD5, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to upload a single block.
+        /// </summary>
+        /// <param name="blockId">A base64-encoded block ID that identifies the block.</param>
+        /// <param name="blockData">A stream that provides the data for the block.</param>
+        /// <param name="contentMD5">An optional hash value that will be used to set the <see cref="BlobProperties.ContentMD5"/> property
+        /// on the blob. May be <c>null</c> or an empty string.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginPutBlock(string blockId, Stream blockData, string contentMD5, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+            var position = blockData.Position;
+            var retryPolicy = blockData.CanSeek ? fullModifier.RetryPolicy : RetryPolicies.NoRetry();
+
+            return TaskImplHelper.BeginImplWithRetry(
+                () =>
+                    {
+                        if (blockData.CanSeek)
+                        {
+                            blockData.Position = position;
+                        }
+
+                        return this.UploadBlock(blockData, blockId, contentMD5, fullModifier);
+                    },
+                retryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to upload a single block.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndPutBlock(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+        
+        /// <summary>
+        /// Uploads a list of blocks to a new or existing blob. 
+        /// </summary>
+        /// <param name="blockList">An enumerable collection of block IDs, as base64-encoded strings.</param>
+        public void PutBlockList(IEnumerable<string> blockList)
+        {
+            this.PutBlockList(blockList, null);
+        }
+
+        /// <summary>
+        /// Uploads a list of blocks to a new or existing blob. 
+        /// </summary>
+        /// <param name="blockList">An enumerable collection of block IDs, as base64-encoded strings.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void PutBlockList(IEnumerable<string> blockList, BlobRequestOptions options)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            List<PutBlockListItem> items = blockList.Select(i => { return new PutBlockListItem(i, BlockSearchMode.Latest); }).ToList();
+
+            TaskImplHelper.ExecuteImplWithRetry(() => { return this.UploadBlockList(items, fullModifier); }, fullModifier.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to upload a list of blocks to a new or existing blob. 
+        /// </summary>
+        /// <param name="blockList">An enumerable collection of block IDs, as base64-encoded strings.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginPutBlockList(IEnumerable<string> blockList, AsyncCallback callback, object state)
+        {
+            return this.BeginPutBlockList(blockList, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to upload a list of blocks to a new or existing blob. 
+        /// </summary>
+        /// <param name="blockList">An enumerable collection of block IDs, as base64-encoded strings.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginPutBlockList(IEnumerable<string> blockList, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifier = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            List<PutBlockListItem> items = blockList.Select(i => { return new PutBlockListItem(i, BlockSearchMode.Latest); }).ToList();
+
+            return TaskImplHelper.BeginImplWithRetry(() => { return this.UploadBlockList(items, fullModifier); }, fullModifier.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to upload a list of blocks to a new or existing blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndPutBlockList(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Uploads the block list.
+        /// </summary>
+        /// <param name="blocks">The blocks to upload.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the block list.</returns>
+        internal TaskSequence UploadBlockList(List<PutBlockListItem> blocks, BlobRequestOptions options)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException("modifers");
+            }
+
+            var request = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.PutBlockList(this.TransformedAddress, timeout, this.Properties, null));
+
+            options.AccessCondition.ApplyCondition(request);
+            BlobRequest.AddMetadata(request, this.Metadata);
+
+            using (var memoryStream = new SmallBlockMemoryStream(Constants.DefaultBufferSize))
+            {
+                BlobRequest.WriteBlockListBody(blocks, memoryStream);
+
+                CommonUtils.ApplyRequestOptimizations(request, memoryStream.Length);
+
+                memoryStream.Seek(0, SeekOrigin.Begin);
+
+                // Compute the MD5
+                var md5 = System.Security.Cryptography.MD5.Create();
+
+                request.Headers[HttpRequestHeader.ContentMd5] = Convert.ToBase64String(md5.ComputeHash(memoryStream));
+
+                this.ServiceClient.Credentials.SignRequest(request);
+
+                memoryStream.Seek(0, SeekOrigin.Begin);
+
+                // Retrieve the stream
+                var requestStreamTask = request.GetRequestStreamAsync();
+                yield return requestStreamTask;
+
+                using (Stream requestStream = requestStreamTask.Result)
+                {
+                    // Copy the data
+                    var copyTask = new InvokeTaskSequenceTask(() => { return memoryStream.WriteTo(requestStream); });
+                    yield return copyTask;
+
+                    // Materialize any exceptions
+                    var scratch = copyTask.Result;
+                }
+            }
+
+            // Get the response
+            var responseTask = request.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return responseTask;
+
+            using (var response = responseTask.Result as HttpWebResponse)
+            {
+                ParseSizeAndLastModified(response);
+                this.Properties.Length = 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets the download block list.
+        /// </summary>
+        /// <param name="typesOfBlocks">The types of blocks.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that gets the download block list.</returns>
+        internal TaskSequence GetDownloadBlockList(BlockListingFilter typesOfBlocks, BlobRequestOptions options, Action<IEnumerable<ListBlockItem>> setResult)
+        {
+            var request = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.GetBlockList(this.TransformedAddress, timeout, this.SnapshotTime, typesOfBlocks, null));
+            this.ServiceClient.Credentials.SignRequest(request);
+
+            // Retrieve the stream
+            var requestStreamTask = request.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return requestStreamTask;
+
+            // Copy the data
+            using (var response = requestStreamTask.Result as HttpWebResponse)
+            {
+                using (var responseStream = response.GetResponseStream())
+                {
+                    var blockListResponse = new GetBlockListResponse(responseStream);
+
+                    setResult(ParseResponse(blockListResponse));
+                }
+
+                this.ParseSizeAndLastModified(response);
+            }
+        }
+
+        /// <summary>
+        /// Parses the response.
+        /// </summary>
+        /// <param name="blockListResponse">The block list response.</param>
+        /// <returns>An enumerable list of <see cref="ListBlockItem"/> objects.</returns>
+        private static IEnumerable<ListBlockItem> ParseResponse(GetBlockListResponse blockListResponse)
+        {
+            List<ListBlockItem> result = new List<ListBlockItem>();
+
+            result.AddRange(blockListResponse.Blocks);
+
+            return result;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudPageBlob.cs b/microsoft-azure-api/StorageClient/CloudPageBlob.cs
new file mode 100644
index 0000000000000..3763d070a1100
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudPageBlob.cs
@@ -0,0 +1,788 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudPageBlob.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudPageBlob class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a blob made up of a collection of pages.
+    /// </summary>
+    public class CloudPageBlob : CloudBlob
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class using an absolute URI to the blob.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudPageBlob(string blobAddress, StorageCredentials credentials)
+            : base(blobAddress, credentials)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class using an absolute URI to the blob.
+        /// </summary>
+        /// <param name="blobAddress">The absolute URI to the blob.</param>
+        public CloudPageBlob(string blobAddress)
+            : base(blobAddress)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class using a relative URI to the blob.
+        /// </summary>
+        /// <param name="blobAddress">The relative URI to the blob, beginning with the container name.</param>
+        /// <param name="serviceClient">A client object that specifies the endpoint for the Blob service.</param>
+        public CloudPageBlob(string blobAddress, CloudBlobClient serviceClient) 
+            : this(blobAddress, null, serviceClient)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class using a relative URI to the blob.
+        /// </summary>
+        /// <param name="blobAddress">The relative URI to the blob, beginning with the container name.</param>
+        /// <param name="snapshotTime">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="serviceClient">A client object that specifies the endpoint for the Blob service.</param>
+        public CloudPageBlob(string blobAddress, DateTime? snapshotTime, CloudBlobClient serviceClient)
+            : base(blobAddress, snapshotTime, serviceClient)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class based on an existing <see cref="CloudBlob"/> object.
+        /// </summary>
+        /// <param name="cloudBlob">An object of type <see cref="CloudBlob"/>.</param>
+        public CloudPageBlob(CloudBlob cloudBlob)
+            : base(cloudBlob)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class.
+        /// </summary>
+        /// <param name="attributes">The attributes.</param>
+        /// <param name="serviceClient">The service client.</param>
+        /// <param name="snapshotTime">The snapshot time.</param>
+        internal CloudPageBlob(BlobAttributes attributes, CloudBlobClient serviceClient, string snapshotTime)
+            : base(attributes, serviceClient, snapshotTime)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class.
+        /// </summary>
+        /// <param name="blobAddress">The blob address.</param>
+        /// <param name="credentials">The credentials.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c>, use path style Uris.</param>
+        internal CloudPageBlob(string blobAddress, StorageCredentials credentials, bool usePathStyleUris)
+            : base(blobAddress, credentials, usePathStyleUris)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class.
+        /// </summary>
+        /// <param name="blobAddress">The blob address.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c>, use path style Uris.</param>
+        internal CloudPageBlob(string blobAddress, bool usePathStyleUris)
+            : base(blobAddress, usePathStyleUris)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class using the specified blob Uri.
+        /// Note that this is just a reference to a blob instance and no requests are issued to the service
+        /// yet to update the blob properties, attribute or metaddata. FetchAttributes is the API that 
+        /// issues such request to the service.
+        /// </summary>
+        /// <param name="blobAddress">The blob address.</param>
+        /// <param name="serviceClient">The service client.</param>
+        /// <param name="containerReference">The reference to the parent container.</param>
+        internal CloudPageBlob(string blobAddress, CloudBlobClient serviceClient, CloudBlobContainer containerReference)
+            : this(blobAddress, null, serviceClient, containerReference)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudPageBlob"/> class using the specified blob Uri.
+        /// If snapshotTime is not null, the blob instance represents a Snapshot.
+        /// Note that this is just a reference to a blob instance and no requests are issued to the service
+        /// yet to update the blob properties, attribute or metaddata. FetchAttributes is the API that 
+        /// issues such request to the service.
+        /// </summary>
+        /// <param name="blobAddress">The blob address.</param>
+        /// <param name="snapshotTime">Snapshot time in case the blob is a snapshot.</param>
+        /// <param name="serviceClient">The service client.</param>
+        /// <param name="containerReference">The reference to the parent container.</param>
+        internal CloudPageBlob(string blobAddress, DateTime? snapshotTime, CloudBlobClient serviceClient, CloudBlobContainer containerReference)
+            : base(blobAddress, snapshotTime, serviceClient, containerReference)
+        {
+            this.Properties.BlobType = BlobType.PageBlob;
+        }
+
+        /// <summary>
+        /// Creates a page blob.
+        /// </summary>
+        /// <param name="size">The maximum size of the page blob, in bytes.</param>
+        public void Create(long size)
+        {
+            this.Create(size, null);
+        }
+
+        /// <summary>
+        /// Creates a page blob.
+        /// </summary>
+        /// <param name="size">The maximum size of the page blob, in bytes.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void Create(long size, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.CreateImpl(fullModifiers, size), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a page blob.
+        /// </summary>
+        /// <param name="size">The maximum size of the page blob, in bytes.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreate(long size, AsyncCallback callback, object state)
+        {
+            return this.BeginCreate(size, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a page blob.
+        /// </summary>
+        /// <param name="size">The maximum size of the blob, in bytes.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreate(long size, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.CreateImpl(fullModifiers, size), fullModifiers.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to create a page blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndCreate(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Writes pages to a page blob.
+        /// </summary>
+        /// <param name="pageData">A stream providing the page data.</param>
+        /// <param name="startOffset">The offset at which to begin writing, in bytes. The offset must be a multiple of 512.</param>
+        public void WritePages(Stream pageData, long startOffset)
+        {
+            this.WritePages(pageData, startOffset, null);
+        }
+
+        /// <summary>
+        /// Writes pages to a page blob.
+        /// </summary>
+        /// <param name="pageData">A stream providing the page data.</param>
+        /// <param name="startOffset">The offset at which to begin writing, in bytes. The offset must be a multiple of 512.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void WritePages(Stream pageData, long startOffset, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            long sourcePosition = pageData.CanSeek ? pageData.Position : 0;
+
+            TaskImplHelper.ExecuteImplWithRetry(
+                () =>
+            {
+                if (pageData.CanSeek == false)
+                {
+                    sourcePosition--;
+                }
+
+                return this.WritePageImpl(pageData, startOffset, sourcePosition, fullModifiers);
+            },
+            fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to write pages to a page blob.
+        /// </summary>
+        /// <param name="pageData">A stream providing the page data.</param>
+        /// <param name="startOffset">The offset at which to begin writing, in bytes. The offset must be a multiple of 512.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginWritePages(Stream pageData, long startOffset, AsyncCallback callback, object state)
+        {
+            return this.BeginWritePages(pageData, startOffset, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to write pages to a page blob.
+        /// </summary>
+        /// <param name="pageData">A stream providing the page data.</param>
+        /// <param name="startOffset">The offset at which to begin writing, in bytes. The offset must be a multiple of 512.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginWritePages(Stream pageData, long startOffset, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            long sourcePosition = pageData.CanSeek ? pageData.Position : 0;
+
+            return TaskImplHelper.BeginImplWithRetry(
+                () =>
+                {
+                    if (pageData.CanSeek == false)
+                    {
+                        sourcePosition--;
+                    }
+
+                    return this.WritePageImpl(pageData, startOffset, sourcePosition, fullModifiers);
+                },
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to write pages to a page blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndWritePages(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Clears pages from a page blob.
+        /// </summary>
+        /// <param name="startOffset">The offset at which to begin clearing pages, in bytes. The offset must be a multiple of 512.</param>
+        /// <param name="length">The length of the data range to be cleared, in bytes. The length must be a multiple of 512.</param>
+        public void ClearPages(long startOffset, long length)
+        {
+            this.ClearPages(startOffset, length, null);
+        }
+
+        /// <summary>
+        /// Clears pages from a page blob.
+        /// </summary>
+        /// <param name="startOffset">The offset at which to begin clearing pages, in bytes. The offset must be a multiple of 512.</param>
+        /// <param name="length">The length of the data range to be cleared, in bytes. The length must be a multiple of 512.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        public void ClearPages(long startOffset, long length, BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            TaskImplHelper.ExecuteImplWithRetry(() => this.ClearPageImpl(startOffset, length, fullModifiers), fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to clear pages from a page blob.
+        /// </summary>
+        /// <param name="startOffset">The offset at which to begin clearing pages, in bytes. The offset must be a multiple of 512.</param>
+        /// <param name="length">The length of the data range to be cleared, in bytes. The length must be a multiple of 512.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginClearPages(long startOffset, long length, AsyncCallback callback, object state)
+        {
+            return this.BeginClearPages(startOffset, length, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to clear pages from a page blob.
+        /// </summary>
+        /// <param name="startOffset">The offset at which to begin clearing pages, in bytes. The offset must be a multiple of 512.</param>
+        /// <param name="length">The length of the data range to be cleared, in bytes. The length must be a multiple of 512.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginClearPages(long startOffset, long length, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry(
+                () => this.ClearPageImpl(startOffset, length, fullModifiers),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to clear pages from a page blob.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndClearPages(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets a collection of page ranges and their starting and ending bytes.
+        /// </summary>
+        /// <returns>An enumerable collection of page ranges.</returns>
+        public IEnumerable<PageRange> GetPageRanges()
+        {
+            return this.GetPageRanges(null);
+        }
+
+        /// <summary>
+        /// Gets a collection of page ranges and their starting and ending bytes.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>An enumerable collection of page ranges.</returns>
+        public IEnumerable<PageRange> GetPageRanges(BlobRequestOptions options)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.ExecuteImplWithRetry<IEnumerable<PageRange>>(
+                (setResult) => this.GetPageRangesImpl(fullModifiers, setResult),
+                fullModifiers.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a collection of page ranges and their starting and ending bytes.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetPageRanges(AsyncCallback callback, object state)
+        {
+            return this.BeginGetPageRanges(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a collection of page ranges and their starting and ending bytes.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetPageRanges(BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            var fullModifiers = BlobRequestOptions.CreateFullModifier(this.ServiceClient, options);
+
+            return TaskImplHelper.BeginImplWithRetry<IEnumerable<PageRange>>(
+                (setResult) => this.GetPageRangesImpl(fullModifiers, setResult),
+                fullModifiers.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to return a collection of page ranges and their starting and ending bytes.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>An enumerable collection of page ranges.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public IEnumerable<PageRange> EndGetPageRanges(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<IEnumerable<PageRange>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Opens a stream for writing to the blob.
+        /// </summary>
+        /// <returns>A stream for writing to the blob.</returns>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override BlobStream OpenWrite()
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Opens a stream for writing to the blob.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A stream for writing to the blob.</returns>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override BlobStream OpenWrite(BlobRequestOptions options)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads a blob from a stream.
+        /// </summary>
+        /// <param name="source">A stream that provides the blob content.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadFromStream(Stream source)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads a blob from a stream.
+        /// </summary>
+        /// <param name="source">A stream that provides the blob content.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadFromStream(Stream source, BlobRequestOptions options)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to upload a blob from a stream.
+        /// </summary>
+        /// <param name="source">The data stream to upload.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override IAsyncResult BeginUploadFromStream(Stream source, AsyncCallback callback, object state)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to upload a blob from a stream.
+        /// </summary>
+        /// <param name="source">The data stream to upload.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override IAsyncResult BeginUploadFromStream(Stream source, BlobRequestOptions options, AsyncCallback callback, object state)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to upload a blob from a stream.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void EndUploadFromStream(IAsyncResult asyncResult)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads a string of text to a blob.
+        /// </summary>
+        /// <param name="content">The text to upload, encoded as a UTF-8 string.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadText(string content)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads a string of text to a blob.
+        /// </summary>
+        /// <param name="content">The text to upload.</param>
+        /// <param name="encoding">An object indicating the text encoding to use.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadText(string content, Encoding encoding, BlobRequestOptions options)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads a file from the file system to a blob.
+        /// </summary>
+        /// <param name="fileName">The path and file name of the file to upload.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadFile(string fileName)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads a file from the file system to a blob.
+        /// </summary>
+        /// <param name="fileName">The path and file name of the file to upload.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadFile(string fileName, BlobRequestOptions options)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads an array of bytes to a blob.
+        /// </summary>
+        /// <param name="content">The array of bytes to upload.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadByteArray(byte[] content)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Uploads an array of bytes to a blob.
+        /// </summary>
+        /// <param name="content">The array of bytes to upload.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <exception cref="NotSupportedException">This operation is not supported on objects of type <see cref="CloudPageBlob"/>.</exception>
+        public override void UploadByteArray(byte[] content, BlobRequestOptions options)
+        {
+            throw ThisCreationMethodNotSupportedException();
+        }
+
+        /// <summary>
+        /// Creates an exception reporting that the creation method is not supported.
+        /// </summary>
+        /// <returns>The created exception.</returns>
+        private static NotSupportedException ThisCreationMethodNotSupportedException()
+        {
+            string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.NotSupportedForPageBlob);
+            return new NotSupportedException(errorMessage);
+        }
+
+        /// <summary>
+        /// Implements the Create method.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="sizeInBytes">The size in bytes.</param>
+        /// <returns>A <see cref="TaskSequence"/> that creates the blob.</returns>
+        private TaskSequence CreateImpl(BlobRequestOptions options, long sizeInBytes)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            this.Properties.BlobType = BlobType.PageBlob;
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.Put(this.TransformedAddress, timeout, this.Properties, BlobType.PageBlob, null, sizeInBytes));
+
+            BlobRequest.AddMetadata(webRequest, this.Metadata);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+
+            yield return task;
+
+            // Parse the response
+            using (HttpWebResponse webResponse = task.Result as HttpWebResponse)
+            {
+                this.ParseSizeAndLastModified(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Gets the page ranges impl.
+        /// </summary>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> for getting the page ranges.</returns>
+        private TaskSequence GetPageRangesImpl(BlobRequestOptions options, Action<IEnumerable<PageRange>> setResult)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            var webRequest = ProtocolHelper.GetWebRequest(this.ServiceClient, options, (timeout) => BlobRequest.GetPageRanges(this.TransformedAddress, timeout, this.SnapshotTime, null));
+            BlobRequest.AddMetadata(webRequest, this.Metadata);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                var getPageRangesResponse = BlobResponse.GetPageRanges(webResponse);
+                List<PageRange> pageRanges = new List<PageRange>();
+
+                // materialize response as we need to close the webResponse
+                pageRanges.AddRange(getPageRangesResponse.PageRanges.ToList());
+
+                setResult(pageRanges);
+
+                this.ParseSizeAndLastModified(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Implementation method for the WritePage methods.
+        /// </summary>
+        /// <param name="pageData">The page data.</param>
+        /// <param name="startOffset">The start offset.</param> 
+        /// <param name="sourceStreamPosition">The beginning position of the source stream prior to execution, negative if stream is unseekable.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that writes the pages.</returns>
+        private TaskSequence WritePageImpl(Stream pageData, long startOffset, long sourceStreamPosition, BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            long length = pageData.Length;
+
+            // Logic to rewind stream on a retry
+            // For non seekable streams we need a way to detect the retry iteration so as to only attempt to execute once.
+            // The first attempt will have SourceStreamPosition = -1, which means the first iteration on a non seekable stream.
+            // The second attempt will have SourceStreamPosition = -2, anything below -1 is considered an abort. Since the Impl method
+            // does not have an execution context to be aware of what iteration is used the SourceStreamPosition is utilized as counter to
+            // differentiate between the first attempt and a retry.
+            if (sourceStreamPosition >= 0 && pageData.CanSeek)
+            {
+                if (sourceStreamPosition != pageData.Position)
+                {
+                    pageData.Seek(sourceStreamPosition, 0);
+                }
+            }
+            else if (sourceStreamPosition < -1)
+            {
+                throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, SR.CannotRetryNonSeekableStreamError));
+            }
+
+            if (startOffset % Protocol.Constants.PageSize != 0)
+            {
+                CommonUtils.ArgumentOutOfRange("startOffset", startOffset);
+            }
+            
+            long rangeStreamOffset = pageData.CanSeek ? pageData.Position : 0;
+
+            PutPageProperties properties = new PutPageProperties()
+            {
+                Range = new PageRange(startOffset, startOffset + length - rangeStreamOffset - 1),
+                PageWrite = PageWrite.Update,
+            };
+
+            if ((1 + properties.Range.EndOffset - properties.Range.StartOffset) % Protocol.Constants.PageSize != 0 ||
+                (1 + properties.Range.EndOffset - properties.Range.StartOffset) == 0)
+            {
+                CommonUtils.ArgumentOutOfRange("pageData", pageData);
+            }
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.PutPage(this.TransformedAddress, timeout, properties, null));
+
+            ////BlobRequest.AddMetadata(webRequest, this.Metadata);
+
+            // Retrieve the stream
+            var requestStreamTask = webRequest.GetRequestStreamAsync();
+            yield return requestStreamTask;
+
+            // Copy the data
+            using (var outputStream = requestStreamTask.Result)
+            {
+                var copyTask = new InvokeTaskSequenceTask(() => { return pageData.WriteTo(outputStream); });
+                yield return copyTask;
+
+                // Materialize any exceptions
+                var scratch = copyTask.Result;
+            }
+
+            // signing request needs Size to be set
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            // Get the response
+            var responseTask = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return responseTask;
+
+            // Parse the response
+            using (HttpWebResponse webResponse = responseTask.Result as HttpWebResponse)
+            {
+                this.ParseSizeAndLastModified(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Implementation method for the ClearPage methods.
+        /// </summary>
+        /// <param name="startOffset">The start offset. Must be multiples of 512.</param>
+        /// <param name="length">Length of the data range to be cleared. Must be multiples of 512.</param>
+        /// <param name="options">An object that specifies any additional options for the request.</param>
+        /// <returns>A <see cref="TaskSequence"/> that writes the pages.</returns>
+        private TaskSequence ClearPageImpl(long startOffset, long length, BlobRequestOptions options)
+        {
+            CommonUtils.AssertNotNull("options", options);
+
+            if (startOffset < 0 || startOffset % Protocol.Constants.PageSize != 0)
+            {
+                CommonUtils.ArgumentOutOfRange("startOffset", startOffset);
+            }
+
+            if (length <= 0 || length % Protocol.Constants.PageSize != 0)
+            {
+                CommonUtils.ArgumentOutOfRange("length", length);
+            }
+
+            PutPageProperties properties = new PutPageProperties()
+            {
+                Range = new PageRange(startOffset, startOffset + length - 1),
+                PageWrite = PageWrite.Clear,
+            };
+
+            var webRequest = ProtocolHelper.GetWebRequest(
+                this.ServiceClient,
+                options,
+                (timeout) => BlobRequest.PutPage(this.TransformedAddress, timeout, properties, null));
+
+            webRequest.ContentLength = 0;
+
+            // signing request needs Size to be set
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            // Get the response
+            var responseTask = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, options.Timeout);
+            yield return responseTask;
+
+            // Parse the response
+            using (HttpWebResponse webResponse = responseTask.Result as HttpWebResponse)
+            {
+                this.ParseSizeAndLastModified(webResponse);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudQueue.cs b/microsoft-azure-api/StorageClient/CloudQueue.cs
new file mode 100644
index 0000000000000..70a55e846699e
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudQueue.cs
@@ -0,0 +1,1411 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudQueue.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudQueue class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a Windows Azure queue.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.Naming",
+        "CA1711:IdentifiersShouldNotHaveIncorrectSuffix",
+        Justification = "This is a queue")]
+    public class CloudQueue
+    {
+        /// <summary>
+        /// Stores the queue attributes.
+        /// </summary>
+        private readonly QueueAttributes attributes;
+
+        /// <summary>
+        /// Uri for the messages.
+        /// </summary>
+        private Uri messageRequestAddress;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueue"/> class.
+        /// </summary>
+        /// <param name="address">The absolute URI to the queue.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudQueue(string address, StorageCredentials credentials)
+            : this(null, address, credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueue"/> class.
+        /// </summary>
+        /// <param name="address">The relative address.</param>
+        /// <param name="credentials">The storage account credentials.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c>, use path style Uris.</param>
+        internal CloudQueue(string address, StorageCredentials credentials, bool usePathStyleUris)
+            : this(usePathStyleUris, address, credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueue"/> class.
+        /// </summary>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <param name="address">The address.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal CloudQueue(bool? usePathStyleUris, string address, StorageCredentials credentials)
+        {
+            CommonUtils.AssertNotNullOrEmpty("address", address);
+            CommonUtils.AssertNotNull("credentials", credentials);
+
+            if (!credentials.CanSignRequest)
+            {
+                throw new ArgumentException(SR.CredentialsCantSignRequest, "credentials");
+            }
+
+            this.EncodeMessage = true;
+            this.attributes = new QueueAttributes() { Uri = new Uri(address) };
+
+            string baseAddress = NavigationHelper.GetServiceClientBaseAddress(this.Uri, usePathStyleUris);
+
+            this.ServiceClient = new CloudQueueClient(baseAddress, credentials);
+            this.Name = NavigationHelper.GetQueueNameFromUri(this.Uri, this.ServiceClient.UsePathStyleUris);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueue"/> class.
+        /// </summary>
+        /// <param name="queueAddress">The queue address.</param>
+        /// <param name="client">The client.</param>
+        internal CloudQueue(Uri queueAddress, CloudQueueClient client)
+        {
+            CommonUtils.AssertNotNull("queueAddress", queueAddress);
+            CommonUtils.AssertNotNull("client", client);
+
+            this.EncodeMessage = true;
+            this.attributes = new QueueAttributes() { Uri = queueAddress };
+            this.ServiceClient = client;
+
+            this.Name = NavigationHelper.GetQueueNameFromUri(this.Uri, this.ServiceClient.UsePathStyleUris);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueue"/> class.
+        /// </summary>
+        /// <param name="attributes">The attributes of the queue.</param>
+        /// <param name="client">The client.</param>
+        internal CloudQueue(QueueAttributes attributes, CloudQueueClient client)
+        {
+            CommonUtils.AssertNotNull("attributes", attributes);
+            CommonUtils.AssertNotNull("client", client);
+
+            this.EncodeMessage = true;
+            this.attributes = attributes;
+            this.ServiceClient = client;
+
+            this.Name = NavigationHelper.GetQueueNameFromUri(this.Uri, this.ServiceClient.UsePathStyleUris);
+        }
+
+        /// <summary>
+        /// Gets the <see cref="CloudQueueClient"/> object that represents the Queue service.
+        /// </summary>
+        /// <value>A client object that specifies the Queue service endpoint.</value>
+        public CloudQueueClient ServiceClient { get; private set; }
+
+        /// <summary>
+        /// Gets the queue name.
+        /// </summary>
+        /// <value>The queue name.</value>
+        public string Name { get; private set; }
+
+        /// <summary>
+        /// Gets the URI that identifies the queue.
+        /// </summary>
+        /// <value>The address of the queue.</value>
+        public Uri Uri
+        {
+            get
+            {
+                return this.attributes.Uri;
+            }
+        }
+
+        /// <summary>
+        /// Gets the queue's attributes.
+        /// </summary>
+        /// <value>The queue's attributes.</value>
+        public QueueAttributes Attributes
+        {
+            get
+            {
+                return this.attributes;
+            }
+        }
+
+        /// <summary>
+        /// Gets the queue's user-defined metadata.
+        /// </summary>
+        /// <value>The queue's user-defined metadata.</value>
+        public NameValueCollection Metadata
+        {
+            get
+            {
+                return this.attributes.Metadata;
+            }
+
+            internal set
+            {
+                this.attributes.Metadata = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the approximate message count for the queue.
+        /// </summary>
+        /// <value>The approximate message count.</value>
+        public int? ApproximateMessageCount { get; private set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to apply base64 encoding when adding or retrieving messages.
+        /// </summary>
+        /// <value><c>True</c> to encode messages; otherwise, <c>false</c>. The default value is <c>true</c>.</value>
+        public bool EncodeMessage { get; set; }
+
+        /// <summary>
+        /// Gets the Uri for general message operations.
+        /// </summary>
+        internal Uri MessageRequestAddress
+        {
+            get
+            {
+                if (this.messageRequestAddress == null)
+                {
+                    this.messageRequestAddress = NavigationHelper.AppendPathToUri(this.Uri, Constants.Messages);
+                }
+
+                return this.messageRequestAddress;
+            }
+        }
+
+        /// <summary>
+        /// Creates a queue.
+        /// </summary>
+        public void Create()
+        {
+            TaskImplHelper.ExecuteImplWithRetry(this.CreateImpl, this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a queue.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreate(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(this.CreateImpl, this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to create a queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndCreate(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Creates the queue if it does not exist.
+        /// </summary>
+        /// <returns><c>true</c> if the queue did not exist and was created; otherwise <c>false</c>.</returns>
+        public bool CreateIfNotExist()
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<bool>(
+                (setResult) => this.CreateIfNotExistImpl(setResult),
+                this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create the queue if it does not exist.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateIfNotExist(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<bool>(
+                (setResult) => this.CreateIfNotExistImpl(setResult),
+                this.ServiceClient.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to create the queue if it does not exist.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>Returns <c>true</c> if the creation succeeded; otherwise, <c>false</c>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public bool EndCreateIfNotExist(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<bool>(asyncResult);
+        }
+
+        /// <summary>
+        /// Deletes the queue.
+        /// </summary>
+        public void Delete()
+        {
+            TaskImplHelper.ExecuteImplWithRetry(this.DeleteImpl, this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete the queue. 
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDelete(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(this.DeleteImpl, this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to delete the queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation")]
+        public void EndDelete(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Determines if the queue exists.
+        /// </summary>
+        /// <returns><c>True</c> if the queue exists; otherwise <c>false</c>.</returns>
+        public bool Exists()
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<bool>(this.ExistsImpl, this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to determine whether the queue exists.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginExists(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<bool>(this.ExistsImpl, this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to determine whether the queue exists.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>Returns <c>true</c> if the queue exists; otherwise, <c>false</c>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public bool EndExists(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<bool>(asyncResult);
+        }
+
+        /// <summary>
+        /// Fetches the queue's attributes.
+        /// </summary>
+        public void FetchAttributes()
+        {
+            TaskImplHelper.ExecuteImplWithRetry(this.FetchAttributesImpl, this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to fetch the queue's attributes.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginFetchAttributes(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(this.FetchAttributesImpl, this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to fetch the queue's attributes.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndFetchAttributes(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Sets the queue's metadata.
+        /// </summary>
+        public void SetMetadata()
+        {
+            TaskImplHelper.ExecuteImplWithRetry(this.SetMetadataImpl, this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to set the queue's metadata.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetMetadata(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(this.SetMetadataImpl, this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to set the queue's metadata.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndSetMetadata(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Retrieves the approximate message count for the queue. This method fetches
+        /// the value from the server and updates the <see cref="ApproximateMessageCount"/>
+        /// property as well.
+        /// </summary>
+        /// <returns>The approximate message count.</returns>
+        public int RetrieveApproximateMessageCount()
+        {
+            this.FetchAttributes();
+
+            return this.ApproximateMessageCount.Value;
+        }
+
+        /// <summary>
+        /// Adds a message to the queue.
+        /// </summary>
+        /// <param name="message">The message to add.</param>
+        public void AddMessage(CloudQueueMessage message)
+        {
+            CommonUtils.AssertNotNull("message", message);
+            TaskImplHelper.ExecuteImplWithRetry(() => this.AddMessageImpl(message, null, null), this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Adds a message to the queue.
+        /// </summary>
+        /// <param name="message">The message to add.</param>
+        /// <param name="timeToLive">The maximum time to allow the message to be in the queue.</param>
+        public void AddMessage(CloudQueueMessage message, TimeSpan timeToLive)
+        {
+            CommonUtils.AssertNotNull("message", message);
+            TaskImplHelper.ExecuteImplWithRetry(() => this.AddMessageImpl(message, timeToLive, null), this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Adds a message to the queue.
+        /// </summary>
+        /// <param name="message">The message to add.</param>
+        /// <param name="timeToLive">The maximum time to allow the message to be in the queue, or null.</param>
+        /// <param name="initialVisibilityDelay">The length of time from now during which the message will be invisible.
+        /// If null then the message will be visible immediately.</param>
+        public void AddMessage(CloudQueueMessage message, TimeSpan? timeToLive, TimeSpan? initialVisibilityDelay)
+        {
+            CommonUtils.AssertNotNull("message", message);
+            TaskImplHelper.ExecuteImplWithRetry(() => this.AddMessageImpl(message, timeToLive, initialVisibilityDelay), this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to add a message to the queue.
+        /// </summary>
+        /// <param name="message">The message to add.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginAddMessage(CloudQueueMessage message, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("message", message);
+            return TaskImplHelper.BeginImplWithRetry(() => this.AddMessageImpl(message, null, null), this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to add a message to the queue.
+        /// </summary>
+        /// <param name="message">The message to add.</param>
+        /// <param name="timeToLive">The maximum time to allow the message to be in the queue.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginAddMessage(CloudQueueMessage message, TimeSpan timeToLive, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("message", message);
+            return TaskImplHelper.BeginImplWithRetry(() => this.AddMessageImpl(message, timeToLive, null), this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to add a message to the queue.
+        /// </summary>
+        /// <param name="message">The message to add.</param>
+        /// <param name="timeToLive">The maximum time to allow the message to be in the queue, or null.</param>
+        /// <param name="initialVisibilityDelay">The length of time from now during which the message will be invisible.
+        /// If null then the message will be visible immediately.</param>        
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginAddMessage(CloudQueueMessage message, TimeSpan? timeToLive, TimeSpan? initialVisibilityDelay, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("message", message);
+            return TaskImplHelper.BeginImplWithRetry(() => this.AddMessageImpl(message, timeToLive, initialVisibilityDelay), this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to add a message to the queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndAddMessage(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets a list of messages from the queue.
+        /// </summary>
+        /// <param name="messageCount">The number of messages to retrieve.</param>
+        /// <returns>An enumerable collection of messages.</returns>
+        public IEnumerable<CloudQueueMessage> GetMessages(int messageCount)
+        {
+            return this.GetMessagesInternal(messageCount, null);
+        }
+
+        /// <summary>
+        /// Gets a list of messages from the queue.
+        /// </summary>
+        /// <param name="messageCount">The number of messages to retrieve.</param>
+        /// <param name="visibilityTimeout">The visibility timeout interval.</param>
+        /// <returns>An enumerable collection of messages.</returns>
+        public IEnumerable<CloudQueueMessage> GetMessages(int messageCount, TimeSpan visibilityTimeout)
+        {
+            return this.GetMessagesInternal(messageCount, visibilityTimeout);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to get messages from the queue.
+        /// </summary>
+        /// <param name="messageCount">The number of messages to retrieve.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetMessages(int messageCount, AsyncCallback callback, object state)
+        {
+            return this.BeginGetMessagesInternal(messageCount, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to get messages from the queue.
+        /// </summary>
+        /// <param name="messageCount">The number of messages to retrieve.</param>
+        /// <param name="visibilityTimeout">The visibility timeout interval.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetMessages(int messageCount, TimeSpan visibilityTimeout, AsyncCallback callback, object state)
+        {
+            return this.BeginGetMessagesInternal(messageCount, visibilityTimeout, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to get messages from the queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>An enumerable collection of messages.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public IEnumerable<CloudQueueMessage> EndGetMessages(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<IEnumerable<CloudQueueMessage>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets a single message from the queue.
+        /// </summary>
+        /// <returns>A message.</returns>
+        public CloudQueueMessage GetMessage()
+        {
+            return this.GetMessageInternal(null);
+        }
+
+        /// <summary>
+        /// Gets a single message from the queue.
+        /// </summary>
+        /// <param name="visibilityTimeout">The visibility timeout interval.</param>
+        /// <returns>A message.</returns>
+        public CloudQueueMessage GetMessage(TimeSpan visibilityTimeout)
+        {
+            return this.GetMessageInternal(visibilityTimeout);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to get a single message from the queue.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetMessage(AsyncCallback callback, object state)
+        {
+            return this.BeginGetMessagesInternal(1, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to get a single message from the queue.
+        /// </summary>
+        /// <param name="visibilityTimeout">The visibility timeout interval.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetMessage(TimeSpan visibilityTimeout, AsyncCallback callback, object state)
+        {
+            return this.BeginGetMessagesInternal(1, visibilityTimeout, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to get a single message from the queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A message.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public CloudQueueMessage EndGetMessage(IAsyncResult asyncResult)
+        {
+            var resultList = TaskImplHelper.EndImplWithRetry<IEnumerable<CloudQueueMessage>>(asyncResult);
+
+            return resultList.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Peeks a message from the queue.
+        /// </summary>
+        /// <returns>A message.</returns>
+        public CloudQueueMessage PeekMessage()
+        {
+            IEnumerable<CloudQueueMessage> peekedMessages = TaskImplHelper.ExecuteImplWithRetry<IEnumerable<CloudQueueMessage>>(
+                (setResult) => this.PeekMessagesImpl(1, setResult),
+                this.ServiceClient.RetryPolicy);
+
+            return peekedMessages.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to peek a message from the queue.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginPeekMessage(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<IEnumerable<CloudQueueMessage>>(
+                (setResult) => this.PeekMessagesImpl(1, setResult),
+                this.ServiceClient.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to peek a message from the queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A message.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public CloudQueueMessage EndPeekMessage(IAsyncResult asyncResult)
+        {
+            var resultList = TaskImplHelper.EndImplWithRetry<IEnumerable<CloudQueueMessage>>(asyncResult);
+            return resultList.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Peeks a set of messages from the queue.
+        /// </summary>
+        /// <param name="messageCount">The number of messages to retrieve.</param>
+        /// <returns>A enumerable collection of messages.</returns>
+        public IEnumerable<CloudQueueMessage> PeekMessages(int messageCount)
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<IEnumerable<CloudQueueMessage>>(
+                (setResult) => this.PeekMessagesImpl(messageCount, setResult),
+                this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to peek a set of messages from the queue.
+        /// </summary>
+        /// <param name="messageCount">The number of messages to retrieve.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginPeekMessages(int messageCount, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<IEnumerable<CloudQueueMessage>>(
+                (setResult) => this.PeekMessagesImpl(messageCount, setResult),
+                this.ServiceClient.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to peek a set of messages from the queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>An enumerable collection of messages.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public IEnumerable<CloudQueueMessage> EndPeekMessages(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<IEnumerable<CloudQueueMessage>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Deletes a message.
+        /// </summary>
+        /// <param name="message">A message.</param>
+        public void DeleteMessage(CloudQueueMessage message)
+        {
+            CommonUtils.AssertNotNull("message", message);
+
+            TaskImplHelper.ExecuteImplWithRetry(
+                () => this.DeleteMessageImpl(message.Id, message.PopReceipt),
+                this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Deletes a message.
+        /// </summary>
+        /// <param name="messageId">The message ID.</param>
+        /// <param name="popReceipt">The pop receipt value.</param>
+        public void DeleteMessage(string messageId, string popReceipt)
+        {
+            TaskImplHelper.ExecuteImplWithRetry(() => this.DeleteMessageImpl(messageId, popReceipt), this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete a message.
+        /// </summary>
+        /// <param name="message">A message.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDeleteMessage(CloudQueueMessage message, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("message", message);
+
+            return TaskImplHelper.BeginImplWithRetry(
+                () => this.DeleteMessageImpl(message.Id, message.PopReceipt),
+                this.ServiceClient.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete a message.
+        /// </summary>
+        /// <param name="messageId">The message ID.</param>
+        /// <param name="popReceipt">The pop receipt value.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDeleteMessage(string messageId, string popReceipt, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(
+                () => this.DeleteMessageImpl(messageId, popReceipt),
+                this.ServiceClient.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to delete a message.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndDeleteMessage(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Updates the visibility timeout and optionally the content of a message.
+        /// </summary>
+        /// <param name="message">The message to update.</param>
+        /// <param name="visibilityTimeout">The length of time from now during which the message will be invisible.</param>
+        /// <param name="updateFields">Flags indicating which parts of the message are to be updated. This must include the Visibility flag.</param>
+        public void UpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields)
+        {
+            TaskImplHelper.ExecuteImplWithRetry(
+                () => this.UpdateMessageImpl(message, visibilityTimeout, updateFields),
+                this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to update the visibility timeout and optionally the content of a message.
+        /// </summary>
+        /// <param name="message">The message to update.</param>
+        /// <param name="visibilityTimeout">The length of time from now during which the message will be invisible.</param>
+        /// <param name="updateFields">Flags indicating which parts of the message are to be updated. This must include the Visibility flag.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginUpdateMessage(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFields, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(
+                () => this.UpdateMessageImpl(message, visibilityTimeout, updateFields),
+                this.ServiceClient.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to update the visibility timeout and possibly the contents of a message.
+        /// </summary>
+        /// <param name="asyncResult">The <c>IAsyncResult</c> returned from a prior call to <see cref="BeginUpdateMessage"/>.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndUpdateMessage(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Clears all messages from the queue.
+        /// </summary>
+        public void Clear()
+        {
+            TaskImplHelper.ExecuteImplWithRetry(this.ClearMessagesImpl, this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to clear all messages from the queue.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginClear(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(this.ClearMessagesImpl, this.ServiceClient.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to clear all messages from the queue.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndClear(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets the individual message address.
+        /// </summary>
+        /// <param name="messageId">The message id.</param>
+        /// <returns>The Uri of the message.</returns>
+        internal Uri GetIndividualMessageAddress(string messageId)
+        {
+            Uri individualMessageUri = NavigationHelper.AppendPathToUri(this.Uri, Constants.Messages + NavigationHelper.Slash + messageId);
+            return individualMessageUri;
+        }
+
+        /// <summary>
+        /// Materialize results so that we can close the response object.
+        /// </summary>
+        /// <param name="protocolList">List of response objects from the Protocol layer.</param>
+        /// <param name="responseProjector">Projection function.</param>
+        /// <returns>A materialized list of messages.</returns>
+        private static IEnumerable<CloudQueueMessage> MaterializeAndParseResponse(IEnumerable<QueueMessage> protocolList, Func<QueueMessage, CloudQueueMessage> responseProjector)
+        {
+            List<CloudQueueMessage> messages = new List<CloudQueueMessage>();
+            messages.AddRange(protocolList.Select(responseProjector));
+            return messages;
+        }
+
+        /// <summary>
+        /// Selects the get message response.
+        /// </summary>
+        /// <param name="protocolMessage">The protocol message.</param>
+        /// <returns>The parsed message.</returns>
+        private CloudQueueMessage SelectGetMessageResponse(QueueMessage protocolMessage)
+        {
+            var message = this.SelectPeekMessageResponse(protocolMessage);
+            message.PopReceipt = protocolMessage.PopReceipt;
+
+            if (protocolMessage.TimeNextVisible.HasValue)
+            {
+                message.NextVisibleTime = protocolMessage.TimeNextVisible.Value;
+            }
+
+            return message;
+        }
+
+        /// <summary>
+        /// Selects the peek message response.
+        /// </summary>
+        /// <param name="protocolMessage">The protocol message.</param>
+        /// <returns>The parsed message.</returns>
+        private CloudQueueMessage SelectPeekMessageResponse(QueueMessage protocolMessage)
+        {
+            CloudQueueMessage message = null;
+            if (this.EncodeMessage)
+            {
+                // if EncodeMessage is true, we assume the string returned from server is Base64 encoding of original message;
+                // if this is not true, exception will likely be thrown.
+                // it is user's responsibility to make sure EncodeMessage setting matches the queue that is being read.
+                message = new CloudQueueMessage(protocolMessage.Text, true);
+            }
+            else
+            {
+                message = new CloudQueueMessage(protocolMessage.Text);
+            }
+
+            message.Id = protocolMessage.Id;
+            message.InsertionTime = protocolMessage.InsertionTime;
+            message.ExpirationTime = protocolMessage.ExpirationTime;
+            message.DequeueCount = protocolMessage.DequeueCount;
+
+            // PopReceipt and TimeNextVisible are not returned during peek
+            return message;
+        }
+
+        /// <summary>
+        /// Gets the message internal.
+        /// </summary>
+        /// <param name="visibilityTimeout">The visibility timeout.</param>
+        /// <returns>The retrieved message.</returns>
+        private CloudQueueMessage GetMessageInternal(TimeSpan? visibilityTimeout)
+        {
+            IEnumerable<CloudQueueMessage> messages = this.GetMessagesInternal(1, visibilityTimeout);
+
+            return messages.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets the messages internal.
+        /// </summary>
+        /// <param name="numberOfMessages">The number of messages.</param>
+        /// <param name="visibilityTimeout">The visibility timeout.</param>
+        /// <returns>A list of retrieved messages.</returns>
+        private IEnumerable<CloudQueueMessage> GetMessagesInternal(int? numberOfMessages, TimeSpan? visibilityTimeout)
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<IEnumerable<CloudQueueMessage>>(
+               (setResult) => this.GetMessagesImpl(numberOfMessages, visibilityTimeout, setResult),
+               this.ServiceClient.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins the get messages internal.
+        /// </summary>
+        /// <param name="numberOfMesages">The number of mesages.</param>
+        /// <param name="visibilityTimeout">The visibility timeout.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An asynchronous result that represents the operation.</returns>
+        private IAsyncResult BeginGetMessagesInternal(int? numberOfMesages, TimeSpan? visibilityTimeout, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<IEnumerable<CloudQueueMessage>>(
+                (setResult) => this.GetMessagesImpl(numberOfMesages, visibilityTimeout, setResult),
+                this.ServiceClient.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Existses the impl.
+        /// </summary>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that detects whether the queue exists.</returns>
+        private TaskSequence ExistsImpl(Action<bool> setResult)
+        {
+            var webRequest = QueueRequest.GetMetadata(this.Uri, this.ServiceClient.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            try
+            {
+                // Materialize exceptions
+                using (var webResponse = task.Result as HttpWebResponse)
+                {
+                    setResult(true);
+                }
+            }
+            catch (StorageClientException e)
+            {
+                if (e.StatusCode == HttpStatusCode.NotFound)
+                {
+                    setResult(false);
+                }
+                else
+                {
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sets the metadata impl.
+        /// </summary>
+        /// <returns>A <see cref="TaskSequence"/> that sets the metadata.</returns>
+        private TaskSequence SetMetadataImpl()
+        {
+            var webRequest = QueueRequest.SetMetadata(this.Uri, this.ServiceClient.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            QueueRequest.AddMetadata(webRequest, this.Metadata);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Fetches the metadata and properties impl.
+        /// </summary>
+        /// <returns>A <see cref="TaskSequence"/> that fetches the attributes.</returns>
+        private TaskSequence FetchAttributesImpl()
+        {
+            var webRequest = QueueRequest.GetMetadata(this.Uri, this.ServiceClient.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                this.GetPropertiesAndMetadataFromResponse(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Creates the impl.
+        /// </summary>
+        /// <returns>A <see cref="TaskSequence"/> that creates the queue.</returns>
+        private TaskSequence CreateImpl()
+        {
+            var webRequest = QueueRequest.Create(this.Uri, this.ServiceClient.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            QueueRequest.AddMetadata(webRequest, this.Metadata);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Creates if not exist impl.
+        /// </summary>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that creates the queue if it doesn't exist.</returns>
+        private TaskSequence CreateIfNotExistImpl(Action<bool> setResult)
+        {
+            var webRequest = QueueRequest.Create(this.Uri, this.ServiceClient.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            QueueRequest.AddMetadata(webRequest, this.Metadata);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            try
+            {
+                // Materialize exceptions
+                using (var webResponse = task.Result as HttpWebResponse)
+                {
+                    if (webResponse.StatusCode != HttpStatusCode.NoContent)
+                    {
+                        setResult(true);
+
+                        this.GetPropertiesAndMetadataFromResponse(webResponse);
+                    }
+                    else
+                    {
+                        setResult(false);
+                    }
+                }
+            }
+            catch (StorageClientException e)
+            {
+                if (e.StatusCode == HttpStatusCode.Conflict && e.ExtendedErrorInformation.ErrorCode == QueueErrorCodeStrings.QueueAlreadyExists)
+                {
+                    setResult(false);
+                }
+                else
+                {
+                    throw;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Deletes the impl.
+        /// </summary>
+        /// <returns>A <see cref="TaskSequence"/> that deletes the queue.</returns>
+        private TaskSequence DeleteImpl()
+        {
+            var webRequest = QueueRequest.Delete(this.Uri, this.ServiceClient.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Clears the messages impl.
+        /// </summary>
+        /// <returns>A <see cref="TaskSequence"/> that clears the messages in the queue.</returns>
+        private TaskSequence ClearMessagesImpl()
+        {
+            var webRequest = QueueRequest.ClearMessages(this.MessageRequestAddress, this.ServiceClient.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Generates a task sequence for adding a message to the queue.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="timeToLive">The time to live.</param>
+        /// <param name="initialVisibilityDelay">The initial visibility delay.</param>
+        /// <returns>A <see cref="TaskSequence"/> that adds the message.</returns>
+        private TaskSequence AddMessageImpl(CloudQueueMessage message, TimeSpan? timeToLive, TimeSpan? initialVisibilityDelay)
+        {
+            int? timeToLiveInSec = null;
+            int? initialVisibilityDelayInSec = null;
+
+            if (timeToLive != null)
+            {
+                CommonUtils.AssertInBounds<TimeSpan>("timeToLive", timeToLive.Value, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
+                timeToLiveInSec = (int)timeToLive.Value.TotalSeconds;
+            }
+
+            if (initialVisibilityDelay != null)
+            {
+                CommonUtils.AssertInBounds<TimeSpan>("initialVisibilityDelay", initialVisibilityDelay.Value, TimeSpan.Zero, timeToLive ?? CloudQueueMessage.MaxTimeToLive);
+                initialVisibilityDelayInSec = (int)initialVisibilityDelay.Value.TotalSeconds;
+            }
+
+            CommonUtils.AssertNotNull("message", message);
+            CommonUtils.AssertNotNull("MessageContent", message.AsBytes);
+
+            HttpWebRequest webRequest = QueueRequest.PutMessage(this.MessageRequestAddress, this.ServiceClient.Timeout.RoundUpToSeconds(), timeToLiveInSec, initialVisibilityDelayInSec);
+            
+            byte[] requestBody = QueueRequest.GenerateMessageRequestBody(this.GenerateMessageContentsForRequest(message));
+            CommonUtils.ApplyRequestOptimizations(webRequest, requestBody.Length);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+
+            var requestTask = webRequest.GetRequestStreamAsync();
+            yield return requestTask;
+
+            using (var requestStream = requestTask.Result)
+            {
+                var writeTask = requestStream.WriteAsync(requestBody, 0, requestBody.Length);
+                yield return writeTask;
+                var scratch = writeTask.Result;
+            }
+
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Generates a suitable string for representing the content of a message in the body of a web request.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <returns>A string appropriately encoded depending on the format of the message and the EncodeMessage property.</returns>
+        private string GenerateMessageContentsForRequest(CloudQueueMessage message)
+        {
+            // when EncodeMessage is false, it is not allowed to upload a CloudQueueMessage that has been created with a byte array
+            // even if the byte array is the UTF8 encoding of a text string.
+            if (!this.EncodeMessage && message.MessageType == QueueMessageType.Base64Encoded)
+            {
+                throw new ArgumentException(SR.BinaryMessageShouldUseBase64Encoding);
+            }
+
+            string outgoingMessageString = null;
+            if (message.MessageType == QueueMessageType.RawString)
+            {
+                if (this.EncodeMessage)
+                {
+                    outgoingMessageString = Convert.ToBase64String(message.AsBytes);
+
+                    // the size of Base64 encoded string is the number of bytes this message will take up on server.
+                    if (outgoingMessageString.Length > CloudQueueMessage.MaxMessageSize)
+                    {
+                        throw new ArgumentException(string.Format(
+                            CultureInfo.InvariantCulture,
+                            SR.MessageTooLarge,
+                            CloudQueueMessage.MaxMessageSize));
+                    }
+                }
+                else
+                {
+                    outgoingMessageString = message.RawString;
+
+                    // we need to calculate the size of its UTF8 byte array, as that will be the storage usage on server.
+                    if (Encoding.UTF8.GetBytes(outgoingMessageString).Length > CloudQueueMessage.MaxMessageSize)
+                    {
+                        throw new ArgumentException(string.Format(
+                            CultureInfo.InvariantCulture,
+                            SR.MessageTooLarge,
+                            CloudQueueMessage.MaxMessageSize));
+                    }
+                }
+            }
+            else
+            {
+                // at this point, this.EncodeMessage must be true
+                outgoingMessageString = message.RawString;
+
+                // the size of Base64 encoded string is the number of bytes this message will take up on server.
+                if (outgoingMessageString.Length > CloudQueueMessage.MaxMessageSize)
+                {
+                    throw new ArgumentException(string.Format(
+                        CultureInfo.InvariantCulture,
+                        SR.MessageTooLarge,
+                        CloudQueueMessage.MaxMessageSize));
+                }
+            }
+
+            return outgoingMessageString;
+        }
+
+        /// <summary>
+        /// Peeks the messages impl.
+        /// </summary>
+        /// <param name="numberOfMessages">The number of messages.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that returns the peeked messages.</returns>
+        private TaskSequence PeekMessagesImpl(int? numberOfMessages, Action<IEnumerable<CloudQueueMessage>> setResult)
+        {
+            if (numberOfMessages.HasValue)
+            {
+                CommonUtils.AssertInBounds("numberOfMessages", numberOfMessages.Value, 0, CloudQueueMessage.MaxNumberOfMessagesToPeek);
+            }
+
+            var webRequest = QueueRequest.PeekMessages(this.MessageRequestAddress, this.ServiceClient.Timeout.RoundUpToSeconds(), numberOfMessages);
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                var parsedResponse = QueueResponse.PeekMessages(webResponse);
+                setResult(MaterializeAndParseResponse(parsedResponse.Messages, this.SelectGetMessageResponse));
+            }
+        }
+
+        /// <summary>
+        /// Deletes the message impl.
+        /// </summary>
+        /// <param name="messageId">The message id.</param>
+        /// <param name="popReceipt">The pop receipt value.</param>
+        /// <returns>A <see cref="TaskSequence"/> that deletes the message.</returns>
+        private TaskSequence DeleteMessageImpl(string messageId, string popReceipt)
+        {
+            CommonUtils.AssertNotNullOrEmpty("messageId", messageId);
+            CommonUtils.AssertNotNullOrEmpty("popReceipt", popReceipt);
+
+            Uri messageUri = this.GetIndividualMessageAddress(messageId);
+
+            var webRequest = QueueRequest.DeleteMessage(messageUri, this.ServiceClient.Timeout.RoundUpToSeconds(), popReceipt);
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+            }
+        }
+
+        /// <summary>
+        /// Generates a task sequence for updating a message in the queue.
+        /// </summary>
+        /// <param name="message">The message.</param>
+        /// <param name="visibilityTimeout">The visibility timeout.</param>
+        /// <param name="updateFlags">The flags controlling which parts of the message to update. Must include Visibility.</param>
+        /// <returns>A <see cref="TaskSequence"/> that updates the message.</returns>
+        private TaskSequence UpdateMessageImpl(CloudQueueMessage message, TimeSpan visibilityTimeout, MessageUpdateFields updateFlags)
+        {
+            CommonUtils.AssertNotNull("message", message);
+            CommonUtils.AssertNotNullOrEmpty("messageId", message.Id);
+            CommonUtils.AssertNotNullOrEmpty("popReceipt", message.PopReceipt);
+            CommonUtils.AssertInBounds<TimeSpan>("visibilityTimeout", visibilityTimeout, TimeSpan.Zero, CloudQueueMessage.MaxTimeToLive);
+            
+            if ((updateFlags & MessageUpdateFields.Visibility) == 0)
+            {
+                throw new ArgumentException("Calls to UpdateMessage must include the Visibility flag.", "updateFlags");
+            }
+
+            Uri messageUri = this.GetIndividualMessageAddress(message.Id);
+
+            HttpWebRequest webRequest = QueueRequest.UpdateMessage(messageUri, this.ServiceClient.Timeout.RoundUpToSeconds(), message.PopReceipt, (int)visibilityTimeout.TotalSeconds);
+
+            if ((updateFlags & MessageUpdateFields.Content) != 0)
+            {
+                byte[] requestBody = QueueRequest.GenerateMessageRequestBody(this.GenerateMessageContentsForRequest(message));
+                CommonUtils.ApplyRequestOptimizations(webRequest, requestBody.Length);
+                this.ServiceClient.Credentials.SignRequest(webRequest);
+
+                Task<Stream> requestTask = webRequest.GetRequestStreamAsync();
+                yield return requestTask;
+
+                using (Stream requestStream = requestTask.Result)
+                {
+                    Task<NullTaskReturn> writeTask = requestStream.WriteAsync(requestBody, 0, requestBody.Length);
+                    yield return writeTask;
+                    NullTaskReturn scratch = writeTask.Result;
+                }
+            }
+            else
+            {
+                CommonUtils.ApplyRequestOptimizations(webRequest, 0);
+                this.ServiceClient.Credentials.SignRequest(webRequest);
+            }
+
+            Task<WebResponse> task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (HttpWebResponse webResponse = task.Result as HttpWebResponse)
+            {
+                // Update the message pop receipt and next visible time
+                message.PopReceipt = QueueResponse.GetPopReceipt(webResponse);
+                message.NextVisibleTime = QueueResponse.GetNextVisibleTime(webResponse);
+            }
+        }
+
+        /// <summary>
+        /// Gets the messages impl.
+        /// </summary>
+        /// <param name="numberOfMessages">The number of messages.</param>
+        /// <param name="visibilityTimeout">The visibility timeout.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that gets the message.</returns>
+        private TaskSequence GetMessagesImpl(int? numberOfMessages, TimeSpan? visibilityTimeout, Action<IEnumerable<CloudQueueMessage>> setResult)
+        {
+            if (visibilityTimeout.HasValue)
+            {
+                CommonUtils.AssertInBounds("visibiliyTimeout", visibilityTimeout.Value, TimeSpan.Zero, TimeSpan.MaxValue);
+            }
+
+            if (numberOfMessages.HasValue)
+            {
+                CommonUtils.AssertInBounds("numberOfMessage", numberOfMessages.Value, 0, int.MaxValue);
+            }
+
+            int? visibilityTimeoutInSec = visibilityTimeout != null ? visibilityTimeout.RoundUpToSeconds() : (int?)null;
+
+            var webRequest = QueueRequest.GetMessages(this.MessageRequestAddress, this.ServiceClient.Timeout.RoundUpToSeconds(), numberOfMessages, visibilityTimeoutInSec);
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+            this.ServiceClient.Credentials.SignRequest(webRequest);
+            var task = webRequest.GetResponseAsyncWithTimeout(this.ServiceClient, this.ServiceClient.Timeout);
+            yield return task;
+
+            using (var webResponse = task.Result as HttpWebResponse)
+            {
+                var parsedResponse = QueueResponse.GetMessages(webResponse);
+                setResult(MaterializeAndParseResponse(parsedResponse.Messages, this.SelectGetMessageResponse));
+            }
+        }
+
+        /// <summary>
+        /// Gets the properties and metadata from response.
+        /// </summary>
+        /// <param name="webResponse">The web response.</param>
+        private void GetPropertiesAndMetadataFromResponse(HttpWebResponse webResponse)
+        {
+            this.Metadata = QueueResponse.GetMetadata(webResponse);
+
+            string count = QueueResponse.GetApproximateMessageCount(webResponse);
+            this.ApproximateMessageCount = string.IsNullOrEmpty(count) ? (int?)null : int.Parse(count);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudQueueClient.cs b/microsoft-azure-api/StorageClient/CloudQueueClient.cs
new file mode 100644
index 0000000000000..e3f7d64fd882e
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudQueueClient.cs
@@ -0,0 +1,561 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudQueueClient.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudQueueClient class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Provides a client for accessing the Windows Azure Queue service.
+    /// </summary>
+    public class CloudQueueClient
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueClient"/> class using the specified
+        /// Queue service endpoint and account credentials.
+        /// </summary>
+        /// <param name="baseAddress">The Queue service endpoint to use to create the client.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudQueueClient(string baseAddress, StorageCredentials credentials)
+            : this(new Uri(baseAddress), credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueClient"/> class using the specified
+        /// Queue service endpoint and account credentials.
+        /// </summary>
+        /// <param name="baseAddressUri">The Queue service endpoint to use to create the client.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudQueueClient(Uri baseAddressUri, StorageCredentials credentials)
+            : this(null, baseAddressUri, credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueClient"/> class.
+        /// </summary>
+        /// <param name="baseAddress">The base address.</param>
+        /// <param name="credentials">The credentials.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> [use path style Uris].</param>
+        internal CloudQueueClient(string baseAddress, StorageCredentials credentials, bool usePathStyleUris)
+            : this(usePathStyleUris, new Uri(baseAddress), credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueClient"/> class.
+        /// </summary>
+        /// <param name="baseAddressUri">The base address Uri.</param>
+        /// <param name="credentials">The credentials.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> [use path style Uris].</param>
+        internal CloudQueueClient(Uri baseAddressUri, StorageCredentials credentials, bool usePathStyleUris)
+            : this(usePathStyleUris, baseAddressUri, credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueClient"/> class.
+        /// </summary>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <param name="baseAddressUri">The base address Uri.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal CloudQueueClient(bool? usePathStyleUris, Uri baseAddressUri, StorageCredentials credentials)
+        {
+            CommonUtils.AssertNotNull("baseAddress", baseAddressUri);
+            CommonUtils.AssertNotNull("credentials", credentials);
+
+            if (!credentials.CanSignRequest)
+            {
+                throw new ArgumentException(SR.CredentialsCantSignRequest, "credentials");
+            }
+
+            this.BaseUri = baseAddressUri;
+
+            if (!this.BaseUri.IsAbsoluteUri)
+            {
+                CommonUtils.ArgumentOutOfRange("baseAddress", baseAddressUri);
+            }
+            
+            this.Timeout = Constants.DefaultClientSideTimeout;
+            this.RetryPolicy = RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultClientBackoff);
+            this.Credentials = credentials;
+       
+            if (usePathStyleUris.HasValue)
+            {
+                this.UsePathStyleUris = usePathStyleUris.Value;
+            }
+            else
+            {
+                // Automatically decide whether to use host style uri or path style uri
+                this.UsePathStyleUris = CommonUtils.UsePathStyleAddressing(this.BaseUri);
+            }
+        }
+        
+        /// <summary>
+        /// Occurs when a response is received from the server.
+        /// </summary>
+        public event EventHandler<ResponseReceivedEventArgs> ResponseReceived;
+
+        /// <summary>
+        /// Gets or sets the default retry policy for requests made via the Queue service client.
+        /// </summary>
+        /// <value>The retry policy.</value>
+        public RetryPolicy RetryPolicy { get; set; }
+
+        /// <summary>
+        /// Gets or sets the server timeout for requests made via the Queue service client.
+        /// </summary>
+        /// <value>The server timeout interval.</value>
+        public TimeSpan Timeout { get; set; }
+
+        /// <summary>
+        /// Gets or sets the lifetime of the approximate message count cache. Obsolete.
+        /// </summary>
+        /// <value>The lifetime of the approximate message count cache.</value>
+        /// <remarks>The approximate message count is not cached. This is an obsolete property that has no effect.</remarks>
+        [System.Obsolete("The approximate message count cache is obsolete. Use FetchAttributes to refresh the approximate message count as needed.")]
+        public TimeSpan ApproximateMessageCountCacheLength { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether requests made via the Queue service client will employ path-style URIs.
+        /// </summary>
+        /// <value><c>True</c> to use path-style URIs; otherwise, <c>false</c>.</value>
+        public bool UsePathStyleUris { get; private set; }
+
+        /// <summary>
+        /// Gets the account credentials used to create the Queue service client.
+        /// </summary>
+        /// <value>An object of type <see cref="StorageCredentials"/>.</value>
+        public StorageCredentials Credentials { get; private set; }
+
+        /// <summary>
+        /// Gets the base URI for the Queue service client.
+        /// </summary>
+        /// <value>The base URI used to construct the Queue service client.</value>
+        public Uri BaseUri { get; private set; }
+
+        /// <summary>
+        /// Gets a reference to the queue at the specified address.
+        /// </summary>
+        /// <param name="queueAddress">Either the name of the queue, or the absolute URI to the queue.</param>
+        /// <returns>A reference to the queue.</returns>
+        public CloudQueue GetQueueReference(string queueAddress)
+        {
+            Uri queueUri = NavigationHelper.AppendPathToUri(this.BaseUri, queueAddress);
+
+            return new CloudQueue(queueUri, this);
+        }
+        
+        /// <summary>
+        /// Returns an enumerable collection of the queues in the storage account.
+        /// </summary>
+        /// <returns>An enumerable collection of queues.</returns>
+        public IEnumerable<CloudQueue> ListQueues()
+        {
+            return this.ListQueues(String.Empty);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of the queues in the storage account whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The queue name prefix.</param>
+        /// <returns>An enumerable collection of queues.</returns>
+        public IEnumerable<CloudQueue> ListQueues(string prefix)
+        {
+            return this.ListQueues(prefix, QueueListingDetails.None);
+        }
+        
+        /// <summary>
+        /// Returns an enumerable collection of the queues in the storage account whose names begin with the specified prefix and that are retrieved lazily.
+        /// </summary>
+        /// <param name="prefix">The queue name prefix.</param>
+        /// <param name="detailsIncluded">One of the enumeration values that indicates which details to include in the listing.</param>
+        /// <returns>An enumerable collection of queues that are retrieved lazily.</returns>
+        public IEnumerable<CloudQueue> ListQueues(string prefix, QueueListingDetails detailsIncluded)
+        {
+            return CommonUtils.LazyEnumerateSegmented<CloudQueue>(
+                (setResult) => this.ListQueuesImpl(prefix, detailsIncluded, null, null, setResult),
+                this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of queues
+        /// in the storage account. 
+        /// </summary>
+        /// <returns>A result segment containing a collection of queues.</returns>
+        public ResultSegment<CloudQueue> ListQueuesSegmented()
+        {
+            return this.ListQueuesSegmented(String.Empty, QueueListingDetails.None);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of queues
+        /// in the storage account. 
+        /// </summary>
+        /// <param name="prefix">The queue name prefix.</param>
+        /// <param name="detailsIncluded">One of the enumeration values that indicates which details to include in the listing.</param>
+        /// <returns>A result segment containing a collection of queues.</returns>
+        public ResultSegment<CloudQueue> ListQueuesSegmented(string prefix, QueueListingDetails detailsIncluded)
+        {
+            return this.ListQueuesSegmented(prefix, detailsIncluded, 0, null);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of queues
+        /// whose names begin with the specified prefix. 
+        /// </summary>
+        /// <param name="prefix">The queue name prefix.</param>
+        /// <param name="detailsIncluded">One of the enumeration values that indicates which details to include in the listing.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <returns>A result segment containing a collection of queues.</returns>
+        public ResultSegment<CloudQueue> ListQueuesSegmented(string prefix, QueueListingDetails detailsIncluded, int maxResults, ResultContinuation continuationToken)
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<CloudQueue>>(
+                (setResult) => this.ListQueuesImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
+                this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of queues
+        /// in the storage account.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListQueuesSegmented(AsyncCallback callback, object state)
+        {
+            return this.BeginListQueuesSegmented(String.Empty, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of queues
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The queue name prefix.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListQueuesSegmented(string prefix, AsyncCallback callback, object state)
+        {
+            return this.BeginListQueuesSegmented(prefix, QueueListingDetails.None, callback, state);
+        }
+        
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of queues
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The queue name prefix.</param>
+        /// <param name="detailsIncluded">One of the enumeration values that indicates which details to include in the listing.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListQueuesSegmented(string prefix, QueueListingDetails detailsIncluded, AsyncCallback callback, object state)
+        {
+            return this.BeginListQueuesSegmented(prefix, detailsIncluded, 0, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of queues
+        /// whose names begin with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The queue name prefix.</param>
+        /// <param name="detailsIncluded">One of the enumeration values that indicates which details to include in the listing.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListQueuesSegmented(string prefix, QueueListingDetails detailsIncluded, int maxResults, ResultContinuation continuationToken, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<CloudQueue>>(
+                (setResult) => this.ListQueuesImpl(prefix, detailsIncluded, continuationToken, maxResults, setResult),
+                this.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to return a result segment containing a collection of queues.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A result segment containing the results of the first request.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public ResultSegment<CloudQueue> EndListQueuesSegmented(IAsyncResult asyncResult) 
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<CloudQueue>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets the properties of the queue service.
+        /// </summary>
+        /// <returns>The queue service properties.</returns>
+        public ServiceProperties GetServiceProperties()
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<ServiceProperties>((setResult) => this.GetServicePropertiesImpl(setResult), this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to get the properties of the queue service.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user defined object to be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetServiceProperties(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ServiceProperties>((setResult) => this.GetServicePropertiesImpl(setResult), this.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to get the properties of the queue service.
+        /// </summary>
+        /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginGetServiceProperties"/>.</param>
+        /// <returns>The queue service properties.</returns>
+        public ServiceProperties EndGetServiceProperties(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ServiceProperties>(asyncResult);
+        }
+
+        /// <summary>
+        /// Sets the properties of the queue service.
+        /// </summary>
+        /// <param name="properties">The queue service properties.</param>
+        public void SetServiceProperties(ServiceProperties properties)
+        {
+            TaskImplHelper.ExecuteImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to set the properties of the queue service.
+        /// </summary>
+        /// <param name="properties">The queue service properties.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user defined object to be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to set the properties of the queue service.
+        /// </summary>
+        /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginSetServiceProperties"/>.</param>
+        public void EndSetServiceProperties(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Ends the get response.
+        /// </summary>
+        /// <param name="asyncresult">The asynchronous result.</param>
+        /// <param name="req">The request.</param>
+        /// <returns>The web response.</returns>
+        internal WebResponse EndGetResponse(IAsyncResult asyncresult, WebRequest req)
+        {
+            return EventHelper.ProcessWebResponse(req, asyncresult, this.ResponseReceived, this);
+        }
+
+        /// <summary>
+        /// Lists the queues impl.
+        /// </summary>
+        /// <param name="prefix">The prefix.</param>
+        /// <param name="detailsIncluded">The details included.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="maxResults">The max results.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> for listing the queues.</returns>
+        private TaskSequence ListQueuesImpl(
+            string prefix,
+            QueueListingDetails detailsIncluded,
+            ResultContinuation continuationToken,
+            int? maxResults,
+            Action<ResultSegment<CloudQueue>> setResult)
+        {
+            ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
+
+            return this.ListQueuesImplCore(
+                prefix,
+                detailsIncluded,
+                continuationToken,
+                pagination,
+                setResult);
+        }
+
+        /// <summary>
+        /// Lists the queues impl core.
+        /// </summary>
+        /// <param name="prefix">The prefix.</param>
+        /// <param name="detailsIncluded">The details included.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="pagination">The pagination.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> for listing the queues.</returns>
+        private TaskSequence ListQueuesImplCore(
+            string prefix,
+            QueueListingDetails detailsIncluded,
+            ResultContinuation continuationToken,
+            ResultPagination pagination,
+            Action<ResultSegment<CloudQueue>> setResult)
+        {
+            CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Queue);
+
+            ListingContext listingContext = new ListingContext(prefix, pagination.GetNextRequestPageSize())
+            {
+                Marker = continuationToken != null ? continuationToken.NextMarker : null
+            };
+
+            var queueList = new List<CloudQueue>();
+            
+            var webRequest = QueueRequest.List(this.BaseUri, this.Timeout.RoundUpToSeconds(), listingContext, detailsIncluded);
+            this.Credentials.SignRequest(webRequest);
+
+            var listTask = webRequest.GetResponseAsyncWithTimeout(this, this.Timeout);
+            yield return listTask;
+
+            string nextMarker;
+
+            using (var response = listTask.Result as HttpWebResponse)
+            {
+                var parsedResponse = QueueResponse.List(response);
+
+                // Materialize the results so that we can close the response
+                queueList.AddRange(parsedResponse.Queues.Select((Func<QueueEntry, CloudQueue>)this.SelectResponse));
+
+                nextMarker = parsedResponse.NextMarker;
+            }
+
+            ResultContinuation newContinuationToken = new ResultContinuation() { NextMarker = nextMarker, Type = ResultContinuation.ContinuationType.Queue };
+
+            ResultSegment.CreateResultSegment(
+                setResult,
+                queueList,
+                newContinuationToken,
+                pagination,
+                this.RetryPolicy,
+                (paginationArg, continuationArg, resultSegment) =>
+                    this.ListQueuesImplCore(prefix, detailsIncluded, continuationArg, paginationArg, resultSegment));
+        }
+
+        /// <summary>
+        /// Selects the response.
+        /// </summary>
+        /// <param name="item">The item to parse.</param>
+        /// <returns>A <see cref="CloudQueue"/> object representing the item.</returns>
+        private CloudQueue SelectResponse(QueueEntry item)
+        {
+            CloudQueue info = new CloudQueue(item.Attributes, this);
+            return info;
+        }
+
+        /// <summary>
+        /// Generates a task sequence for getting the properties of the queue service.
+        /// </summary>
+        /// <param name="setResult">A delegate to receive the service properties.</param>
+        /// <returns>A task sequence that gets the properties of the queue service.</returns>
+        private TaskSequence GetServicePropertiesImpl(Action<ServiceProperties> setResult)
+        {
+            HttpWebRequest request = QueueRequest.GetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(request, -1);
+            this.Credentials.SignRequest(request);
+
+            // Get the web response.
+            Task<WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
+            yield return responseTask;
+
+            using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
+            using (Stream responseStream = response.GetResponseStream())
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                // Download the service properties.
+                Task<NullTaskReturn> downloadTask = new InvokeTaskSequenceTask(() => { return responseStream.WriteTo(memoryStream); });
+                yield return downloadTask;
+
+                // Materialize any exceptions.
+                NullTaskReturn scratch = downloadTask.Result;
+
+                // Get the result from the memory stream.
+                memoryStream.Seek(0, SeekOrigin.Begin);
+                setResult(QueueResponse.ReadServiceProperties(memoryStream));
+            }
+        }
+
+        /// <summary>
+        /// Generates a task sequence for setting the properties of the queue service.
+        /// </summary>
+        /// <param name="properties">The queue service properties to set.</param>
+        /// <returns>A task sequence that sets the properties of the queue service.</returns>
+        private TaskSequence SetServicePropertiesImpl(ServiceProperties properties)
+        {
+            CommonUtils.AssertNotNull("properties", properties);
+
+            HttpWebRequest request = QueueRequest.SetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                try
+                {
+                    QueueRequest.WriteServiceProperties(properties, memoryStream);
+                }
+                catch (InvalidOperationException invalidOpException)
+                {
+                    throw new ArgumentException(invalidOpException.Message, "properties");
+                }
+
+                memoryStream.Seek(0, SeekOrigin.Begin);
+                CommonUtils.ApplyRequestOptimizations(request, memoryStream.Length);
+                this.Credentials.SignRequest(request);
+
+                // Get the request stream
+                Task<Stream> getStreamTask = request.GetRequestStreamAsync();
+                yield return getStreamTask;
+
+                using (Stream requestStream = getStreamTask.Result)
+                {
+                    // Upload the service properties.
+                    Task<NullTaskReturn> uploadTask = new InvokeTaskSequenceTask(() => { return (memoryStream as Stream).WriteTo(requestStream); });
+                    yield return uploadTask;
+
+                    // Materialize any exceptions.
+                    NullTaskReturn scratch = uploadTask.Result;
+                }
+            }
+
+            // Get the web response.
+            Task<WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
+            yield return responseTask;
+
+            // Materialize any exceptions.
+            using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
+            {
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudQueueMessage.cs b/microsoft-azure-api/StorageClient/CloudQueueMessage.cs
new file mode 100644
index 0000000000000..06db928ff1e02
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudQueueMessage.cs
@@ -0,0 +1,223 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudQueueMessage.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudQueueMessage class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Globalization;
+    using System.Text;
+    using Protocol;
+
+    /// <summary>
+    /// Enum for Queue message type.
+    /// </summary>
+    internal enum QueueMessageType
+    {
+        /// <summary>
+        /// Indicates the message object stores the raw text string.
+        /// </summary>
+        RawString,
+
+        /// <summary>
+        /// Indicates the message object stores the Base64-Encoded representation of the raw data. 
+        /// </summary>
+        Base64Encoded
+    }
+
+    /// <summary>
+    /// Represents a message in a queue.
+    /// </summary>
+    public class CloudQueueMessage
+    {
+        /// <summary>
+        /// The maximum message size in bytes.
+        /// </summary>
+        public static readonly long MaxMessageSize = 64 * Constants.KB;
+
+        /// <summary>
+        /// The maximum amount of time a message is kept in the queue.
+        /// </summary>
+        public static readonly TimeSpan MaxTimeToLive = TimeSpan.FromDays(7);
+
+        /// <summary>
+        /// The maximum number of messages that can be peeked at a time.
+        /// </summary>
+        public static readonly int MaxNumberOfMessagesToPeek = 32;
+
+        /// <summary>
+        /// Custom UTF8Encoder to throw exception in case of invalid bytes.
+        /// </summary>
+        private static UTF8Encoding utf8Encoder = new UTF8Encoding(false, true);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueMessage"/> class with the given byte array.
+        /// </summary>
+        /// <param name="content">The content of the message as a byte array.</param>
+        public CloudQueueMessage(byte[] content)
+        {
+            this.SetMessageContent(content);
+
+            // While binary messages will be Base64-encoded and we could validate the message size here,
+            // for consistency, we leave it to CloudQueue so that we have a central place for this logic.
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueMessage"/> class with the given string.
+        /// </summary>
+        /// <param name="content">The content of the message as a string of text.</param>
+        public CloudQueueMessage(string content)
+        {
+            this.SetMessageContent(content);
+
+            // At this point, without knowing whether or not the message will be Base64 encoded, we can't fully validate the message size.
+            // So we leave it to CloudQueue so that we have a central place for this logic.
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudQueueMessage"/> class with the given Base64 encoded string.
+        /// This method is only used internally.
+        /// </summary>
+        /// <param name="content">The text string.</param>
+        /// <param name="isBase64Encoded">Whether the string is Base64 encoded.</param>
+        internal CloudQueueMessage(string content, bool isBase64Encoded)
+        {
+            if (content == null)
+            {
+                content = string.Empty;
+            }
+
+            this.RawString = content;
+            this.MessageType = isBase64Encoded ? QueueMessageType.Base64Encoded : QueueMessageType.RawString;
+        }
+
+        /// <summary>
+        /// Gets the content of the message as a byte array.
+        /// </summary>
+        /// <value>The content of the message as a byte array.</value>
+        public byte[] AsBytes
+        {
+            get
+            {
+                if (this.MessageType == QueueMessageType.RawString)
+                {
+                    return Encoding.UTF8.GetBytes(this.RawString);
+                }
+                else
+                {
+                    return Convert.FromBase64String(this.RawString);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the message ID.
+        /// </summary>
+        /// <value>The message ID.</value>
+        public string Id { get; protected internal set; }
+
+        /// <summary>
+        /// Gets or sets the message's pop receipt.
+        /// </summary>
+        /// <value>The pop receipt value.</value>
+        public string PopReceipt { get; protected internal set; }
+
+        /// <summary>
+        /// Gets or sets the time that the message was added to the queue.
+        /// </summary>
+        /// <value>The time that that message was added to the queue.</value>
+        public DateTime? InsertionTime { get; protected internal set; }
+
+        /// <summary>
+        /// Gets or sets the time that the message expires.
+        /// </summary>
+        /// <value>The time that the message expires.</value>
+        public DateTime? ExpirationTime { get; protected internal set; }
+
+        /// <summary>
+        /// Gets or sets the time that the message will next be visible.
+        /// </summary>
+        /// <value>The time that the message will next be visible.</value>
+        public DateTime? NextVisibleTime { get; protected internal set; }
+
+        /// <summary>
+        /// Gets the content of the message, as a string.
+        /// </summary>
+        /// <value>The message content.</value>
+        public string AsString
+        {
+            get
+            {
+                if (this.MessageType == QueueMessageType.RawString)
+                {
+                    return this.RawString;
+                }
+                else
+                {
+                    return utf8Encoder.GetString(Convert.FromBase64String(this.RawString));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the number of times this message has been dequeued.
+        /// </summary>
+        /// <value>The number of times this message has been dequeued.</value>
+        public int DequeueCount { get; protected internal set; }
+        
+        /// <summary>
+        /// Gets message type that indicates if the RawString is the original message string or Base64 encoding of the original binary data.
+        /// </summary>
+        internal QueueMessageType MessageType { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the original message string or Base64 encoding of the original binary data.
+        /// </summary>
+        /// <value>The original message string.</value>
+        protected internal string RawString { get; set; }
+
+        /// <summary>
+        /// Sets the content of this message.
+        /// </summary>
+        /// <param name="content">The new message content.</param>
+        public void SetMessageContent(string content)
+        {
+            if (content == null)
+            {
+                // Protocol will return null for empty content
+                content = string.Empty;
+            }
+
+            this.RawString = content;
+            this.MessageType = QueueMessageType.RawString;
+        }
+
+        /// <summary>
+        /// Sets the content of this message.
+        /// </summary>
+        /// <param name="content">The new message content.</param>
+        public void SetMessageContent(byte[] content)
+        {
+            CommonUtils.AssertNotNull("content", content);
+
+            this.RawString = Convert.ToBase64String(content);
+            this.MessageType = QueueMessageType.Base64Encoded;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudStorageAccountStorageClientExtensions.cs b/microsoft-azure-api/StorageClient/CloudStorageAccountStorageClientExtensions.cs
new file mode 100644
index 0000000000000..c9dcaf9a8dd36
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudStorageAccountStorageClientExtensions.cs
@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudStorageAccountStorageClientExtensions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudStorageAccountStorageClientExtensions class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Provides a set of extensions to the <see cref="CloudStorageAccount"/> class that may be used to generate client objects for 
+    /// the Windows Azure storage services.
+    /// </summary>
+    public static class CloudStorageAccountStorageClientExtensions
+    {
+        /// <summary>
+        /// Creates a new Blob service client.
+        /// </summary>
+        /// <param name="account">The storage account.</param>
+        /// <returns>A client object that specifies the Blob service endpoint.</returns>
+        public static CloudBlobClient CreateCloudBlobClient(this CloudStorageAccount account)
+        {
+            if (account.BlobEndpoint == null)
+            {
+                throw new InvalidOperationException("No blob endpoint configured.");
+            }
+
+            if (account.Credentials == null)
+            {
+                throw new InvalidOperationException("No credentials provided configured.");
+            }
+
+            return new CloudBlobClient(account.BlobEndpoint, account.Credentials);
+        }
+
+        /// <summary>
+        /// Creates a new Queue service client.
+        /// </summary>
+        /// <param name="account">The storage account.</param>
+        /// <returns>A client object that specifies the Queue service endpoint.</returns>
+        public static CloudQueueClient CreateCloudQueueClient(this CloudStorageAccount account)
+        {
+            if (account.QueueEndpoint == null)
+            {
+                throw new InvalidOperationException("No queue endpoint configured.");
+            }
+
+            if (account.Credentials == null)
+            {
+                throw new InvalidOperationException("No credentials provided.");
+            }
+
+            if (!account.Credentials.CanSignRequest)
+            {
+                throw new InvalidOperationException("CloudQueueClient requires a credential that can sign request");
+            }
+
+            return new CloudQueueClient(account.QueueEndpoint, account.Credentials);
+        }
+
+        /// <summary>
+        /// Creates the Table service client.
+        /// </summary>
+        /// <param name="account">The storage account.</param>
+        /// <returns>A client object that specifies the Table service endpoint.</returns>
+        public static CloudTableClient CreateCloudTableClient(this CloudStorageAccount account)
+        {
+            if (account.TableEndpoint == null)
+            {
+                throw new InvalidOperationException("No table endpoint configured.");
+            }
+
+            if (account.Credentials == null)
+            {
+                throw new InvalidOperationException("No credentials provided.");
+            }
+
+            if (!account.Credentials.CanSignRequest || !account.Credentials.CanSignRequestLite)
+            {
+                throw new InvalidOperationException("CloudTableClient requires a credential that can sign request");
+            }
+
+            return new CloudTableClient(account.TableEndpoint, account.Credentials);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudTableClient.cs b/microsoft-azure-api/StorageClient/CloudTableClient.cs
new file mode 100644
index 0000000000000..c1c868702e91f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudTableClient.cs
@@ -0,0 +1,969 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudTableClient.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudTableClient class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Data.Services.Client;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using Microsoft.WindowsAzure.StorageClient.Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Provides a client for accessing the Windows Azure Table service.
+    /// </summary>
+    public class CloudTableClient
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudTableClient"/> class using the specified Table service endpoint
+        /// and account credentials.
+        /// </summary>
+        /// <param name="baseAddress">The Table service endpoint to use to create the client.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudTableClient(string baseAddress, StorageCredentials credentials)
+            : this(new Uri(baseAddress), credentials)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudTableClient"/> class using the specified Table service endpoint
+        /// and account credentials.
+        /// </summary>
+        /// <param name="baseAddressUri">The Table service endpoint to use to create the client.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public CloudTableClient(Uri baseAddressUri, StorageCredentials credentials)
+        {
+            if (baseAddressUri == null)
+            {
+                throw new ArgumentNullException("baseAddressUri");
+            }
+
+            if (credentials == null)
+            {
+                throw new ArgumentNullException("credentials");
+            }
+
+            if ((!credentials.CanSignRequest) || (!credentials.CanSignRequestLite))
+            {
+                throw new ArgumentException(SR.CredentialsCantSignRequest, "credentials");
+            }
+
+            this.BaseUri = baseAddressUri;
+            this.Credentials = credentials;
+            this.RetryPolicy = RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultClientBackoff);
+            this.Timeout = TimeSpan.FromSeconds(90);
+        }
+
+        /// <summary>
+        /// Occurs when a response is received from the server.
+        /// </summary>
+        public event EventHandler<ResponseReceivedEventArgs> ResponseReceived;
+
+        /// <summary>
+        /// Gets the minimum supported timestamp value for a table entity.
+        /// </summary>
+        /// <value>The minimum supported timestamp value for a table entity.</value>
+        public DateTime MinSupportedDateTime
+        {
+            get
+            {
+                return DateTime.FromFileTimeUtc(0);
+            }
+        }
+
+        /// <summary>
+        /// Gets the base URI for the Table service client.
+        /// </summary>
+        /// <value>The base URI used to construct the Table service client.</value>
+        public Uri BaseUri { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the default retry policy for requests made via the Table service client.
+        /// </summary>
+        /// <value>The retry policy.</value>
+        public RetryPolicy RetryPolicy { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default server timeout for requests made by the Table service client.
+        /// </summary>
+        /// <value>The server timeout interval.</value>
+        public TimeSpan Timeout { get; set; }
+
+        /// <summary>
+        /// Gets the account credentials used to create the Table service client.
+        /// </summary>
+        /// <value>The account credentials.</value>
+        public StorageCredentials Credentials { get; private set; }
+
+        /// <summary>
+        /// Creates the tables needed for the specified service context.
+        /// </summary>
+        /// <param name="serviceContextType">The type of service context.</param>
+        /// <param name="baseAddress">The Table service endpoint to use to create the client.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void CreateTablesFromModel(Type serviceContextType, string baseAddress, StorageCredentials credentials)
+        {
+            var client = new CloudTableClient(baseAddress, credentials);
+
+            foreach (var table in TableServiceUtilities.EnumerateEntitySetNames(serviceContextType))
+            {
+                client.CreateTableIfNotExist(table);
+            }
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="TableServiceContext"/> object for performing operations against the Table service.
+        /// </summary>
+        /// <returns>A service context to use for performing operations against the Table service.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1024:UsePropertiesWhereAppropriate",
+            Justification = "This method creates a new object each time.")]
+        public TableServiceContext GetDataServiceContext()
+        {
+            return new TableServiceContext(this.BaseUri.ToString(), this.Credentials)
+            {
+                RetryPolicy = this.RetryPolicy,
+                Timeout = (int)this.Timeout.TotalSeconds
+            };
+        }
+
+        /// <summary>
+        /// Attaches to the specified service context.
+        /// </summary>
+        /// <param name="serviceContext">The service context to attach to.</param>
+        public void Attach(DataServiceContext serviceContext)
+        {
+            if (serviceContext is TableServiceContext)
+            {
+                throw new ArgumentException(SR.AttachToTableServiceContext);
+            }
+
+            // because this is an anonymous method the closure object acts as GC isolation
+            serviceContext.SendingRequest += (sender, e) =>
+            {
+                HttpWebRequest request = e.Request as HttpWebRequest;
+
+                // do the authentication
+                Credentials.SignRequestLite(request);
+            };
+        }
+
+        /// <summary>
+        /// Begins an asychronous operation to create a table.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateTable(string tableName, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(() => this.CreateTableImpl(tableName, null), RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asychronous operation to create a table.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public void EndCreateTable(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Creates a table with specified name.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        public void CreateTable(string tableName)
+        {
+            TaskImplHelper.ExecuteImplWithRetry(() => this.CreateTableImpl(tableName, null), RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to create a table with the specified name if it does not already exist.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginCreateTableIfNotExist(string tableName, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImpl<bool>(
+                (setResult) => this.CreateTableIfNotExistImpl(tableName, setResult),
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to create a table with the specified name if it does not already exist.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns><c>true</c> if table was created; otherwise, <c>false</c>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public bool EndCreateTableIfNotExist(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<bool>(asyncResult);
+        }
+
+        /// <summary>
+        /// Creates the table if it does not already exist.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <returns><c>true</c> if table was created; otherwise, <c>false</c>.</returns>
+        public bool CreateTableIfNotExist(string tableName)
+        {
+            return TaskImplHelper.ExecuteImpl<bool>((setResult) => this.CreateTableIfNotExistImpl(tableName, setResult));
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to determine whether a table exists.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDoesTableExist(string tableName, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImpl<bool>((setResult) => this.DoesTableExistImpl(tableName, setResult), callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to determine whether a table exists.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns><c>true</c> if table exists; otherwise, <c>false</c>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public bool EndDoesTableExist(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<bool>(asyncResult);
+        }
+
+        /// <summary>
+        /// Checks whether the table exists.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <returns><c>true</c> if table exists; otherwise, <c>false</c>.</returns>
+        public bool DoesTableExist(string tableName)
+        {
+            return TaskImplHelper.ExecuteImpl<bool>((setResult) => this.DoesTableExistImpl(tableName, setResult));
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of table names in the storage account.
+        /// </summary>
+        /// <returns>An enumerable collection of table names.</returns>
+        public IEnumerable<string> ListTables()
+        {
+            return this.ListTables(String.Empty);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of table names that begin with the specified prefix and that are retrieved lazily.
+        /// </summary>
+        /// <param name="prefix">The table name prefix.</param>
+        /// <returns>An enumerable collection of table names that are retrieved lazily.</returns>
+        public IEnumerable<string> ListTables(string prefix)
+        {
+            return CommonUtils.LazyEnumerateSegmented<string>(
+                (setResult) => this.ListTablesSegmentedImpl(prefix, null, null, setResult),
+                this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of table names in the storage account.
+        /// </summary>
+        /// <returns>A result segment containing table names.</returns>
+        public ResultSegment<string> ListTablesSegmented()
+        {
+            return this.ListTablesSegmented(0, null);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of table names in the storage account.
+        /// </summary>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <returns>A result segment containing table names.</returns>
+        public ResultSegment<string> ListTablesSegmented(int maxResults, ResultContinuation continuationToken)
+        {
+            return this.ListTablesSegmented(String.Empty, maxResults, continuationToken);
+        }
+
+        /// <summary>
+        /// Returns a result segment containing a collection of table names beginning with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The table name prefix.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <returns>A result segment containing table names.</returns>
+        public ResultSegment<string> ListTablesSegmented(string prefix, int maxResults, ResultContinuation continuationToken)
+        {
+            return this.EndListTablesSegmented(
+                this.BeginListTablesSegmented(prefix, maxResults, continuationToken, null, null));
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection of table names 
+        /// in the storage account.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListTablesSegmented(AsyncCallback callback, object state)
+        {
+            return this.BeginListTablesSegmented(String.Empty, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection 
+        /// of table names beginning with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The table name prefix.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListTablesSegmented(string prefix, AsyncCallback callback, object state)
+        {
+            return this.BeginListTablesSegmented(prefix, 0, null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to return a result segment containing a collection 
+        /// of table names beginning with the specified prefix.
+        /// </summary>
+        /// <param name="prefix">The table name prefix.</param>
+        /// <param name="maxResults">A non-negative integer value that indicates the maximum number of results to be returned at a time, up to the 
+        /// per-operation limit of 5000. If this value is zero, the maximum possible number of results will be returned, up to 5000.</param>         
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginListTablesSegmented(string prefix, int maxResults, ResultContinuation continuationToken, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<string>>(
+                (setResult) => this.ListTablesSegmentedImpl(
+                    prefix,
+                    maxResults,
+                    continuationToken,
+                    setResult),
+                this.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to return a result segment containing a collection 
+        /// of table names. 
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>A result segment containing table names.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Performance",
+            "CA1822:MarkMembersAsStatic",
+            Justification = "This is a member-operation.")]
+        public ResultSegment<string> EndListTablesSegmented(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<string>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete a table.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>
+        /// An <see cref="IAsyncResult"/> that references the asynchronous request.
+        /// </returns>
+        public IAsyncResult BeginDeleteTable(string tableName, AsyncCallback callback, object state)
+        {
+            CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars);
+            TableServiceUtilities.CheckTableName(tableName, "tableName");
+
+            return TaskImplHelper.BeginImplWithRetry(() => this.DeleteTableImpl(tableName), RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to delete a table.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public void EndDeleteTable(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Deletes the table.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        public void DeleteTable(string tableName)
+        {
+            this.EndDeleteTable(this.BeginDeleteTable(tableName, null, null));
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to delete the tables if it exists.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginDeleteTableIfExist(string tableName, AsyncCallback callback, object state)
+        {
+            CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars);
+
+            TableServiceUtilities.CheckTableName(tableName, "tableName");
+
+            return TaskImplHelper.BeginImpl<bool>((setResult) => this.DeleteTableIfExistImpl(tableName, setResult), callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to delete the tables if it exists.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns><c>true</c> if the table was deleted; otherwise, <c>false</c>.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public bool EndDeleteTableIfExist(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<bool>(asyncResult);
+        }
+
+        /// <summary>
+        /// Deletes the table if it exists.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <returns><c>true</c> if the table was deleted; otherwise, <c>false</c>.</returns>
+        public bool DeleteTableIfExist(string tableName)
+        {
+            return this.EndDeleteTableIfExist(this.BeginDeleteTableIfExist(tableName, null, null));
+        }
+
+        /// <summary>
+        /// Gets the properties of the table service.
+        /// </summary>
+        /// <returns>The table service properties.</returns>
+        public ServiceProperties GetServiceProperties()
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<ServiceProperties>((setResult) => this.GetServicePropertiesImpl(setResult), this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to get the properties of the table service.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user defined object to be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetServiceProperties(AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ServiceProperties>((setResult) => this.GetServicePropertiesImpl(setResult), this.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to get the properties of the table service.
+        /// </summary>
+        /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginGetServiceProperties"/>.</param>
+        /// <returns>The table service properties.</returns>
+        public ServiceProperties EndGetServiceProperties(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ServiceProperties>(asyncResult);
+        }
+
+        /// <summary>
+        /// Sets the properties of the table service.
+        /// </summary>
+        /// <param name="properties">The table service properties.</param>
+        public void SetServiceProperties(ServiceProperties properties)
+        {
+            TaskImplHelper.ExecuteImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to set the properties of the table service.
+        /// </summary>
+        /// <param name="properties">The table service properties.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user defined object to be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSetServiceProperties(ServiceProperties properties, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry(() => this.SetServicePropertiesImpl(properties), this.RetryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to set the properties of the table service.
+        /// </summary>
+        /// <param name="asyncResult">The result returned from a prior call to <see cref="BeginSetServiceProperties"/>.</param>
+        public void EndSetServiceProperties(IAsyncResult asyncResult)
+        {
+            TaskImplHelper.EndImplWithRetry(asyncResult);
+        }
+
+        /// <summary>
+        /// Ends the asynchronous GetResponse operation.
+        /// </summary>
+        /// <param name="asyncresult">An <see cref="IAsyncResult"/> that references the asynchronous operation.</param>
+        /// <param name="req">The request to end the operation on.</param>
+        /// <returns>The <see cref="WebResponse"/> from the asynchronous request.</returns>
+        internal WebResponse EndGetResponse(IAsyncResult asyncresult, WebRequest req)
+        {
+            return EventHelper.ProcessWebResponse(req, asyncresult, this.ResponseReceived, this);
+        }
+
+        /// <summary>
+        /// Gets the result or default.
+        /// </summary>
+        /// <typeparam name="T">The type of the result.</typeparam>
+        /// <param name="task">The task to retrieve the result from.</param>
+        /// <param name="result">Receives result of the task.</param>
+        /// <returns><c>true</c> if the result was returned; otherwise, <c>false</c>.</returns>
+        private static bool GetResultOrDefault<T>(Task<T> task, out T result)
+        {
+            try
+            {
+                result = task.Result;
+
+                return true;
+            }
+            catch (DataServiceQueryException ex)
+            {
+                if ((HttpStatusCode)ex.Response.StatusCode == HttpStatusCode.NotFound)
+                {
+                    result = default(T);
+
+                    return false;
+                }
+
+                throw Utilities.TranslateDataServiceClientException(ex);
+            }
+            catch (InvalidOperationException ex)
+            {
+                DataServiceClientException dsce = CommonUtils.FindInnerDataServiceClientException(ex);
+
+                if (dsce != null)
+                {
+                    if ((HttpStatusCode)dsce.StatusCode == HttpStatusCode.NotFound)
+                    {
+                        result = default(T);
+
+                        return false;
+                    }
+                }
+
+                throw Utilities.TranslateDataServiceClientException(ex);
+            }
+        }
+
+        /// <summary>
+        /// Creates the table implementation.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A sequence of tasks to do the operation.</returns>
+        private TaskSequence CreateTableImpl(string tableName, Action<InvalidOperationException> setResult)
+        {
+            CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars);
+
+            var svc = this.GetDataServiceContext();
+
+            svc.AddObject(Protocol.Constants.TableServiceTablesName, new TableServiceTable() { TableName = tableName });
+
+            var saveChangesTask = svc.SaveChangesAsync();
+
+            yield return saveChangesTask;
+
+            // wrap any exceptions
+            try
+            {
+                var result = saveChangesTask.Result;
+            }
+            catch (InvalidOperationException ex)
+            {
+                if (setResult == null)
+                {
+                    throw Utilities.TranslateDataServiceClientException(ex);
+                }
+                else
+                {
+                    setResult(ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates the table if not exist implementation.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A sequence of tasks to do the operation.</returns>
+        private TaskSequence CreateTableIfNotExistImpl(string tableName, Action<bool> setResult)
+        {
+            CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars);
+            TableServiceUtilities.CheckTableName(tableName, "tableName");
+
+            var doesTableExistTask = new InvokeTaskSequenceTask<bool>((set) => this.DoesTableExistImpl(tableName, set));
+
+            yield return doesTableExistTask;
+
+            if (doesTableExistTask.Result)
+            {
+                setResult(false);
+            }
+            else
+            {
+                var createTableTask = TaskImplHelper.GetRetryableAsyncTask<InvalidOperationException>((resultSetter) => this.CreateTableImpl(tableName, resultSetter), RetryPolicy);
+
+                yield return createTableTask;
+
+                // wrap any exceptions
+                try
+                {
+                    if (createTableTask.Result == null)
+                    {
+                        setResult(true);
+                    }
+                    else
+                    {
+                        StorageClientException exception = Utilities.TranslateDataServiceClientException(createTableTask.Result) as StorageClientException;
+                        if (exception != null
+                            && exception.ErrorCode == StorageErrorCode.ResourceAlreadyExists
+                            && exception.ExtendedErrorInformation != null
+                            && exception.ExtendedErrorInformation.ErrorCode == TableErrorCodeStrings.TableAlreadyExists)
+                        {
+                            setResult(false);
+                        }
+                        else
+                        {
+                            throw createTableTask.Result;
+                        }
+                    }
+                }
+                catch (InvalidOperationException ex)
+                {
+                    throw Utilities.TranslateDataServiceClientException(ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Verifies whether the table exist implementation.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A sequence of tasks to do the operation.</returns>
+        private TaskSequence DoesTableExistImpl(string tableName, Action<bool> setResult)
+        {
+            CommonUtils.CheckStringParameter(tableName, false, "tableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars);
+            TableServiceUtilities.CheckTableName(tableName, "tableName");
+
+            var svc = this.GetDataServiceContext();
+
+            var tableExistsQuery = (from table in svc.CreateQuery<TableServiceTable>(Protocol.Constants.TableServiceTablesName)
+                                    where table.TableName == tableName
+                                    select table).AsTableServiceQuery();
+
+            ResultSegment<TableServiceTable> segment = null;
+
+            while (true)
+            {
+                Task<ResultSegment<TableServiceTable>> tableExistsSegmentTask;
+
+                if (segment == null)
+                {
+                    tableExistsSegmentTask = TaskImplHelper.GetRetryableAsyncTask<ResultSegment<TableServiceTable>>(
+                        (setResultInner) => tableExistsQuery.ExecuteSegmentedImpl(null, setResultInner), RetryPolicy);
+                }
+                else
+                {
+                    tableExistsSegmentTask = TaskImplHelper.GetRetryableAsyncTask<ResultSegment<TableServiceTable>>(segment.GetNextImpl, RetryPolicy);
+                }
+
+                yield return tableExistsSegmentTask;
+
+                if (GetResultOrDefault(tableExistsSegmentTask, out segment))
+                {
+                    if (segment.Results.Any())
+                    {
+                        setResult(true);
+
+                        break;
+                    }
+                    else
+                    {
+                        setResult(false);
+
+                        break;
+                    }
+                }
+                else
+                {
+                    setResult(false);
+
+                    break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of tables segmented impl.
+        /// </summary>
+        /// <param name="prefix">The prefix.</param>
+        /// <param name="maxResults">The max results.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that lists the tables.</returns>
+        private TaskSequence ListTablesSegmentedImpl(
+            string prefix,
+            int? maxResults,
+            ResultContinuation continuationToken,
+            Action<ResultSegment<string>> setResult)
+        {
+            ResultPagination pagination = new ResultPagination(maxResults.GetValueOrDefault());
+
+            return this.ListTablesSegmentedImplCore(prefix, continuationToken, pagination, null, setResult);
+        }
+
+        /// <summary>
+        /// Returns an enumerable collection of tables segmented implementation.
+        /// </summary>
+        /// <param name="prefix">The prefix.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="pagination">The pagination.</param>
+        /// <param name="lastResult">The last result.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A sequence of tasks to do the operation.</returns>
+        private TaskSequence ListTablesSegmentedImplCore(
+            string prefix,
+            ResultContinuation continuationToken,
+            ResultPagination pagination,
+            ResultSegment<TableServiceTable> lastResult,
+            Action<ResultSegment<string>> setResult)
+        {
+            CommonUtils.AssertContinuationType(continuationToken, ResultContinuation.ContinuationType.Table);
+
+            InvokeTaskSequenceTask<ResultSegment<TableServiceTable>> listTablesSegmentedTask;
+
+            if (lastResult == null)
+            {
+                var svc = this.GetDataServiceContext();
+                var query = from table in svc.CreateQuery<TableServiceTable>(Protocol.Constants.TableServiceTablesName)                           
+                            select table;
+
+                if (prefix != string.Empty)
+                {                       
+                    // Append Max char to end  '{' is 1 + 'z' in AsciiTable
+                    string uppperBound = prefix + '{';
+                    
+                    query = query.Where((table) => table.TableName.CompareTo(prefix) >= 0 && table.TableName.CompareTo(uppperBound) < 0);
+                }
+
+                if (pagination.IsPagingEnabled)
+                {
+                    query = query.Take(pagination.GetNextRequestPageSize().Value);
+                }
+
+                var listTablesQuery = query.AsTableServiceQuery();
+
+                listTablesSegmentedTask = new InvokeTaskSequenceTask<ResultSegment<TableServiceTable>>(
+                                    (setResultInner) =>
+                                    listTablesQuery.ExecuteSegmentedImpl(continuationToken, setResultInner));
+            }
+            else
+            {
+                listTablesSegmentedTask = new InvokeTaskSequenceTask<ResultSegment<TableServiceTable>>(lastResult.GetNextImpl);
+            }
+
+            yield return listTablesSegmentedTask;
+
+            if (GetResultOrDefault<ResultSegment<TableServiceTable>>(listTablesSegmentedTask, out lastResult))
+            {
+                setResult(new ResultSegment<string>(
+                    lastResult.Results.Select((table) => table.TableName),
+                    lastResult.HasMoreResults,
+                    (setResultInner) =>
+                        this.ListTablesSegmentedImplCore(prefix, lastResult.ContinuationToken, pagination, lastResult, setResultInner),
+                    RetryPolicy)
+                {
+                    ContinuationToken = lastResult.ContinuationToken
+                });
+            }
+            else
+            {
+                setResult(new ResultSegment<string>(new List<string>(), false, null, RetryPolicy));
+            }
+        }
+
+        /// <summary>
+        /// Delete table implementation.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <returns>A sequence of tasks to do the operation.</returns>
+        private TaskSequence DeleteTableImpl(string tableName)
+        {
+            var svc = this.GetDataServiceContext();
+            var table = new TableServiceTable(tableName);
+
+            svc.AttachTo(Protocol.Constants.TableServiceTablesName, table);
+            svc.DeleteObject(table);
+
+            var saveChangesTask = svc.SaveChangesAsync();
+
+            yield return saveChangesTask;
+
+            // wrap any exceptions
+            try
+            {
+                var result = saveChangesTask.Result;
+            }
+            catch (InvalidOperationException ex)
+            {
+                throw Utilities.TranslateDataServiceClientException(ex);
+            }
+        }
+
+        /// <summary>
+        /// Deletes table if exists implementation.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A sequence of tasks to do the operation.</returns>
+        private TaskSequence DeleteTableIfExistImpl(string tableName, Action<bool> setResult)
+        {
+            var doesTableExistTask = TaskImplHelper.GetRetryableAsyncTask<bool>(
+                (set) => this.DoesTableExistImpl(tableName, set),
+                RetryPolicy);
+
+            yield return doesTableExistTask;
+
+            if (!doesTableExistTask.Result)
+            {
+                setResult(false);
+            }
+            else
+            {
+                var deleteTableTask = TaskImplHelper.GetRetryableAsyncTask(() => this.DeleteTableImpl(tableName), RetryPolicy);
+
+                yield return deleteTableTask;
+
+                var result = deleteTableTask.Result;
+
+                setResult(true);
+            }
+        }
+
+        /// <summary>
+        /// Generates a task sequence for getting the properties of the table service.
+        /// </summary>
+        /// <param name="setResult">A delegate to receive the service properties.</param>
+        /// <returns>A task sequence that gets the properties of the table service.</returns>
+        private TaskSequence GetServicePropertiesImpl(Action<ServiceProperties> setResult)
+        {
+            HttpWebRequest request = TableRequest.GetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
+            CommonUtils.ApplyRequestOptimizations(request, -1);
+            this.Credentials.SignRequestLite(request);
+
+            // Get the web response.
+            Task<WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
+            yield return responseTask;
+
+            using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
+            using (Stream responseStream = response.GetResponseStream())
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                // Download the service properties.
+                Task<NullTaskReturn> downloadTask = new InvokeTaskSequenceTask(() => { return responseStream.WriteTo(memoryStream); });
+                yield return downloadTask;
+
+                // Materialize any exceptions.
+                NullTaskReturn scratch = downloadTask.Result;
+
+                // Get the result from the memory stream.
+                memoryStream.Seek(0, SeekOrigin.Begin);
+                setResult(TableResponse.ReadServiceProperties(memoryStream));
+            }
+        }
+
+        /// <summary>
+        /// Generates a task sequence for setting the properties of the table service.
+        /// </summary>
+        /// <param name="properties">The table service properties to set.</param>
+        /// <returns>A task sequence that sets the properties of the table service.</returns>
+        private TaskSequence SetServicePropertiesImpl(ServiceProperties properties)
+        {
+            CommonUtils.AssertNotNull("properties", properties);
+
+            HttpWebRequest request = TableRequest.SetServiceProperties(this.BaseUri, this.Timeout.RoundUpToSeconds());
+            using (MemoryStream memoryStream = new MemoryStream())
+            {
+                try
+                {
+                    TableRequest.WriteServiceProperties(properties, memoryStream);
+                }
+                catch (InvalidOperationException invalidOpException)
+                {
+                    throw new ArgumentException(invalidOpException.Message, "properties");
+                }
+
+                memoryStream.Seek(0, SeekOrigin.Begin);
+                CommonUtils.ApplyRequestOptimizations(request, memoryStream.Length);
+                this.Credentials.SignRequestLite(request);
+
+                // Get the request stream
+                Task<Stream> getStreamTask = request.GetRequestStreamAsync();
+                yield return getStreamTask;
+
+                using (Stream requestStream = getStreamTask.Result)
+                {
+                    // Upload the service properties.
+                    Task<NullTaskReturn> uploadTask = new InvokeTaskSequenceTask(() => { return (memoryStream as Stream).WriteTo(requestStream); });
+                    yield return uploadTask;
+
+                    // Materialize any exceptions.
+                    NullTaskReturn scratch = uploadTask.Result;
+                }
+            }
+
+            // Get the web response.
+            Task<WebResponse> responseTask = request.GetResponseAsyncWithTimeout(this, this.Timeout);
+            yield return responseTask;
+
+            // Materialize any exceptions.
+            using (HttpWebResponse response = responseTask.Result as HttpWebResponse)
+            {
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CloudTableQuery.cs b/microsoft-azure-api/StorageClient/CloudTableQuery.cs
new file mode 100644
index 0000000000000..d83e93f7fa8bd
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CloudTableQuery.cs
@@ -0,0 +1,412 @@
+//-----------------------------------------------------------------------
+// <copyright file="CloudTableQuery.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CloudTableQuery class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Data.Services.Client;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Net;
+    using Tasks;
+
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a query against the Windows Azure Table service.
+    /// </summary>
+    /// <typeparam name="TElement">The type of the query result.</typeparam>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.Naming",
+        "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "The intent is to mirror the name of the DataServiceQuery type.")]
+    public class CloudTableQuery<TElement> : IQueryable<TElement>
+    {
+        /// <summary>
+        /// Stores the header prefix for continuation information.
+        /// </summary>
+        internal const string TableServicePrefixForTableContinuation = "x-ms-continuation-";
+
+        /// <summary>
+        /// Stores the header suffix for the next partition key.
+        /// </summary>
+        internal const string TableServiceNextPartitionKey = "NextPartitionKey";
+
+        /// <summary>
+        /// Stores the header suffix for the next row key.
+        /// </summary>
+        internal const string TableServiceNextRowKey = "NextRowKey";
+
+        /// <summary>
+        /// Stores the table suffix for the next table name.
+        /// </summary>
+        internal const string TableServiceNextTableName = "NextTableName";
+
+        /// <summary>
+        /// Stores the maximum results the table service can return.
+        /// </summary>
+        internal const int TableServiceMaxResults = 1000;
+
+        /// <summary>
+        /// Stores the pagination options.
+        /// </summary>
+        private ResultPagination pagination;
+
+        /// <summary>
+        /// Stores the wrapped <see cref="DataServiceQuery&lt;TElement&gt;"/>.
+        /// </summary>
+        private DataServiceQuery<TElement> query;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudTableQuery{TElement}"/> class with the specified query.
+        /// </summary>
+        /// <param name="query">The base query.</param>
+        public CloudTableQuery(DataServiceQuery<TElement> query)
+            : this(query, RetryPolicies.RetryExponential(3, TimeSpan.FromSeconds(2)))
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CloudTableQuery{TElement}"/> class with the specified query
+        /// and retry policy.
+        /// </summary>
+        /// <param name="query">The base query.</param>
+        /// <param name="policy">The retry policy for the query.</param>
+        public CloudTableQuery(DataServiceQuery<TElement> query, RetryPolicy policy)
+        {
+            if (query == null)
+            {
+                throw new ArgumentNullException("query");
+            }
+
+            this.query = query;
+            this.RetryPolicy = policy;
+
+            int? queryTakeCount = GetQueryTakeCount(this.query);
+
+            this.pagination = new ResultPagination(queryTakeCount.GetValueOrDefault());
+        }
+
+        /// <summary>
+        /// Gets or sets the retry policy for the query.
+        /// </summary>
+        /// <value>The retry policy.</value>
+        public RetryPolicy RetryPolicy { get; set; }
+
+        /// <summary>
+        /// Gets the type of the element(s) that are returned when the expression tree associated with this 
+        /// instance of <see cref="T:System.Linq.IQueryable"/> is executed.
+        /// </summary>
+        /// <value>
+        /// A <see cref="T:System.Type"/> that represents the type of the element(s) that are returned when the expression tree associated with this object is executed.
+        /// </value>
+        public Type ElementType
+        {
+            get
+            {
+                return this.query.ElementType;
+            }
+        }
+
+        /// <summary>
+        /// Gets the expression tree that is associated with the instance of <see cref="T:System.Linq.IQueryable"/>.
+        /// </summary>
+        /// <value>
+        /// The <see cref="T:System.Linq.Expressions.Expression"/> that is associated with this instance of <see cref="T:System.Linq.IQueryable"/>.
+        /// </value>
+        public Expression Expression
+        {
+            get
+            {
+                return this.query.Expression;
+            }
+        }
+
+        /// <summary>
+        /// Gets the query provider that is associated with this data source.
+        /// </summary>
+        /// <value>
+        /// The <see cref="T:System.Linq.IQueryProvider"/> that is associated with this data source.
+        /// </value>
+        public IQueryProvider Provider
+        {
+            get
+            {
+                return this.query.Provider;
+            }
+        }
+
+        /// <summary>
+        /// Executes the query with the retry policy specified on the <see cref="CloudTableQuery&lt;TElement&gt;"/> object.
+        /// </summary>
+        /// <returns>The results of the query, retrieved lazily.</returns>
+        public IEnumerable<TElement> Execute()
+        {
+            return CommonUtils.LazyEnumerateSegmented<TElement>((setResult) => this.ExecuteSegmentedImpl(null, setResult), this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Executes the query with the retry policy specified on the <see cref="CloudTableQuery&lt;TElement&gt;"/> object.
+        /// </summary>
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param> 
+        /// <returns>The results of the query, retrieved lazily.</returns>
+        public IEnumerable<TElement> Execute(ResultContinuation continuationToken)
+        {
+            return CommonUtils.LazyEnumerateSegmented<TElement>(
+                (setResult) => this.ExecuteSegmentedImpl(continuationToken, setResult),
+                this.RetryPolicy);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to execute a query and return the results as a result segment.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginExecuteSegmented(AsyncCallback callback, object state)
+        {
+            return this.BeginExecuteSegmented(null, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to execute a query and return the results as a result segment.
+        /// </summary>
+        /// <param name="continuationToken">A continuation token returned by a previous listing operation.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginExecuteSegmented(ResultContinuation continuationToken, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<TElement>>(
+                (setResult) => this.ExecuteSegmentedImpl(continuationToken, setResult),
+                this.RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to execute a query and return the results as a result segment.
+        /// </summary>
+        /// <param name="asyncResult">The reference to the pending asynchronous request to finish.</param>
+        /// <returns>A result segment containing objects of type <typeparamref name="TElement"/>.</returns>
+        public ResultSegment<TElement> EndExecuteSegmented(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<TElement>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Expands the specified path.
+        /// </summary>
+        /// <param name="path">The path to expand.</param>
+        /// <returns>A new query with the expanded path.</returns>
+        public CloudTableQuery<TElement> Expand(string path)
+        {
+            return new CloudTableQuery<TElement>(this.query.Expand(path), RetryPolicy);
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through the collection.
+        /// </summary>
+        /// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.</returns>
+        public IEnumerator<TElement> GetEnumerator()
+        {
+            return this.Execute().GetEnumerator();
+        }
+
+        /// <summary>
+        /// Returns a <see cref="System.String"/> that represents this instance.
+        /// </summary>
+        /// <returns>A <see cref="System.String"/> that represents this instance.</returns>
+        public override string ToString()
+        {
+            return this.query.ToString();
+        }
+
+        /// <summary>
+        /// Returns an enumerator that can be used to iterate through a collection.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Collections.IEnumerator"/> that can be used to iterate through a collection.
+        /// </returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator() as IEnumerator;
+        }
+
+        /// <summary>
+        /// Executes the segmented impl.
+        /// </summary>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that executes the query and returns the first segment of results.</returns>
+        internal TaskSequence ExecuteSegmentedImpl(ResultContinuation continuationToken, Action<ResultSegment<TElement>> setResult)
+        {
+            var localQuery = this.query;
+
+            localQuery = RewriteQueryForTakeCount(localQuery, this.pagination);
+
+            localQuery = ApplyContinuationToQuery(continuationToken, localQuery);
+
+            var requestTask = localQuery.ExecuteAsync();
+
+            yield return requestTask;
+
+            try
+            {
+                var responseResult = requestTask.Result;
+                var response = responseResult as QueryOperationResponse;
+
+                ResultContinuation newContinuationToken = this.GetTableContinuationFromResponse(response);
+
+                List<TElement> listResult = new List<TElement>(responseResult.ToList());
+
+                ResultSegment.CreateResultSegment<TElement>(
+                    setResult,
+                    listResult,
+                    newContinuationToken,
+                    this.pagination,
+                    this.RetryPolicy,
+                    (scratch, continuationArg, setResultInnerArg) => this.ExecuteSegmentedImpl(continuationArg, setResultInnerArg));
+            }
+            catch (InvalidOperationException ex)
+            {
+                var dsce = CommonUtils.FindInnerDataServiceClientException(ex);
+
+                if (dsce == null)
+                {
+                    throw;
+                }
+
+                if ((HttpStatusCode)dsce.StatusCode == HttpStatusCode.NotFound)
+                {
+                    setResult(new ResultSegment<TElement>(new List<TElement>(), false, null, null));
+                }
+
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Rewrites the query for take count.
+        /// </summary>
+        /// <param name="localQuery">The local query.</param>
+        /// <param name="pagination">The pagination.</param>
+        /// <returns>The rewritten query.</returns>
+        private static DataServiceQuery<TElement> RewriteQueryForTakeCount(DataServiceQuery<TElement> localQuery, ResultPagination pagination)
+        {
+            int? nextRequestPageSize = pagination.GetNextRequestPageSize();
+
+            if (pagination.IsPagingEnabled &&
+                ((nextRequestPageSize != pagination.EffectivePageSize) ||
+                pagination.EffectivePageSize > TableServiceMaxResults))
+            {
+                var expression = localQuery.Expression as MethodCallExpression;
+                var adjustedTakeExpression = Expression.Call(
+                    expression.Object,
+                    expression.Method,
+                    expression.Arguments[0],
+                    Expression.Constant(Math.Min(nextRequestPageSize.Value, TableServiceMaxResults)));
+
+                return localQuery.Provider.CreateQuery<TElement>(adjustedTakeExpression) as DataServiceQuery<TElement>;
+            }
+
+            return localQuery;
+        }
+
+        /// <summary>
+        /// Applies the continuation to query.
+        /// </summary>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="localQuery">The local query.</param>
+        /// <returns>The modified query.</returns>
+        private static DataServiceQuery<TElement> ApplyContinuationToQuery(ResultContinuation continuationToken, DataServiceQuery<TElement> localQuery)
+        {
+            if (continuationToken != null)
+            {
+                if (continuationToken.NextPartitionKey != null)
+                {
+                    localQuery = localQuery.AddQueryOption(TableServiceNextPartitionKey, continuationToken.NextPartitionKey);
+                }
+
+                if (continuationToken.NextRowKey != null)
+                {
+                    localQuery = localQuery.AddQueryOption(TableServiceNextRowKey, continuationToken.NextRowKey);
+                }
+
+                if (continuationToken.NextTableName != null)
+                {
+                    localQuery = localQuery.AddQueryOption(TableServiceNextTableName, continuationToken.NextTableName);
+                }
+            }
+
+            return localQuery;
+        }
+
+        /// <summary>
+        /// Gets the query take count.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The take count of the query, if any.</returns>
+        private static int? GetQueryTakeCount(DataServiceQuery<TElement> query)
+        {
+            var expression = query.Expression as MethodCallExpression;
+
+            if (expression != null && expression.Method.Name == "Take")
+            {
+                var argument = expression.Arguments[1] as ConstantExpression;
+
+                if (argument != null)
+                {
+                    return (int)argument.Value;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the table continuation from response.
+        /// </summary>
+        /// <param name="response">The response.</param>
+        /// <returns>The continuation.</returns>
+        private ResultContinuation GetTableContinuationFromResponse(QueryOperationResponse response)
+        {
+            string nextPartitionKey;
+            string nextRowKey;
+            string nextTableName;
+
+            response.Headers.TryGetValue(TableServicePrefixForTableContinuation + TableServiceNextPartitionKey, out nextPartitionKey);
+            response.Headers.TryGetValue(TableServicePrefixForTableContinuation + TableServiceNextRowKey, out nextRowKey);
+            response.Headers.TryGetValue(TableServicePrefixForTableContinuation + TableServiceNextTableName, out nextTableName);
+
+            ResultContinuation newContinuationToken = new ResultContinuation()
+            {
+                NextPartitionKey = nextPartitionKey,
+                NextRowKey = nextRowKey,
+                NextTableName = nextTableName,
+                Type = ResultContinuation.ContinuationType.Table
+            };
+
+            return newContinuationToken;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/CommonUtils.cs b/microsoft-azure-api/StorageClient/CommonUtils.cs
new file mode 100644
index 0000000000000..2d4542febe12a
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/CommonUtils.cs
@@ -0,0 +1,342 @@
+//-----------------------------------------------------------------------
+// <copyright file="CommonUtils.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CommonUtils class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Data.Services.Client;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Net;
+    using System.Text;
+    using Protocol;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// A set of common utilities for use in verfication.
+    /// </summary>
+    internal static class CommonUtils
+    {
+        /// <summary>
+        /// Throws an exception if the string is empty or null.
+        /// </summary>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <param name="value">The value of the parameter.</param>
+        /// <exception cref="ArgumentException">Thrown if value is empty.</exception>
+        /// <exception cref="ArgumentNullException">Thrown if value is null.</exception>
+        internal static void AssertNotNullOrEmpty(string paramName, string value)
+        {
+            AssertNotNull(paramName, value);
+
+            if (string.IsNullOrEmpty(value))
+            {
+                throw new ArgumentException(SR.ArgumentEmptyError, paramName);
+            }
+        }
+
+        /// <summary>
+        /// Throw an exception if the value is null.
+        /// </summary>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <param name="value">The value of the parameter.</param>
+        /// <exception cref="ArgumentNullException">Thrown if value is null.</exception>
+        internal static void AssertNotNull(string paramName, object value)
+        {
+            if (value == null)
+            {
+                throw new ArgumentNullException(paramName); 
+            }
+        }
+
+        /// <summary>
+        /// Throw an exception indicating argument is out of range.
+        /// </summary>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <param name="value">The value of the parameter.</param>
+        internal static void ArgumentOutOfRange(string paramName, object value)
+        {
+            throw new ArgumentOutOfRangeException(paramName, value, SR.ArgumentOutOfRangeError);
+        }
+
+        /// <summary>
+        /// Throw an exception if the argument is out of bounds.
+        /// </summary>
+        /// <typeparam name="T">The type of the value.</typeparam>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <param name="val">The value of the parameter.</param>
+        /// <param name="min">The minimum value for the parameter.</param>
+        /// <param name="max">The maximum value for the parameter.</param>
+        internal static void AssertInBounds<T>(string paramName, T val, T min, T max)
+            where T : IComparable
+        {
+            if (val.CompareTo(min) < 0)
+            {
+                throw new ArgumentOutOfRangeException(String.Format(SR.ArgumentTooSmallError, paramName, min), paramName);
+            }
+
+            if (val.CompareTo(max) > 0)
+            {
+                throw new ArgumentOutOfRangeException(String.Format(SR.ArgumentTooLargeError, paramName, max), paramName);
+            }
+        }
+
+        /// <summary>
+        /// Combines AssertNotNullOrEmpty and AssertInBounds for convenience.
+        /// </summary>
+        /// <param name="paramName">The name of the parameter.</param>
+        /// <param name="canBeNullOrEmpty">Turns on or off null/empty checking.</param>
+        /// <param name="value">The value of the parameter.</param>
+        /// <param name="maxSize">The maximum size of value.</param>
+        internal static void CheckStringParameter(string paramName, bool canBeNullOrEmpty, string value, int maxSize)
+        {
+            if (!canBeNullOrEmpty)
+            {
+                AssertNotNullOrEmpty(value, paramName);
+            }
+
+            AssertInBounds(value, paramName.Length, 0, maxSize);
+        }
+
+        /// <summary>
+        /// Throws if the result segment does not have more results.
+        /// </summary>
+        /// <typeparam name="T">The type of the batch context.</typeparam>
+        /// <param name="result">The result segment to check.</param>
+        internal static void AssertSegmentResultNotComplete<T>(ResultSegment<T> result)
+        {
+            if (result != null && result.ContinuationToken == null)
+            {
+                throw new InvalidOperationException(SR.NoMoreResultsForSegmentCursor);
+            }
+        }
+
+        /// <summary>
+        /// Determines if a Uri requires path style addressing.
+        /// </summary>
+        /// <param name="uri">The Uri to check.</param>
+        /// <returns>Returns <c>true</c> if the Uri uses path style addressing; otherwise, <c>false</c>.</returns>
+        internal static bool UsePathStyleAddressing(Uri uri)
+        {
+            if (uri.HostNameType != UriHostNameType.Dns)
+            {
+                return true;
+            }
+
+            int[] wellKnownDevStorePorts = { 10000, 10001, 10002 };
+
+            foreach (var p in wellKnownDevStorePorts)
+            {
+                if (uri.Port == p)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Asserts the segment result not empty.
+        /// </summary>
+        /// <typeparam name="T">The type of the result segment.</typeparam>
+        /// <param name="result">The result.</param>
+        internal static void AssertSegmentResultNotEmpty<T>(ResultSegment<T> result)
+        {
+            if (result == null || result.Results == null)
+            {
+                throw new InvalidOperationException(SR.MustCallEndMoveNextSegmentFirst);
+            }
+        }
+
+        /// <summary>
+        /// Performs a 'magic enumerator' lazy segmented enumeration.
+        /// </summary>
+        /// <typeparam name="T">The type of the result.</typeparam>
+        /// <param name="impl">The task sequence generator that produces the first segment.</param>
+        /// <param name="retryPolicy">The retry policy to use.</param>
+        /// <returns>A 'magic enumerator' that makes requests when needed and chains segments accordingly.</returns>
+        [DebuggerNonUserCode]
+        internal static IEnumerable<T> LazyEnumerateSegmented<T>(Func<Action<ResultSegment<T>>, TaskSequence> impl, RetryPolicy retryPolicy)
+        {
+            var segment = TaskImplHelper.ExecuteImplWithRetry<ResultSegment<T>>(impl, retryPolicy);
+            CloudBlobDirectory cloudDirectoryInLastPartition = null;
+            T lastElement = default(T);
+
+            while (true)
+            {
+                foreach (var result in segment.Results)
+                {
+                    if (cloudDirectoryInLastPartition != null && result is CloudBlobDirectory)
+                    {
+                        var cloudBlobDirectory = result as CloudBlobDirectory;
+                        if (cloudDirectoryInLastPartition.Uri == cloudBlobDirectory.Uri)
+                        {
+                            continue;
+                        }
+                    }
+
+                    lastElement = result;
+                    yield return result;
+                }
+
+                if (!segment.HasMoreResults)
+                {
+                    break;
+                }
+
+                if (lastElement is CloudBlobDirectory)
+                {
+                    cloudDirectoryInLastPartition = lastElement as CloudBlobDirectory;
+                }
+
+                segment = segment.GetNext();
+            }
+        }
+
+        /// <summary>
+        /// Rounds up to seconds.
+        /// </summary>
+        /// <param name="timeSpan">The time span.</param>
+        /// <returns>The time rounded to seconds.</returns>
+        internal static int RoundUpToSeconds(this TimeSpan timeSpan)
+        {
+            return (int)Math.Ceiling(timeSpan.TotalSeconds);
+        }
+
+        /// <summary>
+        /// Rounds up to seconds.
+        /// </summary>
+        /// <param name="timeSpan">The time span.</param>
+        /// <returns>The time rounded to seconds.</returns>
+        internal static int RoundUpToSeconds(this TimeSpan? timeSpan)
+        {
+            return (int)Math.Ceiling(timeSpan.Value.TotalSeconds);
+        }
+
+        /// <summary>
+        /// Rounds up to milliseconds.
+        /// </summary>
+        /// <param name="timeSpan">The time span.</param>
+        /// <returns>The time rounded to milliseconds.</returns>
+        internal static int RoundUpToMilliseconds(this TimeSpan timeSpan)
+        {
+            return (int)Math.Ceiling(timeSpan.TotalMilliseconds);
+        }
+
+        /// <summary>
+        /// Rounds up to milliseconds.
+        /// </summary>
+        /// <param name="timeSpan">The time span.</param>
+        /// <returns>The time rounded to milliseconds.</returns>
+        internal static int RoundUpToMilliseconds(this TimeSpan? timeSpan)
+        {
+            return (int)Math.Ceiling(timeSpan.Value.TotalMilliseconds);
+        }
+
+        /// <summary>
+        /// When calling the Get() operation on a queue, the content of messages
+        /// returned in the REST protocol are represented as Base64-encoded strings.
+        /// This internal function transforms the Base64 representation into a byte array.
+        /// </summary>
+        /// <param name="str">The Base64-encoded string.</param>
+        /// <returns>The decoded bytes.</returns>
+        internal static byte[] GetContentFromBase64String(string str)
+        {
+            byte[] base64Content;
+
+            if (string.IsNullOrEmpty(str))
+            {
+                // we got a message with an empty <MessageText> element
+                base64Content = Encoding.UTF8.GetBytes(string.Empty);
+            }
+            else
+            {
+                base64Content = Convert.FromBase64String(str);
+            }
+
+            return base64Content;
+        }
+
+        /// <summary>
+        /// Applies the request optimizations such as disabling buffering and 100 continue.
+        /// </summary>
+        /// <param name="request">The request to be modified.</param>
+        /// <param name="length">The length of the content, -1 if the content length is not settable.</param>
+        internal static void ApplyRequestOptimizations(HttpWebRequest request, long length)
+        {
+            if (length >= Constants.DefaultBufferSize)
+            {
+                request.AllowWriteStreamBuffering = false;
+            }
+
+            // Set the length of the stream if the value is known
+            if (length >= 0)
+            {
+                request.ContentLength = length;
+            }
+
+            // Disable the Expect 100-Continue
+            request.ServicePoint.Expect100Continue = false;
+        }
+
+        /// <summary>
+        /// Look for an inner exception of type DataServiceClientException. Different versions of Sytem.Data.Services.Client
+        /// have different levels of wrapping of a DataServiceClientException.
+        /// </summary>
+        /// <param name="exception">The exception.</param>
+        /// <returns>The found exception or null.</returns>
+        internal static DataServiceClientException FindInnerDataServiceClientException(Exception exception)
+        {
+            DataServiceClientException dsce = null;
+
+            while (exception != null)
+            {
+                dsce = exception as DataServiceClientException;
+
+                if (dsce != null)
+                {
+                    break;
+                }
+
+                exception = exception.InnerException;
+            }
+
+            return dsce;
+        }
+
+        /// <summary>
+        /// Asserts the type of the continuation.
+        /// </summary>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="continuationType">Type of the continuation.</param>
+        internal static void AssertContinuationType(ResultContinuation continuationToken, ResultContinuation.ContinuationType continuationType)
+        {
+            if (continuationToken != null)
+            {
+                if (!(continuationToken.Type == ResultContinuation.ContinuationType.None || continuationToken.Type == continuationType))
+                {
+                    string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.InvalidContinuationType, continuationToken.Type, continuationType);
+                    throw new InvalidOperationException(errorMessage);
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/ContainerListingDetails.cs b/microsoft-azure-api/StorageClient/ContainerListingDetails.cs
new file mode 100644
index 0000000000000..778893ce39c33
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ContainerListingDetails.cs
@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------
+// <copyright file="ContainerListingDetails.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ContainerListingDetails enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Specifies which details to include when listing the containers in this storage account.
+    /// </summary>
+    [Flags]
+    public enum ContainerListingDetails
+    {
+        /// <summary>
+        /// No additional details.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        /// Retrieve container metadata.
+        /// </summary>
+        Metadata = 0x1,
+
+        /// <summary>
+        /// Retrieve all available details.
+        /// </summary>
+        All = 0x1
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/DeleteSnapshotsOption.cs b/microsoft-azure-api/StorageClient/DeleteSnapshotsOption.cs
new file mode 100644
index 0000000000000..d4c4916f26051
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/DeleteSnapshotsOption.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="DeleteSnapshotsOption.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the DeleteSnapshotsOption enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// The set of options describing delete operation.
+    /// </summary>
+    public enum DeleteSnapshotsOption
+    {
+        /// <summary>
+        /// Delete blobs but not snapshots.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// Delete the blob and its snapshots.
+        /// </summary>
+        IncludeSnapshots,
+
+        /// <summary>
+        /// Delete the blob's snapshots only.
+        /// </summary>
+        DeleteSnapshotsOnly
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/EventHelper.cs b/microsoft-azure-api/StorageClient/EventHelper.cs
new file mode 100644
index 0000000000000..f9c1dc5fc0fc6
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/EventHelper.cs
@@ -0,0 +1,137 @@
+//-----------------------------------------------------------------------
+// <copyright file="EventHelper.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the EventHelper class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Net;
+    using Protocol;
+
+    /// <summary>
+    /// Contains methods for dealing with events.
+    /// </summary>
+    internal static class EventHelper
+    {
+        /// <summary>
+        /// This sets the event handler with request and response data and 
+        /// translates storage exceptions.
+        /// </summary>
+        /// <param name="req">The request.</param>
+        /// <param name="handler">The handler.</param>
+        /// <param name="sender">The sender.</param>
+        /// <returns>The processed response.</returns>
+        internal static WebResponse ProcessWebResponseSync(WebRequest req,  EventHandler<ResponseReceivedEventArgs> handler, object sender)
+        {
+            WebResponse response = null;
+            Exception exception = null;
+            try
+            {
+                response = req.GetResponse();
+                return response as HttpWebResponse;
+            }
+            catch (WebException e)
+            {
+                response = e.Response;
+                exception = Utilities.TranslateWebException(e);
+                throw exception;
+            }
+            finally
+            {
+                EventHelper.OnResponseReceived(req, response, handler, sender, exception);
+            }
+        }        
+        
+        /// <summary>
+        /// This sets the event handler with request and response data and 
+        /// translates storage exceptions.
+        /// </summary>
+        /// <param name="req">The request.</param>
+        /// <param name="asyncResult">The async result.</param>
+        /// <param name="handler">The handler.</param>
+        /// <param name="sender">The sender.</param>
+        /// <returns>The processed response.</returns>
+        internal static WebResponse ProcessWebResponse(WebRequest req, IAsyncResult asyncResult, EventHandler<ResponseReceivedEventArgs> handler, object sender)
+        {
+            WebResponse response = null;
+            Exception exception = null;
+            try
+            {
+                response = req.EndGetResponse(asyncResult);
+                return response as HttpWebResponse;
+            }
+            catch (WebException e)
+            {
+                response = e.Response;
+                exception = Utilities.TranslateWebException(e);
+                throw exception;
+            }
+            finally
+            {
+                EventHelper.OnResponseReceived(req, response, handler, sender, exception);
+            }
+        }
+
+        /// <summary>
+        /// Set the event handler.
+        /// </summary>
+        /// <param name="req">The request.</param>
+        /// <param name="webResponse">The web response.</param>
+        /// <param name="eventHandler">The event handler.</param>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The exception.</param>
+        private static void OnResponseReceived(
+            WebRequest req,
+            WebResponse webResponse, 
+            EventHandler<ResponseReceivedEventArgs> eventHandler,
+            object sender,
+            Exception e)
+        {
+            // Get a Thread safe refence. May be not necessary given that its a function argument.            
+            EventHandler<ResponseReceivedEventArgs> temp = eventHandler;
+
+            if (temp != null)
+            {
+                if (webResponse != null)
+                {
+                    HttpWebResponse response = webResponse as HttpWebResponse;
+
+                    if (response != null)
+                    {
+                        string requestId = BlobResponse.GetRequestId(response);
+                        var eventArgs = new ResponseReceivedEventArgs()
+                        {
+                            RequestId = requestId,
+                            RequestHeaders = req.Headers,
+                            RequestUri = req.RequestUri,
+                            ResponseHeaders = response.Headers,
+                            StatusCode = response.StatusCode,
+                            StatusDescription = response.StatusDescription,
+                            Exception = e
+                        };
+
+                        temp(sender, eventArgs);
+                    }
+                }
+            }
+        }
+    }
+}
+
diff --git a/microsoft-azure-api/StorageClient/IListBlobItem.cs b/microsoft-azure-api/StorageClient/IListBlobItem.cs
new file mode 100644
index 0000000000000..a70ec1460574e
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/IListBlobItem.cs
@@ -0,0 +1,48 @@
+//-----------------------------------------------------------------------
+// <copyright file="IListBlobItem.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the IListBlobItem interface.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Represents an item that may be returned by a blob listing operation.
+    /// </summary>
+    public interface IListBlobItem
+    {
+        /// <summary>
+        /// Gets the URI to the blob item.
+        /// </summary>
+        /// <value>The blob item's URI.</value>
+        Uri Uri { get; }
+
+        /// <summary>
+        /// Gets the blob item's parent.
+        /// </summary>
+        /// <value>The blob item's parent.</value>
+        CloudBlobDirectory Parent { get; }
+
+        /// <summary>
+        /// Gets the blob item's container.
+        /// </summary>
+        /// <value>The blob item's container.</value>
+        CloudBlobContainer Container { get; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/LeaseStatus.cs b/microsoft-azure-api/StorageClient/LeaseStatus.cs
new file mode 100644
index 0000000000000..f343525859146
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/LeaseStatus.cs
@@ -0,0 +1,45 @@
+//-----------------------------------------------------------------------
+// <copyright file="LeaseStatus.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the LeaseStatus enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System.ComponentModel;
+
+    /// <summary>
+    /// The lease status of the blob.
+    /// </summary>
+    public enum LeaseStatus
+    {
+        /// <summary>
+        /// The lease status is not specified.
+        /// </summary>
+        Unspecified,
+
+        /// <summary>
+        /// The blob is locked for exclusive-write access.
+        /// </summary>
+        Locked,
+
+        /// <summary>
+        /// The blob is available to be locked for exclusive write access.
+        /// </summary>
+        Unlocked
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/ListBlockItem.cs b/microsoft-azure-api/StorageClient/ListBlockItem.cs
new file mode 100644
index 0000000000000..2daea975f751a
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ListBlockItem.cs
@@ -0,0 +1,55 @@
+//-----------------------------------------------------------------------
+// <copyright file="ListBlockItem.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ListBlockItem class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a block retrieved from the blob's block list.
+    /// </summary>
+    public class ListBlockItem
+    {
+        /// <summary>
+        /// Gets the name of the block.
+        /// </summary>
+        /// <value>The block name.</value>
+        public string Name { get; internal set; }
+
+        /// <summary>
+        /// Gets the size of block in bytes.
+        /// </summary>
+        /// <value>The block size.</value>
+        public long Size { get; internal set; }
+
+        /// <summary>
+        /// Gets a value indicating whether or not the block has been committed.
+        /// </summary>
+        /// <value><c>True</c> if the block has been committed; otherwise, <c>false</c>.</value>
+        public bool Committed { get; internal set; }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/MessageUpdateFields.cs b/microsoft-azure-api/StorageClient/MessageUpdateFields.cs
new file mode 100644
index 0000000000000..038cc6a8dd6c6
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/MessageUpdateFields.cs
@@ -0,0 +1,42 @@
+//-----------------------------------------------------------------------
+// <copyright file="MessageUpdateFields.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the MessageUpdateFields enum.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Enumeration controlling the options for updating queue messages.
+    /// </summary>
+    [Flags]
+    public enum MessageUpdateFields
+    {
+        /// <summary>
+        /// Update the message visibility timeout.
+        /// This is required for calls to UpdateMessage in version 2011-08-18.
+        /// </summary>
+        Visibility = 0x1,
+
+        /// <summary>
+        /// Update the message content.
+        /// </summary>
+        Content = 0x2
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/NavigationHelper.cs b/microsoft-azure-api/StorageClient/NavigationHelper.cs
new file mode 100644
index 0000000000000..356f74e6aba25
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/NavigationHelper.cs
@@ -0,0 +1,431 @@
+//-----------------------------------------------------------------------
+// <copyright file="NavigationHelper.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the NavigationHelper class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Globalization;
+
+    /// <summary>
+    /// Contains methods for dealing with navigation.
+    /// </summary>
+    internal static class NavigationHelper
+    {
+        /// <summary>
+        /// The name of the root container.
+        /// </summary>
+        public const string RootContainerName = "$root";
+
+        /// <summary>
+        /// Used in address parsing.
+        /// </summary>
+        public const string Slash = "/";
+
+        /// <summary>
+        /// Used in address parsing.
+        /// </summary>
+        public const string Dot = ".";
+
+        /// <summary>
+        /// Used in address parsing.
+        /// </summary>
+        public const char SlashChar = '/';
+
+        /// <summary>
+        /// Used to split string on slash.
+        /// </summary>
+        public static readonly char[] SlashAsSplitOptions = new char[] { '/' };
+
+        /// <summary>
+        /// Used to split hostname.
+        /// </summary>
+        public static readonly char[] DotAsSplitOptions = new char[] { '.' };
+
+        /// <summary>
+        /// Retrieves the container part of a storage Uri, or "$root" if the container is implicit.
+        /// </summary>
+        /// <param name="blobAddress">The blob address.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> use path style Uris.</param>
+        /// <returns>Name of the container.</returns>
+        /// <remarks>
+        /// The trailing slash is always removed.
+        /// <example>
+        /// GetContainerName(new Uri("http://test.blob.core.windows.net/mycontainer/myfolder/myblob")) will return "mycontainer"
+        /// GetConatinerName(new Uri("http://test.blob.core.windows.net/mycontainer/")) will return "mycontainer"
+        /// GetConatinerName(new Uri("http://test.blob.core.windows.net/myblob")) will return "$root"
+        /// GetConatinerName(new Uri("http://test.blob.core.windows.net/")) will throw ArgumentException
+        /// </example>
+        /// </remarks>
+        internal static string GetContainerName(Uri blobAddress, bool usePathStyleUris)
+        {
+            string containerName;
+            string blobName;
+
+            GetContainerNameAndBlobName(blobAddress, usePathStyleUris, out containerName, out blobName);
+
+            return containerName;
+        }
+
+        /// <summary>
+        /// Retrieves the blob part of a storage Uri.
+        /// </summary>
+        /// <param name="blobAddress">The blob address.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> use path style Uris.</param>
+        /// <returns>The name of the blob.</returns>
+        internal static string GetBlobName(Uri blobAddress, bool usePathStyleUris)
+        {
+            string containerName;
+            string blobName;
+
+            GetContainerNameAndBlobName(blobAddress, usePathStyleUris, out containerName, out blobName);
+
+            return blobName;
+        }
+
+        /// <summary>
+        /// Retreives the complete container address from a storage Uri
+        /// Example GetContainerAddress(new Uri("http://test.blob.core.windows.net/mycontainer/myfolder/myblob"))
+        /// will return http://test.blob.core.windows.net/mycontainer.
+        /// </summary>
+        /// <param name="blobAddress">The BLOB address.</param>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <returns>Uri of the container.</returns>
+        internal static string GetContainerAddress(Uri blobAddress, bool usePathStyleUris)
+        {
+            string containerName;
+            Uri containerAddress;
+            GetContainerNameAndAddress(blobAddress, usePathStyleUris, out containerName, out containerAddress);
+
+            return containerAddress.AbsoluteUri;
+        }
+
+        /// <summary>
+        /// Retreives the parent name from a storage Uri.
+        /// </summary>
+        /// <param name="blobAddress">The BLOB address.</param>
+        /// <param name="delimiter">The delimiter.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> use path style Uris.</param>
+        /// <returns>The name of the parent.</returns>
+        /// <remarks>
+        /// Adds the trailing delimiter as the prefix returned by the storage REST api always contains the delimiter.
+        /// </remarks>
+        /// <example>
+        /// GetParentName(new Uri("http://test.blob.core.windows.net/mycontainer/myfolder/myblob", "/")) will return "/mycontainer/myfolder/"
+        /// GetParentName(new Uri("http://test.blob.core.windows.net/mycontainer/myfolder|myblob", "|") will return "/mycontainer/myfolder|"
+        /// GetParentName(new Uri("http://test.blob.core.windows.net/mycontainer/myblob", "/") will return "/mycontainer/"
+        /// GetParentName(new Uri("http://test.blob.core.windows.net/mycontainer/", "/") will return "/mycontainer/"
+        /// </example>
+        internal static string GetParentName(Uri blobAddress, string delimiter, bool usePathStyleUris)
+        {
+            CommonUtils.AssertNotNull("blobAbsoluteUriString", blobAddress);
+            CommonUtils.AssertNotNullOrEmpty("delimiter", delimiter);
+
+            string containerName;
+            Uri containerUri;
+            GetContainerNameAndAddress(blobAddress, usePathStyleUris, out containerName, out containerUri);
+
+            // Get the blob path as the rest of the Uri
+            var blobPathUri = containerUri.MakeRelativeUri(blobAddress);
+            var blobPath = blobPathUri.OriginalString;
+
+            if (blobPath.EndsWith(delimiter))
+            {
+                blobPath = blobPath.Substring(0, blobPath.Length - delimiter.Length);
+            }
+
+            string parentName = null;
+
+            if (string.IsNullOrEmpty(blobPath))
+            {
+                // Case 1 /<ContainerName>[Delimiter]*? => /<ContainerName>
+                // Parent of container is container itself
+                parentName = containerName + delimiter;
+            }
+            else
+            {
+                var parentLength = blobPath.LastIndexOf(delimiter);
+
+                if (parentLength <= 0)
+                {
+                    // Case 2 /<Container>/<folder>
+                    // Parent of a folder is container
+                    parentName = containerName + delimiter;
+                }
+                else
+                {
+                    // Case 3 /<Container>/<folder>/[<subfolder>/]*<BlobName>
+                    // Parent of blob is folder
+                    parentName = blobPath.Substring(0, parentLength + delimiter.Length);
+                }
+            }
+
+            return parentName;
+        }
+
+        /// <summary>
+        /// Retrieves the parent address for a blob Uri.
+        /// </summary>
+        /// <param name="blobAddress">The BLOB address.</param>
+        /// <param name="delimiter">The delimiter.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> use path style Uris.</param>
+        /// <returns>The address of the parent.</returns>
+        /// <example>
+        /// GetParentName(new Uri("http://test.blob.core.windows.net/mycontainer/myfolder/myblob", null))
+        /// will return "http://test.blob.core.windows.net/mycontainer/myfolder/"
+        /// </example>
+        internal static string GetParentAddress(Uri blobAddress, string delimiter, bool usePathStyleUris)
+        {
+            var parentName = GetParentName(blobAddress, delimiter, usePathStyleUris);
+            Uri parentUri = NavigationHelper.AppendPathToUri(new Uri(NavigationHelper.GetServiceClientBaseAddress(blobAddress, usePathStyleUris)), parentName);
+            return parentUri.AbsoluteUri;
+        }
+
+        /// <summary>
+        /// Get service client address from a complete Uri.
+        /// </summary>
+        /// <param name="address">Complete address of the resource.</param>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <returns>Uri of the service client.</returns>
+        /// <example>
+        /// GetServiceClientBaseAddress("http://testaccount.blob.core.windows.net/testconatiner/blob1") 
+        /// returns "http://testaccount.blob.core.windows.net"
+        /// </example>
+        internal static string GetServiceClientBaseAddress(string address, bool? usePathStyleUris)
+        {
+            return GetServiceClientBaseAddress(new Uri(address), usePathStyleUris);
+        }
+
+        /// <summary>
+        /// Gets the service client base address.
+        /// </summary>
+        /// <param name="addressUri">The address Uri.</param>
+        /// <param name="usePathStyleUris">The use path style Uris.</param>
+        /// <returns>The base address of the client.</returns>
+        internal static string GetServiceClientBaseAddress(Uri addressUri, bool? usePathStyleUris)
+        {
+            if (usePathStyleUris == null)
+            {
+                // Automatically determine whether to use path style vs host style uris
+                usePathStyleUris = CommonUtils.UsePathStyleAddressing(addressUri);
+            }
+
+            if (usePathStyleUris.Value)
+            {
+                // Path style uri
+                string[] segments = addressUri.Segments;
+                if (segments.Length < 2)
+                {
+                    string error = string.Format(CultureInfo.CurrentCulture, SR.PathStyleUriMissingAccountNameInformation, addressUri.AbsoluteUri);
+                    throw new ArgumentException("address", error);
+                }
+
+                string completeAddress = addressUri.GetLeftPart(UriPartial.Authority) + Slash + segments[1];
+                completeAddress = completeAddress.Trim(SlashChar);
+                return completeAddress;
+            }
+            else
+            {
+                return addressUri.GetLeftPart(UriPartial.Authority);
+            }
+        }
+
+        /// <summary>
+        /// Appends a path to a Uri correctly using "/" as separator.
+        /// </summary>
+        /// <param name="uri">The base Uri.</param>
+        /// <param name="relativeOrAbslouteUri">The relative or absloute URI.</param>
+        /// <returns>The appended Uri.</returns>
+        /// <example>
+        /// AppendPathToUri(new Uri("http://test.blob.core.windows.net/test", "abc")
+        /// will return "http://test.blob.core.windows.net/test/abc"
+        /// AppendPathToUri(new Uri("http://test.blob.core.windows.net/test"), "http://test.blob.core.windows.net/test/abc")
+        /// will return "http://test.blob.core.windows.net/test/abc"
+        /// </example>
+        internal static Uri AppendPathToUri(Uri uri, string relativeOrAbslouteUri)
+        {
+            return AppendPathToUri(uri, relativeOrAbslouteUri, NavigationHelper.Slash);
+        }
+
+        /// <summary>
+        /// Append a relative path to a Uri, handling traling slashes appropiately.
+        /// </summary>
+        /// <param name="uri">The base Uri.</param>
+        /// <param name="relativeOrAbslouteUri">The relative or absloute URI.</param>
+        /// <param name="sep">The seperator.</param>
+        /// <returns>The appended Uri.</returns>
+        internal static Uri AppendPathToUri(Uri uri, string relativeOrAbslouteUri, string sep)
+        {
+            Uri relativeUri;
+
+            // Because of URI's Scheme, URI.TryCreate() can't differentiate a string with colon from an absolute URI. 
+            // A workaround is added here to verify if a given string is an absolute URI.
+            if (Uri.TryCreate(relativeOrAbslouteUri, UriKind.Absolute, out relativeUri) && (relativeUri.Scheme == "http" || relativeUri.Scheme == "https"))
+            {
+                // Handle case if relPath is an absolute Uri
+                if (uri.IsBaseOf(relativeUri))
+                {
+                    return relativeUri;
+                }
+                else
+                {
+                    // Happens when using fiddler, DNS aliases, or potentially NATs
+                    var absoluteUri = new Uri(relativeOrAbslouteUri);
+                    return new Uri(uri, absoluteUri.AbsolutePath);
+                }
+            }
+
+            var ub = new UriBuilder(uri);
+            string appendString = null;
+            if (ub.Path.EndsWith(sep))
+            {
+                appendString = relativeOrAbslouteUri;
+            }
+            else
+            {
+                appendString = sep + relativeOrAbslouteUri;
+            }
+
+            string escapedRelativeOrAbslouteUri = Uri.EscapeUriString(appendString);
+            ub.Path += escapedRelativeOrAbslouteUri;
+
+            return ub.Uri;
+        }
+
+        /// <summary>
+        /// Get container name from address for styles of paths
+        /// Eg: http://test.blob.core.windows.net/container/blob =&gt; container
+        /// http://127.0.0.1:10000/test/container/blob =&gt; container.
+        /// </summary>
+        /// <param name="uri">The container Uri.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> use path style Uris.</param>
+        /// <returns>The container name.</returns>
+        internal static string GetContainerNameFromContainerAddress(Uri uri, bool usePathStyleUris)
+        {
+            if (usePathStyleUris)
+            {
+                string[] parts = uri.AbsolutePath.Split(NavigationHelper.SlashAsSplitOptions);
+
+                if (parts.Length < 3)
+                {
+                    string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.MissingAccountInformationInUri, uri.AbsoluteUri);
+                    throw new InvalidOperationException(errorMessage);
+                }
+
+                return parts[2];
+            }
+            else
+            {                
+                return uri.AbsolutePath.Substring(1);
+            }
+        }
+
+        /// <summary>
+        /// Gets the canonical path from creds.
+        /// </summary>
+        /// <param name="credentials">The credentials.</param>
+        /// <param name="absolutePath">The absolute path.</param>
+        /// <returns>The canonical path.</returns>
+        internal static string GetCanonicalPathFromCreds(StorageCredentials credentials, string absolutePath)
+        {
+            string account = credentials.AccountName;
+
+            if (account == null)
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.CannotCreateSASSignatureForGivenCred);
+                throw new InvalidOperationException(errorMessage);
+            }
+
+            return NavigationHelper.Slash + account + absolutePath;
+        }
+
+        /// <summary>
+        /// Similar to getting container name from Uri.
+        /// </summary>
+        /// <param name="uri">The queue Uri.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> use path style Uris.</param>
+        /// <returns>The queue name.</returns>
+        internal static string GetQueueNameFromUri(Uri uri, bool usePathStyleUris)
+        {
+            return GetContainerNameFromContainerAddress(uri, usePathStyleUris);
+        }
+
+        /// <summary>
+        /// Retrieve the container address and address.
+        /// </summary>
+        /// <param name="blobAddress">The BLOB address.</param>
+        /// <param name="usePathStyleUris">True to use path style Uris.</param>
+        /// <param name="containerName">Name of the container.</param>
+        /// <param name="containerUri">The container URI.</param>
+        private static void GetContainerNameAndAddress(Uri blobAddress, bool usePathStyleUris, out string containerName, out Uri containerUri)
+        {
+            containerName = GetContainerName(blobAddress, usePathStyleUris);
+            containerUri = NavigationHelper.AppendPathToUri(new Uri(GetServiceClientBaseAddress(blobAddress, usePathStyleUris)), containerName);
+        }
+
+        /// <summary>
+        /// Retrieve the container name and the blob name from a blob address.
+        /// </summary>
+        /// <param name="blobAddress">The blob address.</param>
+        /// <param name="usePathStyleUris">If set to <c>true</c> use path style Uris.</param>
+        /// <param name="containerName">The resulting container name.</param>
+        /// <param name="blobName">The resulting blob name.</param>
+        private static void GetContainerNameAndBlobName(Uri blobAddress, bool usePathStyleUris, out string containerName, out string blobName)
+        {
+            CommonUtils.AssertNotNull("blobAddress", blobAddress);
+
+            var addressParts = blobAddress.Segments;
+
+            int containerIndex = usePathStyleUris ? 2 : 1;
+            int firstBlobIndex = containerIndex + 1;
+
+            if (addressParts.Length - 1 < containerIndex)
+            {
+                // No reference appears to any container or blob
+                string error = string.Format(CultureInfo.CurrentCulture, SR.MissingContainerInformation, blobAddress);
+                throw new ArgumentException(error, "blobAddress");
+            }
+            else if (addressParts.Length - 1 == containerIndex)
+            {
+                // This is either the root directory of a container or a blob in the root container
+                string containerOrBlobName = addressParts[containerIndex];
+                if (containerOrBlobName[containerOrBlobName.Length - 1] == SlashChar)
+                {
+                    // This is the root directory of a container
+                    containerName = containerOrBlobName.Trim(SlashChar);
+                    blobName = string.Empty;
+                }
+                else
+                {
+                    // This is a blob implicitly in the root container
+                    containerName = RootContainerName;
+                    blobName = containerOrBlobName;
+                }
+            }
+            else
+            {
+                // This is a blob in an explicit container
+                containerName = addressParts[containerIndex].Trim(SlashChar);
+                string[] blobNameSegments = new string[addressParts.Length - firstBlobIndex];
+                Array.Copy(addressParts, firstBlobIndex, blobNameSegments, 0, blobNameSegments.Length);
+                blobName = string.Concat(blobNameSegments);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/PageRange.cs b/microsoft-azure-api/StorageClient/PageRange.cs
new file mode 100644
index 0000000000000..d368ddd318e0b
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/PageRange.cs
@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+// <copyright file="PageRange.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the PageRange class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a range of pages in a page blob.
+    /// </summary>
+    public class PageRange
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PageRange"/> class.
+        /// </summary>
+        /// <param name="start">The starting offset.</param>
+        /// <param name="end">The ending offset.</param>
+        public PageRange(long start, long end)
+        {
+            this.StartOffset = start;
+            this.EndOffset = end;
+        }
+
+        /// <summary>
+        /// Gets the starting offset of the page range.
+        /// </summary>
+        /// <value>The starting offset.</value>
+        public long StartOffset { get; internal set; }
+
+        /// <summary>
+        /// Gets the ending offset of the page range.
+        /// </summary>
+        /// <value>The ending offset.</value>
+        public long EndOffset { get; internal set; }
+
+        /// <summary>
+        /// Returns the content of the page range as a string.
+        /// </summary>
+        /// <returns>The content of the page range.</returns>
+        public override string ToString()
+        {
+            return String.Format("bytes={0}-{1}", this.StartOffset, this.EndOffset);
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/ParallelUpload.cs b/microsoft-azure-api/StorageClient/ParallelUpload.cs
new file mode 100644
index 0000000000000..bbd40dcc1c0f9
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ParallelUpload.cs
@@ -0,0 +1,345 @@
+//-----------------------------------------------------------------------
+// <copyright file="ParallelUpload.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ParallelUpload class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Security.Cryptography;
+    using System.Threading;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Class used to upload blocks for a blob in parallel.
+    /// </summary>
+    /// <remarks>The parallelism factor is configurable at the CloudBlobClient.</remarks>
+    internal class ParallelUpload
+    {
+        /// <summary>
+        /// Stores the block size.
+        /// </summary>
+        private long blockSize;
+
+        /// <summary>
+        /// Stores the blob we're uploading.
+        /// </summary>
+        private CloudBlockBlob blob;
+
+        /// <summary>
+        /// Stores the request options to use.
+        /// </summary>
+        private BlobRequestOptions options;
+
+        /// <summary>
+        /// Stores the blob's hash.
+        /// </summary>
+        private MD5 blobHash;
+
+        /// <summary>
+        /// Stores the source stream to upload from.
+        /// </summary>
+        private Stream sourceStream;
+
+        /// <summary>
+        /// Stores the dispensized stream size.
+        /// </summary>
+        private long dispensizedStreamSize;
+
+        /// <summary>
+        /// Bound on number of parallel active tasks (threads).
+        /// </summary>
+        private int parellelism;
+
+        /// <summary>
+        /// The list of uploaded blocks.
+        /// </summary>
+        private List<string> blockList;
+
+        /// <summary>
+        /// Number of block creation tasks.
+        /// </summary>
+        private int producerTasksCreated;
+
+        /// <summary>
+        /// Number of block upload tasks created.
+        /// </summary>
+        private int consumerTasksCreated;
+
+        /// <summary>
+        /// Number of dispenser calls.
+        /// </summary>
+        private int dispenserCallCount;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ParallelUpload"/> class.
+        /// </summary>
+        /// <param name="source">The source stream.</param>
+        /// <param name="options">The request options.</param>
+        /// <param name="blockSize">The block size to use.</param>
+        /// <param name="blob">The blob to upload to.</param>
+        internal ParallelUpload(Stream source, BlobRequestOptions options, long blockSize, CloudBlockBlob blob)
+        {
+            this.sourceStream = source;
+            this.blockSize = blockSize;
+            this.options = options;
+            this.dispensizedStreamSize = 0;
+            this.blob = blob;
+            this.blobHash = MD5.Create();
+            this.blockList = new List<string>();
+            this.parellelism = this.GetParallelismFactor();
+        }
+
+        /// <summary>
+        /// Perform a parallel upload of blocks for a blob from a given stream.
+        /// </summary>
+        /// <param name="uploadFunc">The upload func.</param>
+        /// <returns>A <see cref="TaskSequence"/> that uploads the blob in parallel.</returns>
+        /// <remarks>
+        /// The operation is done as a series of alternate producer and consumer tasks. The producer tasks dispense out
+        /// chunks of source stream as fixed size blocks. This is done in serial order on a thread using InvokeTaskSequence's
+        /// serial execution. The consumer tasks upload each block in parallel on multiple thread. The producer thread waits
+        /// for at least one consumer task to finish before adding more producer tasks. The producer thread quits when no
+        /// more data can be read from the stream and no other pending consumer tasks.
+        /// </remarks>
+        internal TaskSequence ParallelExecute(
+            Func<SmallBlockMemoryStream, string, string, BlobRequestOptions, Task<NullTaskReturn>> uploadFunc)
+        {
+            bool moreToUpload = true;
+            List<IAsyncResult> asyncResults = new List<IAsyncResult>();
+
+            Random rand = new Random();
+            long blockIdSequenceNumber = (long)rand.Next() << 32;
+            blockIdSequenceNumber += rand.Next();
+
+            do
+            {
+                int currentPendingTasks = asyncResults.Count;
+
+                // Step 1 
+                // Create producer tasks in a serial order as stream can only be read sequentially
+                for (int i = currentPendingTasks; i < this.parellelism && moreToUpload; i++)
+                {
+                    string blockId = null;
+                    string blockHash = null;
+                    SmallBlockMemoryStream blockAsStream = null;
+                    blockIdSequenceNumber++;
+
+                    InvokeTaskSequenceTask producerTask = new InvokeTaskSequenceTask(() =>
+                        this.DispenseBlockStream(
+                        blockIdSequenceNumber,
+                            (stream, id, hashVal) =>
+                            {
+                                blockAsStream = stream;
+                                blockId = id;
+                                blockHash = hashVal;
+                            }));
+
+                    yield return producerTask;
+
+                    this.producerTasksCreated++;
+
+                    var scatch = producerTask.Result;
+
+                    if (blockAsStream == null)
+                    {
+                        TraceHelper.WriteLine("No more upload tasks");
+                        moreToUpload = false;
+                    }
+                    else
+                    {
+                        // Step 2
+                        // Fire off consumer tasks that may finish on other threads;                        
+                        var task = uploadFunc(blockAsStream, blockId, blockHash, this.options);
+                        IAsyncResult asyncresult = task.ToAsyncResult(null, null);
+                        this.consumerTasksCreated++;
+                        
+                        asyncResults.Add(asyncresult);
+                    }
+                }
+
+                // Step 3
+                // Wait for 1 or more consumer tasks to finish inorder to bound set of parallel tasks
+                if (asyncResults.Count > 0)
+                {
+                    int waitTimeout = GetWaitTimeout(this.options);
+
+                    TraceHelper.WriteLine("Starting wait");
+
+                    int waitResult = WaitHandle.WaitAny(asyncResults.Select(result => result.AsyncWaitHandle).ToArray(), waitTimeout);
+                    
+                    TraceHelper.WriteLine("Ending wait");
+
+                    if (waitResult == WaitHandle.WaitTimeout)
+                    {
+                        throw TimeoutHelper.ThrowTimeoutError(this.options.Timeout.Value);
+                    }
+
+                    CompleteAsyncresult(asyncResults, waitResult);
+
+                    // Optimize away any other completed tasks
+                    for (int index = 0; index < asyncResults.Count; index++)
+                    {
+                        IAsyncResult result = asyncResults[index];
+                        if (result.IsCompleted)
+                        {
+                            CompleteAsyncresult(asyncResults, index);
+                            index--;
+                        }
+                    }
+                }
+            }
+            while (moreToUpload || asyncResults.Count != 0);
+
+            TraceHelper.WriteLine(
+                "Total producer tasks created {0}, consumer tasks created {1} ",
+                this.producerTasksCreated,
+                this.consumerTasksCreated);
+
+            var commitTask = TaskImplHelper.GetRetryableAsyncTask(this.CommitBlob, this.options.RetryPolicy);
+
+            yield return commitTask;
+            var commitTaskResult = commitTask.Result;
+        }
+
+        /// <summary>
+        /// Completes the asyncresult.
+        /// </summary>
+        /// <param name="asyncResults">The async results.</param>
+        /// <param name="index">The index.</param>
+        private static void CompleteAsyncresult(List<IAsyncResult> asyncResults, int index)
+        {
+            IAsyncResult signalledResult = asyncResults[index];
+
+            // NO locking necessary as they happen on the singleton producer thread
+            asyncResults.RemoveAt(index);
+            TaskImplHelper.EndImpl(signalledResult);
+        }
+
+        /// <summary>
+        /// Gets the wait timeout.
+        /// </summary>
+        /// <param name="options">The options.</param>
+        /// <returns>The wait timeout.</returns>
+        private static int GetWaitTimeout(BlobRequestOptions options)
+        {
+            if (options.Timeout.HasValue)
+            {
+                return options.Timeout.RoundUpToMilliseconds();
+            }
+
+            return Timeout.Infinite;
+        }
+
+        /// <summary>
+        /// Upload a single block. This can happen on parallel threads.
+        /// </summary>
+        /// <param name="blockIdSequenceNumber">The block sequence prefix value.</param>
+        /// <param name="setResult">The set result.</param>       
+        /// <returns>A <see cref="TaskSequence"/> that dispenses a block stream.</returns>   
+        private TaskSequence DispenseBlockStream(long blockIdSequenceNumber, Action<SmallBlockMemoryStream, string, string> setResult)
+        {
+            int currentCallIndex = this.dispenserCallCount++;
+            TraceHelper.WriteLine("Staring dispensBlockStream for id {0}", currentCallIndex);
+
+            SmallBlockMemoryStream memoryStream = new SmallBlockMemoryStream(Constants.DefaultBufferSize);
+
+            var md5Check = MD5.Create();
+            int totalCopied = 0, numRead = 0;
+
+            do
+            {
+                byte[] buffer = new byte[Constants.DefaultBufferSize];
+                var numToRead = (int)Math.Min(buffer.Length, this.blockSize - totalCopied);
+                var readTask = this.sourceStream.ReadAsync(buffer, 0, numToRead);
+                yield return readTask;
+                numRead = readTask.Result;
+
+                if (numRead != 0)
+                {
+                    // Verify the content
+                    StreamUtilities.ComputeHash(buffer, 0, numRead, md5Check);
+                    StreamUtilities.ComputeHash(buffer, 0, numRead, this.blobHash);
+
+                    var writeTask = memoryStream.WriteAsync(buffer, 0, numRead);
+                    yield return writeTask;
+
+                    // Materialize any exceptions
+                    var scratch = writeTask.Result;
+
+                    totalCopied += numRead;
+                }
+            }
+            while (numRead != 0 && totalCopied < this.blockSize);
+
+            // No locking necessary as only once active Dispense Task
+            this.dispensizedStreamSize += totalCopied;
+
+            if (totalCopied != 0)
+            {
+                string hashVal = StreamUtilities.GetHashValue(md5Check);
+                string blockId = Utilities.GenerateBlockIDWithHash(hashVal, blockIdSequenceNumber);
+
+                this.blockList.Add(blockId);
+
+                memoryStream.Position = 0;
+                setResult(memoryStream, blockId, hashVal);
+            }
+            else
+            {
+                memoryStream.Close();
+                setResult(null, null, null);
+            }
+
+            TraceHelper.WriteLine("Ending dispensBlockStream for id {0}", currentCallIndex);
+        }
+
+        /// <summary>
+        /// Gets the parallelism factor.
+        /// </summary>
+        /// <returns>The parallelism factor.</returns>
+        private int GetParallelismFactor()
+        {
+            return this.blob.ServiceClient.ParallelOperationThreadCount;
+        }
+
+        /// <summary>
+        /// As a final step upload the block list to commit the blob.
+        /// </summary>
+        /// <returns>A <see cref="TaskSequence"/> that commits the blob.</returns>
+        private TaskSequence CommitBlob()
+        {
+            string hashValue = StreamUtilities.GetHashValue(this.blobHash);
+            this.blob.Properties.ContentMD5 = hashValue;
+
+            // At the convenience layer we always upload uncommitted blocks
+            List<PutBlockListItem> putBlockList = new List<PutBlockListItem>();
+            foreach (var id in this.blockList)
+            {
+                putBlockList.Add(new PutBlockListItem(id, BlockSearchMode.Uncommitted));
+            }
+
+            return this.blob.UploadBlockList(putBlockList, this.options);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/AccessPolicyResponse.cs b/microsoft-azure-api/StorageClient/Protocol/AccessPolicyResponse.cs
new file mode 100644
index 0000000000000..8267f11c7901a
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/AccessPolicyResponse.cs
@@ -0,0 +1,136 @@
+//-----------------------------------------------------------------------
+// <copyright file="AccessPolicyResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the AccessPolicyResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Xml;
+    
+    /// <summary>
+    /// Parses the response XML from an operation to set the access policy for a container.
+    /// </summary>
+    public class AccessPolicyResponse : ResponseParsingBase<KeyValuePair<string, SharedAccessPolicy>>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AccessPolicyResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream to be parsed.</param>
+        internal AccessPolicyResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of container-level access policy identifiers.
+        /// </summary>
+        /// <value>An enumerable collection of container-level access policy identifiers.</value>
+        public IEnumerable<KeyValuePair<string, SharedAccessPolicy>> AccessIdentifiers
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Parses the response XML from a Set Container ACL operation to retrieve container-level access policy data.
+        /// </summary>
+        /// <returns>A list of enumerable key-value pairs.</returns>
+        protected override IEnumerable<KeyValuePair<string, SharedAccessPolicy>> ParseXml()
+        {
+            bool needToRead = true;
+            while (true)
+            {
+                if (needToRead && !reader.Read())
+                {
+                    break;
+                }
+
+                needToRead = true;
+
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.SignedIdentifiers)
+                {
+                    while (reader.Read())
+                    {
+                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.SignedIdentifier)
+                        {
+                            while (reader.Read())
+                            {
+                                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.Id)
+                                {
+                                    string id = reader.ReadElementContentAsString();
+                                    SharedAccessPolicy identifier = new SharedAccessPolicy();
+                                    bool needToReadItem = true;
+
+                                    do
+                                    {
+                                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement
+                                            && reader.Name == Constants.AccessPolicy)
+                                        {
+                                            bool needToReadElement = true;
+
+                                            while (true)
+                                            {
+                                                if (needToReadElement && !reader.Read())
+                                                {
+                                                    break;
+                                                }
+
+                                                needToReadElement = true;
+
+                                                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                                                {
+                                                    switch (reader.Name)
+                                                    {
+                                                        case Constants.Start:
+                                                            identifier.SharedAccessStartTime = Uri.UnescapeDataString(reader.ReadElementContentAsString()).ToUTCTime();
+                                                            needToReadElement = false;
+                                                            break;
+                                                        case Constants.Expiry:
+                                                            identifier.SharedAccessExpiryTime = Uri.UnescapeDataString(reader.ReadElementContentAsString()).ToUTCTime();
+                                                            needToReadElement = false;
+                                                            break;
+                                                        case Constants.Permission:
+                                                            identifier.Permissions = SharedAccessPolicy.PermissionsFromString(reader.ReadElementContentAsString());
+                                                            needToReadElement = false;
+                                                            break;
+                                                    }
+                                                }
+                                                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.AccessPolicy)
+                                                {
+                                                    needToReadItem = false;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                    while (needToReadItem && reader.Read());
+
+                                    yield return new KeyValuePair<string, SharedAccessPolicy>(id, identifier);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/BlobContainerEntry.cs b/microsoft-azure-api/StorageClient/Protocol/BlobContainerEntry.cs
new file mode 100644
index 0000000000000..e120bf8c04a6c
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/BlobContainerEntry.cs
@@ -0,0 +1,41 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobContainerEntry.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobContainerEntry class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Represents a container item returned in the XML response for a container listing operation.
+    /// </summary>
+    public class BlobContainerEntry
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobContainerEntry"/> class.
+        /// </summary>
+        internal BlobContainerEntry()
+        {
+        }
+
+        /// <summary>
+        /// Gets the attributes for this container item.
+        /// </summary>
+        /// <value>The container item's attributes.</value>
+        public BlobContainerAttributes Attributes { get; internal set; }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/BlobEntry.cs b/microsoft-azure-api/StorageClient/Protocol/BlobEntry.cs
new file mode 100644
index 0000000000000..42af38c330ea2
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/BlobEntry.cs
@@ -0,0 +1,51 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobEntry.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobEntry class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Represents a blob item returned in the XML response for a blob listing operation.
+    /// </summary>
+    public class BlobEntry : IListBlobEntry
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobEntry"/> class.
+        /// </summary>
+        /// <param name="name">The name of the blob.</param>
+        /// <param name="attributes">The blob's attributes.</param>
+        internal BlobEntry(string name, BlobAttributes attributes)
+        {
+            this.Name = name;
+            this.Attributes = attributes;
+        }
+
+        /// <summary>
+        /// Gets the attributes for this blob item.
+        /// </summary>
+        /// <value>The blob item's attributes.</value>
+        public BlobAttributes Attributes { get; private set; }
+
+        /// <summary>
+        /// Gets the name of the blob item.
+        /// </summary>
+        /// <value>The name of the blob item.</value>
+        public string Name { get; private set; }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/BlobListingContext.cs b/microsoft-azure-api/StorageClient/Protocol/BlobListingContext.cs
new file mode 100644
index 0000000000000..4f8e333ac3b38
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/BlobListingContext.cs
@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobListingContext.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobListingContext class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Provides a set of parameters for a blob listing operation.
+    /// </summary>
+    public class BlobListingContext : ListingContext
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BlobListingContext"/> class.
+        /// </summary>
+        /// <param name="prefix">The blob prefix.</param>
+        /// <param name="maxResults">The maximum number of results to return.</param>
+        /// <param name="delimiter">The blob delimiter.</param>
+        /// <param name="include">The include parameter.</param>
+        public BlobListingContext(string prefix, int? maxResults, string delimiter, BlobListingDetails include)
+            : base(prefix, maxResults)
+        {
+            this.Delimiter = delimiter;
+            this.Include = include;
+        }
+
+        /// <summary>
+        /// Gets or sets the delimiter for a blob listing operation.
+        /// </summary>
+        /// <value>The delimiter to use to traverse the virtual hierarchy of blobs.</value>
+        /// <remarks>
+        /// The delimiter parameter enables the caller to traverse the blob namespace by using a user-configured delimiter. 
+        /// Using this parameter, it is possible to traverse a virtual hierarchy of blobs as though it were a file system. 
+        /// </remarks>
+        public string Delimiter { get; set; }
+
+        /// <summary>
+        /// Gets or sets the details for the listing operation, which indicates the types of data to include in the 
+        /// response.
+        /// </summary>
+        /// <value>The details to include in the listing operation.</value>
+        /// <remarks>
+        /// The include parameter specifies that the response should include one or more of the following subsets: snapshots,
+        /// metadata, uncommitted blobs.
+        /// </remarks>
+        public BlobListingDetails Include { get; set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/BlobPrefixEntry.cs b/microsoft-azure-api/StorageClient/Protocol/BlobPrefixEntry.cs
new file mode 100644
index 0000000000000..fcf058315265f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/BlobPrefixEntry.cs
@@ -0,0 +1,38 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobPrefixEntry.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobPrefixEntry class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Represents the blob name prefix that is returned in the XML response for a blob listing operation.
+    /// </summary>
+    public class BlobPrefixEntry : IListBlobEntry
+    {
+        /// <summary>
+        /// Gets the blob name prefix.
+        /// </summary>
+        /// <value>The blob name prefix.</value>
+        public string Name
+        {
+            get;
+            internal set;
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/BlobRequest.cs b/microsoft-azure-api/StorageClient/Protocol/BlobRequest.cs
new file mode 100644
index 0000000000000..ac71d60062e3d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/BlobRequest.cs
@@ -0,0 +1,765 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobRequest.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobRequest class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.IO;
+    using System.Net;
+    using System.Text;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides a set of methods for constructing requests for blob operations.
+    /// </summary>
+    public static class BlobRequest
+    {
+        /// <summary>
+        /// Constructs a web request to create a new block blob or page blob, or to update the content 
+        /// of an existing block blob. 
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="properties">The properties to set for the blob.</param>
+        /// <param name="blobType">The type of the blob.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <param name="pageBlobSize">For a page blob, the size of the blob. This parameter is ignored
+        /// for block blobs.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest Put(Uri uri, int timeout, BlobProperties properties, BlobType blobType, string leaseId, long pageBlobSize)
+        {
+            if (blobType == BlobType.Unspecified)
+            {
+                throw new InvalidOperationException(SR.UndefinedBlobType);
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, null);
+
+            request.Method = "PUT";
+
+            if (properties.CacheControl != null)
+            {
+                request.Headers.Add(HttpRequestHeader.CacheControl, properties.CacheControl);
+            }
+
+            if (properties.ContentType != null)
+            {
+                // Setting it using Headers is an exception
+                request.ContentType = properties.ContentType;
+            }
+
+            if (properties.ContentMD5 != null)
+            {
+                request.Headers.Add(HttpRequestHeader.ContentMd5, properties.ContentMD5);
+            }
+
+            if (properties.ContentLanguage != null)
+            {
+                request.Headers.Add(HttpRequestHeader.ContentLanguage, properties.ContentLanguage);
+            }
+
+            if (properties.ContentEncoding != null)
+            {
+                request.Headers.Add(HttpRequestHeader.ContentEncoding, properties.ContentEncoding);
+            }
+
+            if (blobType == BlobType.PageBlob)
+            {
+                request.ContentLength = 0;
+                request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.PageBlob);
+                request.Headers.Add(Constants.HeaderConstants.Size, pageBlobSize.ToString(NumberFormatInfo.InvariantInfo));
+                properties.Length = pageBlobSize;
+            }
+            else
+            {
+                request.Headers.Add(Constants.HeaderConstants.BlobType, Constants.HeaderConstants.BlockBlob);
+            }
+
+            Request.AddLeaseId(request, leaseId);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to delete a blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="deleteSnapshotsOption">A set of options indicating whether to delete only blobs, only snapshots, or both.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest Delete(Uri uri, int timeout, DateTime? snapshot, DeleteSnapshotsOption deleteSnapshotsOption, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+
+            if (snapshot != null && deleteSnapshotsOption != DeleteSnapshotsOption.None)
+            {
+                throw new InvalidOperationException(String.Format(SR.DeleteSnapshotsNotValidError, "deleteSnapshotsOption", "snapshot"));
+            }
+
+            BlobRequest.AddSnapshot(builder, snapshot);
+
+            var request = Request.Delete(uri, timeout, builder);
+
+            Request.AddLeaseId(request, leaseId);
+
+            switch (deleteSnapshotsOption)
+            {
+                case DeleteSnapshotsOption.None:
+                     break; // nop
+                case DeleteSnapshotsOption.IncludeSnapshots:
+                     request.Headers.Add(
+                         Constants.HeaderConstants.DeleteSnapshotHeader,
+                         Constants.HeaderConstants.IncludeSnapshotsValue);
+                     break;
+                case DeleteSnapshotsOption.DeleteSnapshotsOnly:
+                     request.Headers.Add(
+                         Constants.HeaderConstants.DeleteSnapshotHeader, 
+                         Constants.HeaderConstants.SnapshotsOnlyValue);
+                    break;
+            }
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to return the user-defined metadata for the blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <returns>A web request for performing the operiaton.</returns>
+        public static HttpWebRequest GetMetadata(Uri uri, int timeout, DateTime? snapshot, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            BlobRequest.AddSnapshot(builder, snapshot);
+
+            var request = Request.GetMetadata(uri, timeout, builder);
+            Request.AddLeaseId(request, leaseId);
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to set user-defined metadata for the blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        public static HttpWebRequest SetMetadata(Uri uri, int timeout, string leaseId)
+        {
+            var request = Request.SetMetadata(uri, timeout, null);
+            Request.AddLeaseId(request, leaseId);
+            return request;
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void SignRequest(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForBlobAndQueue(request, credentials);
+        }
+
+        /// <summary>
+        /// Adds user-defined metadata to the request as one or more name-value pairs.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="metadata">The user-defined metadata.</param>
+        public static void AddMetadata(HttpWebRequest request, NameValueCollection metadata)
+        {
+            Request.AddMetadata(request, metadata);
+        }
+
+        /// <summary>
+        /// Adds user-defined metadata to the request as a single name-value pair.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="name">The metadata name.</param>
+        /// <param name="value">The metadata value.</param>
+        public static void AddMetadata(HttpWebRequest request, string name, string value)
+        {
+            Request.AddMetadata(request, name, value);
+        }
+
+        /// <summary>
+        /// Constructs a web request to return the blob's system properties.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="leaseId">The lease ID.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        public static HttpWebRequest GetProperties(Uri uri, int timeout, DateTime? snapshot, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+
+            BlobRequest.AddSnapshot(builder, snapshot);
+
+            var request = Request.GetProperties(uri, timeout, builder);
+            Request.AddLeaseId(request, leaseId);
+            return request;
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key Lite authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void SignRequestForSharedKeyLite(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForBlobAndQueuesSharedKeyLite(request, credentials);
+        }
+
+        /// <summary>
+        /// Adds a conditional header to the request.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="header">The type of conditional header to add.</param>
+        /// <param name="etag">The blob's ETag.</param>
+        public static void AddConditional(HttpWebRequest request, ConditionHeaderKind header, string etag)
+        {
+            Request.AddConditional(request, header, etag);
+        }
+
+        /// <summary>
+        /// Adds a conditional header to the request.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="header">The type of conditional header to add.</param>
+        /// <param name="dateTime">The date and time specification for the request.</param>
+        public static void AddConditional(HttpWebRequest request, ConditionHeaderKind header, DateTime dateTime)
+        {
+            Request.AddConditional(request, header, dateTime);
+        }
+        
+        /// <summary>
+        /// Constructs a web request to return a listing of all blobs in the container.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="listingContext">A set of parameters for the listing operation.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest List(Uri uri, int timeout, BlobListingContext listingContext)
+        {
+            UriQueryBuilder builder = ContainerRequest.GetContainerUriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "list");
+
+            if (listingContext != null)
+            {
+                if (listingContext.Prefix != null)
+                {
+                    builder.Add("prefix", listingContext.Prefix);
+                }
+
+                if (listingContext.Delimiter != null)
+                {
+                    builder.Add("delimiter", listingContext.Delimiter);
+                }
+
+                if (listingContext.Marker != null)
+                {
+                    builder.Add("marker", listingContext.Marker);
+                }
+
+                if (listingContext.MaxResults != null)
+                {
+                    builder.Add("maxresults", listingContext.MaxResults.ToString());
+                }
+
+                if (listingContext.Include != BlobListingDetails.None)
+                {
+                    StringBuilder sb = new StringBuilder();
+
+                    bool started = false;
+
+                    if ((listingContext.Include & BlobListingDetails.Snapshots) == BlobListingDetails.Snapshots)
+                    {
+                        if (!started)
+                        {
+                            started = true;
+                        }
+                        else
+                        {
+                            sb.Append(",");
+                        }
+
+                        sb.Append("snapshots");
+                    }
+
+                    if ((listingContext.Include & BlobListingDetails.UncommittedBlobs) == BlobListingDetails.UncommittedBlobs)
+                    {
+                        if (!started)
+                        {
+                            started = true;
+                        }
+                        else
+                        {
+                            sb.Append(",");
+                        }
+
+                        sb.Append("uncommittedblobs");
+                    }
+
+                    if ((listingContext.Include & BlobListingDetails.Metadata) == BlobListingDetails.Metadata)
+                    {
+                        if (!started)
+                        {
+                            started = true;
+                        }
+                        else
+                        {
+                            sb.Append(",");
+                        }
+
+                        sb.Append("metadata");
+                    }
+
+                    builder.Add("include", sb.ToString());
+                }
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to copy a blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the destination blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="source">The canonical path to the source blob, in the form /&lt;account-name&gt;/&lt;container-name&gt;/&lt;blob-name&gt;.</param>
+        /// <param name="sourceSnapshot">The snapshot version, if the source blob is a snapshot.</param>
+        /// <param name="sourceConditions">A type of condition to check on the source blob.</param>
+        /// <param name="sourceConditionsValue">The value of the condition to check on the source blob.</param>
+        /// <param name="leaseId">The lease ID for the source blob, if it has an active lease.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest CopyFrom(Uri uri, int timeout, string source, DateTime? sourceSnapshot, ConditionHeaderKind sourceConditions, string sourceConditionsValue, string leaseId)
+        {
+            if (sourceSnapshot != null)
+            {
+                // User needs to construct the proper canonical path string.
+                source += "?snapshot=" + Request.ConvertDateTimeToSnapshotString(sourceSnapshot.Value.ToUniversalTime());
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, null);
+
+            request.ContentLength = 0;
+            request.Method = "PUT";
+
+            request.Headers.Add(Constants.HeaderConstants.CopySourceHeader, source);
+
+            switch (sourceConditions)
+            {
+                case ConditionHeaderKind.IfMatch:
+                    request.Headers.Add(Constants.HeaderConstants.SourceIfMatchHeader, sourceConditionsValue);
+                    break;
+                case ConditionHeaderKind.IfModifiedSince:
+                    request.Headers.Add(Constants.HeaderConstants.SourceIfModifiedSinceHeader, sourceConditionsValue);
+                    break;
+                case ConditionHeaderKind.IfNoneMatch:
+                    request.Headers.Add(Constants.HeaderConstants.SourceIfNoneMatchHeader, sourceConditionsValue);
+                    break;
+                case ConditionHeaderKind.IfUnmodifiedSince:
+                    request.Headers.Add(Constants.HeaderConstants.SourceIfUnmodifiedSinceHeader, sourceConditionsValue);
+                    break;
+                case ConditionHeaderKind.None:
+                    break;
+            }
+
+            Request.AddLeaseId(request, leaseId);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to get the blob's content, properties, and metadata.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="snapshot">The snapshot version, if the blob is a snapshot.</param>
+        /// <param name="leaseId">The lease ID for the blob, if it has an active lease.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        public static HttpWebRequest Get(Uri uri, int timeout, DateTime? snapshot, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+
+            BlobRequest.AddSnapshot(builder, snapshot);
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            if (leaseId != null)
+            {
+                Request.AddLeaseId(request, leaseId);
+            }
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to return a specified range of the blob's content, together with its properties and metadata.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <param name="snapshot">The snapshot version, if the blob is a snapshot.</param>
+        /// <param name="offset">The byte offset at which to begin returning content.</param>
+        /// <param name="count">The number of bytes to return, or null to return all bytes through the end of the blob.</param>
+        /// <param name="leaseId">The lease ID for the blob if it has an active lease, or null if there is no lease.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest Get(Uri uri, int timeout, DateTime? snapshot, long offset, long? count, string leaseId)
+        {
+            HttpWebRequest request = Get(uri, timeout, snapshot, leaseId);
+
+            string rangeStart = offset.ToString();
+            string rangeEnd = string.Empty;
+            if (count.HasValue)
+            {
+                rangeEnd = (offset + count.Value - 1).ToString();
+            }
+
+            string rangeHeaderValue = string.Format(
+                            CultureInfo.InvariantCulture,
+                            Constants.HeaderConstants.RangeHeaderFormat,
+                            rangeStart,
+                            rangeEnd);
+
+            request.Headers.Add(Constants.HeaderConstants.StorageRangeHeader, rangeHeaderValue);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to return the list of blocks for a block blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="typesOfBlocks">The types of blocks to include in the list: committed, uncommitted, or both.</param>
+        /// <param name="leaseId">The lease ID for the blob, if it has an active lease.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest GetBlockList(Uri uri, int timeout, DateTime? snapshot, BlockListingFilter typesOfBlocks, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "blocklist");
+
+            builder.Add("blocklisttype", typesOfBlocks.ToString());
+        
+            BlobRequest.AddSnapshot(builder, snapshot);
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            Request.AddLeaseId(request, leaseId);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to return the list of active page ranges for a page blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="snapshot">The snapshot timestamp, if the blob is a snapshot.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest GetPageRanges(Uri uri, int timeout, DateTime? snapshot, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "pagelist");
+
+            BlobRequest.AddSnapshot(builder, snapshot);
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            Request.AddLeaseId(request, leaseId);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to use to acquire, renew, release or break the lease for the blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="action">The lease action to perform.</param>
+        /// <param name="leaseId">The lease ID.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest Lease(Uri uri, int timeout, LeaseAction action, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "lease");
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.ContentLength = 0;
+            request.Method = "PUT";
+
+            Request.AddLeaseId(request, leaseId);
+
+            // acquire, renew, release, or break; required
+            request.Headers.Add("x-ms-lease-action", action.ToString());
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to write a block to a block blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="blockId">The block ID for this block.</param>
+        /// <param name="leaseId">The lease ID for the blob, if it has an active lease.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest PutBlock(Uri uri, int timeout, string blockId, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "block");
+
+            builder.Add("blockid", blockId);
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "PUT";
+
+            Request.AddLeaseId(request, leaseId);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to create or update a blob by committing a block list.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="properties">The properties to set for the blob.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        public static HttpWebRequest PutBlockList(
+            Uri uri,
+            int timeout,
+            BlobProperties properties,
+            string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "blocklist");
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "PUT";
+
+            Request.AddLeaseId(request, leaseId);
+
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Writes the body of the block list to the specified stream in XML format.
+        /// </summary>
+        /// <param name="blocks">An enumerable collection of <see cref="PutBlockListItem"/> objects.</param>
+        /// <param name="outputStream">The stream to which the block list is written.</param>
+        public static void WriteBlockListBody(IEnumerable<PutBlockListItem> blocks, Stream outputStream)
+        {
+            XmlWriterSettings settings = new XmlWriterSettings();
+            settings.Encoding = Encoding.UTF8;
+            using (XmlWriter writer = XmlWriter.Create(outputStream, settings))
+            {
+                writer.WriteStartElement(Constants.BlockListElement);
+
+                foreach (var block in blocks)
+                {
+                    if (block.SearchMode == BlockSearchMode.Committed)
+                    {
+                        writer.WriteElementString(Constants.CommittedElement, block.Id);
+                    }
+                    else if (block.SearchMode == BlockSearchMode.Uncommitted)
+                    {
+                        writer.WriteElementString(Constants.UncommittedElement, block.Id);
+                    }
+                    else if (block.SearchMode == BlockSearchMode.Latest)
+                    {
+                        writer.WriteElementString(Constants.LatestElement, block.Id);
+                    }
+                }
+
+                writer.WriteEndDocument();
+            }
+        }
+
+        /// <summary>
+        /// Constructs a web request to write or clear a range of pages in a page blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="properties">The blob's properties.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest PutPage(Uri uri, int timeout, PutPageProperties properties, string leaseId)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "page");
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "PUT";
+
+            Request.AddLeaseId(request, leaseId);
+
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.RangeHeader, properties.Range.ToString());
+
+            // Page write is either update or clean; required
+            request.Headers.Add(Constants.HeaderConstants.PageWrite, properties.PageWrite.ToString());
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to set system properties for a blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="properties">The blob's properties.</param>
+        /// <param name="leaseId">The lease ID, if the blob has an active lease.</param>
+        /// <param name="newBlobSize">The new blob size, if the blob is a page blob. Set this parameter to <c>null</c> to keep the existing blob size.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest SetProperties(Uri uri, int timeout, BlobProperties properties, string leaseId, long? newBlobSize)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "properties");
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.ContentLength = 0;
+            request.Method = "PUT";
+
+            Request.AddLeaseId(request, leaseId);
+
+            if (newBlobSize.HasValue)
+            {
+                request.Headers.Add(Constants.HeaderConstants.Size, newBlobSize.Value.ToString(NumberFormatInfo.InvariantInfo));
+                properties.Length = newBlobSize.Value;
+            }
+
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.CacheControlHeader, properties.CacheControl);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentEncodingHeader, properties.ContentEncoding);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentLanguageHeader, properties.ContentLanguage);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.BlobContentMD5Header, properties.ContentMD5);
+            Request.AddOptionalHeader(request, Constants.HeaderConstants.ContentTypeHeader, properties.ContentType);
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to create a snapshot of a blob.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the blob.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest Snapshot(Uri uri, int timeout)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "snapshot");
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.ContentLength = 0;
+            request.Method = "PUT";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Creates a web request to get the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <returns>A web request to get the service properties.</returns>
+        public static HttpWebRequest GetServiceProperties(Uri uri, int timeout)
+        {
+            return Request.GetServiceProperties(uri, timeout);
+        }
+
+        /// <summary>
+        /// Creates a web request to set the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <returns>A web request to set the service properties.</returns>
+        public static HttpWebRequest SetServiceProperties(Uri uri, int timeout)
+        {
+            return Request.SetServiceProperties(uri, timeout);
+        }
+
+        /// <summary>
+        /// Writes service properties to a stream, formatted in XML.
+        /// </summary>
+        /// <param name="properties">The service properties to format and write to the stream.</param>
+        /// <param name="outputStream">The stream to which the formatted properties are to be written.</param>
+        public static void WriteServiceProperties(ServiceProperties properties, Stream outputStream)
+        {
+            Request.WriteServiceProperties(properties, outputStream);
+        }
+
+        /// <summary>
+        /// Adds the snapshot.
+        /// </summary>
+        /// <param name="builder">The builder.</param>
+        /// <param name="snapshot">The snapshot version, if the blob is a snapshot.</param>
+        private static void AddSnapshot(UriQueryBuilder builder, DateTime? snapshot)
+        {
+            if (snapshot != null)
+            {
+                builder.Add("snapshot", Request.ConvertDateTimeToSnapshotString(snapshot.Value.ToUniversalTime()));
+            }
+        }
+
+        /// <summary>
+        /// Creates the web request.
+        /// </summary>
+        /// <param name="uri">The Uri of the resource.</param>
+        /// <param name="timeout">The timeout to apply.</param>
+        /// <param name="query">The query builder to use.</param>
+        /// <returns>The resulting <see cref="HttpWebRequest"/>.</returns>
+        private static HttpWebRequest CreateWebRequest(Uri uri, int timeout, UriQueryBuilder query)
+        {
+            return Request.CreateWebRequest(uri, timeout, query);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/BlobResponse.cs b/microsoft-azure-api/StorageClient/Protocol/BlobResponse.cs
new file mode 100644
index 0000000000000..d6644d5b88e00
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/BlobResponse.cs
@@ -0,0 +1,233 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlobResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlobResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Net;
+    using System.Web;
+
+    /// <summary>
+    /// Provides a set of methods for parsing responses from blob operations.
+    /// </summary>
+    public static class BlobResponse
+    {
+        /// <summary>
+        /// Returns extended error information from the storage service, that is in addition to the HTTP status code returned with the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object containing extended error information returned with the response.</returns>
+        public static StorageExtendedErrorInformation GetError(HttpWebResponse response)
+        {
+            return Response.GetError(response);
+        }
+
+        /// <summary>
+        /// Gets a collection of user-defined metadata from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A collection of user-defined metadata, as name-value pairs.</returns>
+        public static NameValueCollection GetMetadata(HttpWebResponse response)
+        {
+            return Response.GetMetadata(response);
+        }
+
+        /// <summary>
+        /// Gets an array of values for a specified name-value pair from a response that includes user-defined metadata.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <param name="name">The name associated with the metadata values to return.</param>
+        /// <returns>An array of metadata values.</returns>
+        public static string[] GetMetadata(HttpWebResponse response, string name)
+        {
+            return Response.GetMetadata(response, name);
+        }
+
+        /// <summary>
+        /// Gets the blob's attributes, including its metadata and properties, from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>The blob's attributes.</returns>
+        public static BlobAttributes GetAttributes(HttpWebResponse response)
+        {
+            BlobAttributes attributes = new BlobAttributes();
+            var properties = attributes.Properties = new BlobProperties();
+            
+            properties.CacheControl = response.Headers[HttpResponseHeader.CacheControl];
+            properties.ContentEncoding = response.Headers[HttpResponseHeader.ContentEncoding];
+            properties.ContentLanguage = response.Headers[HttpResponseHeader.ContentLanguage];
+            properties.ContentMD5 = response.Headers[HttpResponseHeader.ContentMd5];
+            properties.ContentType = response.Headers[HttpResponseHeader.ContentType];
+            properties.ETag = response.Headers[HttpResponseHeader.ETag];
+            properties.LastModifiedUtc = response.LastModified.ToUniversalTime();
+            
+            string blobType = response.Headers[Constants.HeaderConstants.BlobType];
+            string leaseStatus = response.Headers[Constants.HeaderConstants.LeaseStatus];
+
+            if (!string.IsNullOrEmpty(blobType))
+            {
+                properties.BlobType = (BlobType)Enum.Parse(typeof(BlobType), blobType, true);
+            }
+
+            if (!string.IsNullOrEmpty(leaseStatus))
+            {
+                properties.LeaseStatus = (LeaseStatus)Enum.Parse(typeof(LeaseStatus), leaseStatus, true);
+            }
+
+            // Get the content length. Prioritize range and x-ms over content length for the special cases.
+            var rangeHeader = response.Headers[HttpResponseHeader.ContentRange];
+            var xContentLengthHeader = response.Headers[Constants.HeaderConstants.ContentLengthHeader];
+            if (!string.IsNullOrEmpty(rangeHeader))
+            {
+                properties.Length = long.Parse(rangeHeader.Split('/')[1]);
+            }
+            else if (!string.IsNullOrEmpty(xContentLengthHeader))
+            {
+                properties.Length = long.Parse(xContentLengthHeader);
+            }
+            else
+            {
+                properties.Length = response.ContentLength;
+            }
+
+            attributes.Uri = new Uri(response.ResponseUri.GetLeftPart(UriPartial.Path));
+            
+            var queryParameters = HttpUtility.ParseQueryString(response.ResponseUri.Query);
+
+            DateTime snapshot;
+            var snapshotString = queryParameters.Get(Constants.QueryConstants.Snapshot);
+            if (!string.IsNullOrEmpty(snapshotString) && 
+                    DateTime.TryParse(
+                        snapshotString, 
+                        System.Globalization.CultureInfo.InvariantCulture, 
+                        System.Globalization.DateTimeStyles.AdjustToUniversal,
+                        out snapshot))
+            {
+                    attributes.Snapshot = snapshot;
+            }
+
+            attributes.Metadata = GetMetadata(response);
+
+            return attributes;
+        }
+
+        /// <summary>
+        /// Gets the request ID from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A unique value associated with the request.</returns>
+        public static string GetRequestId(HttpWebResponse response)
+        {
+            return Response.GetRequestId(response);
+        }
+
+        /// <summary>
+        /// Gets the snapshot timestamp from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>The snapshot timestamp.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1011:ConsiderPassingBaseTypesAsParameters",
+            Justification = "Storage only supports HTTP")]
+        public static string GetSnapshotTime(HttpWebResponse response)
+        {
+            return response.Headers[Constants.HeaderConstants.SnapshotHeader];
+        }
+        
+        /// <summary>
+        /// Parses the response for a blob listing operation.
+        /// </summary>
+        /// <param name="stream">The response stream.</param>
+        /// <returns>An object that may be used for parsing data from the results of a blob listing operation.</returns>
+        public static ListBlobsResponse List(Stream stream)
+        {
+            return new ListBlobsResponse(stream);
+        }
+
+        /// <summary>
+        /// Parses the response for a blob listing operation.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object that may be used for parsing data from the results of a blob listing operation.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1011:ConsiderPassingBaseTypesAsParameters",
+            Justification = "Storage only supports HTTP")]
+        public static ListBlobsResponse List(HttpWebResponse response)
+        {
+            return new ListBlobsResponse(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Parses the response for an operation that returns a block list for the blob.
+        /// </summary>
+        /// <param name="stream">The response stream.</param>
+        /// <returns>An object that may be used for parsing data from the results of an operation to return a block list.</returns>
+        public static GetBlockListResponse GetBlockList(Stream stream)
+        {
+            return new GetBlockListResponse(stream);
+        }
+        
+        /// <summary>
+        /// Parses the response for an operation that returns a block list for the blob.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object that may be used for parsing data from the results of an operation to return a block list.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Storage only supports HTTP")]
+        public static GetBlockListResponse GetBlockList(HttpWebResponse response)
+        {
+            return new GetBlockListResponse(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Parses the response for an operation that returns a range of pages.
+        /// </summary>
+        /// <param name="stream">The response stream.</param>
+        /// <returns>An object that may be used for parsing data from the results of an operation to return a range of pages.</returns>
+        public static GetPageRangesResponse GetPageRanges(Stream stream)
+        {
+            return new GetPageRangesResponse(stream);
+        }
+
+        /// <summary>
+        /// Parses the response for an operation that returns a range of pages.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object that may be used for parsing data from the results of an operation to return a range of pages.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Storage only supports HTTP")]
+        public static GetPageRangesResponse GetPageRanges(HttpWebResponse response)
+        {
+            return new GetPageRangesResponse(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Reads service properties from a stream.
+        /// </summary>
+        /// <param name="inputStream">The stream from which to read the service properties.</param>
+        /// <returns>The service properties stored in the stream.</returns>
+        public static ServiceProperties ReadServiceProperties(Stream inputStream)
+        {
+            return Response.ReadServiceProperties(inputStream);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/BlockSearchMode.cs b/microsoft-azure-api/StorageClient/Protocol/BlockSearchMode.cs
new file mode 100644
index 0000000000000..de717d5eb15d1
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/BlockSearchMode.cs
@@ -0,0 +1,44 @@
+//-----------------------------------------------------------------------
+// <copyright file="BlockSearchMode.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the BlockSearchMode enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Indicates which block lists should be searched to find a specified block. 
+    /// </summary>
+    public enum BlockSearchMode
+    {
+        /// <summary>
+        /// Search the committed block list only.
+        /// </summary>
+        Committed,
+
+        /// <summary>
+        /// Search the uncommitted block list only.
+        /// </summary>
+        Uncommitted,
+
+        /// <summary>
+        /// Search the uncommitted block list first, and if the block is not found there, search 
+        /// the committed block list.
+        /// </summary>
+        Latest
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/CanonicalizationStrategy.cs b/microsoft-azure-api/StorageClient/Protocol/CanonicalizationStrategy.cs
new file mode 100644
index 0000000000000..94b5bac6ca25b
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/CanonicalizationStrategy.cs
@@ -0,0 +1,382 @@
+//-----------------------------------------------------------------------
+// <copyright file="CanonicalizationStrategy.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CanonicalizationStrategy class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// Represents the base canonicalization strategy used to authenticate a request against the storage services.
+    /// </summary>
+    public abstract class CanonicalizationStrategy
+    {
+        /// <summary>
+        /// Constructs a canonicalized string for signing a request.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>A canonicalized string.</returns>
+        public abstract string CanonicalizeHttpRequest(HttpWebRequest request, string accountName);
+
+        /// <summary>
+        /// Constructs a canonicalized string from the request's headers that will be used to construct the signature
+        /// string for signing a Blob or Queue service request under the Shared Key Lite authentication scheme.
+        /// </summary>
+        /// <param name="address">The request URI.</param>
+        /// <param name="accountName">The storage account name.</param>
+        /// <param name="method">The verb to be used for the HTTP request.</param>
+        /// <param name="contentType">The content type of the HTTP request.</param>
+        /// <param name="date">The date/time specification for the HTTP request.</param>
+        /// <param name="headers">A collection of additional headers specified on the HTTP request.</param>
+        /// <returns>A canonicalized string.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Globalization",
+            "CA1308:NormalizeStringsToUppercase",
+            Justification = "Authentication algorithm requires canonicalization by converting to lower case")]
+        protected static string CanonicalizeHttpRequest(
+            Uri address,
+            string accountName,
+            string method,
+            string contentType,
+            string date,
+            NameValueCollection headers)
+        {
+            // The first element should be the Method of the request.
+            // I.e. GET, POST, PUT, or HEAD.
+            CanonicalizedString canonicalizedString = new CanonicalizedString(method);
+
+            // The second element should be the MD5 value.
+            // This is optional and may be empty.
+            string httpContentMD5Value = string.Empty;
+
+            // First extract all the content MD5 values from the header.
+            ArrayList httpContentMD5Values = GetHeaderValues(headers, "Content-MD5");
+
+            // If we only have one, then set it to the value we want to append to the canonicalized string.
+            if (httpContentMD5Values.Count == 1)
+            {
+                httpContentMD5Value = (string)httpContentMD5Values[0];
+            }
+
+            canonicalizedString.AppendCanonicalizedElement(httpContentMD5Value);
+
+            // The third element should be the content type.
+            canonicalizedString.AppendCanonicalizedElement(contentType);
+
+            // The fourth element should be the request date.
+            // See if there's an storage date header.
+            // If there's one, then don't use the date header.
+            ArrayList httpStorageDateValues = GetHeaderValues(headers, Constants.HeaderConstants.Date);
+            if (httpStorageDateValues.Count > 0)
+            {
+                date = null;
+            }
+
+            canonicalizedString.AppendCanonicalizedElement(date);
+
+            AddCanonicalizedHeaders(headers, canonicalizedString);
+
+            AddCanonicalizedResource(address, accountName, canonicalizedString);
+
+            return canonicalizedString.Value;
+        }
+
+        /// <summary>
+        /// Constructs a canonicalized string from the request's headers that will be used to construct the signature
+        /// string for signing a Blob or Queue service request under the Shared Key Lite authentication scheme.
+        /// </summary>
+        /// <param name="address">The request URI.</param>
+        /// <param name="accountName">The storage account name.</param>
+        /// <param name="method">The verb to be used for the HTTP request.</param>
+        /// <param name="contentType">The content type of the HTTP request.</param>
+        /// <param name="contentLength">The length of the HTTP request, in bytes.</param>
+        /// <param name="date">The date/time specification for the HTTP request.</param>
+        /// <param name="headers">A collection of additional headers specified on the HTTP request.</param>
+        /// <returns>A canonicalized string.</returns>
+        protected static string CanonicalizeHttpRequestVersion2(
+            Uri address,
+            string accountName,
+            string method,
+            string contentType,
+            long contentLength,
+            string date,
+            NameValueCollection headers)
+        {
+            // The first element should be the Method of the request.
+            // I.e. GET, POST, PUT, or HEAD.
+            CanonicalizedString canonicalizedString = new CanonicalizedString(method);
+
+            // The next elements are 
+            // If any element is missing it may be empty.
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "Content-Encoding"));
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "Content-Language"));
+            canonicalizedString.AppendCanonicalizedElement(contentLength == -1 ? String.Empty : contentLength.ToString());
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "Content-MD5"));
+            canonicalizedString.AppendCanonicalizedElement(contentType);
+
+            // If x-ms-date header exists, Date should be empty string
+            canonicalizedString.AppendCanonicalizedElement(
+                GetStandardHeaderValue(headers, Constants.HeaderConstants.Date) != string.Empty 
+                ? string.Empty : GetStandardHeaderValue(headers, "Date"));
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "If-Modified-Since"));
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "If-Match"));
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "If-None-Match"));
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "If-Unmodified-Since"));
+            canonicalizedString.AppendCanonicalizedElement(GetStandardHeaderValue(headers, "Range"));
+
+            AddCanonicalizedHeaders(headers, canonicalizedString);
+
+            AddCanonicalizedResourceVer2(address, accountName, canonicalizedString);
+
+            return canonicalizedString.Value;
+        }
+
+        /// <summary>
+        /// Gets the value of a standard HTTP header.
+        /// </summary>
+        /// <param name="headers">The collection of headers.</param>
+        /// <param name="headerName">The name of the header.</param>
+        /// <returns>The header value.</returns>
+        protected static string GetStandardHeaderValue(NameValueCollection headers, string headerName)
+        {
+            ArrayList headerValues = GetHeaderValues(headers, headerName);
+
+            return headerValues.Count == 1 ? (string)headerValues[0] : string.Empty;
+        }
+
+        /// <summary>
+        /// Returns an <see cref="ArrayList"/> of HTTP header values for a named header.
+        /// </summary>
+        /// <param name="headers">A collection of HTTP headers as name-values pairs.</param>
+        /// <param name="headerName">The name of the header to return.</param>
+        /// <returns>An <see cref="ArrayList"/> of HTTP header values, stored in the same order as they appear in the collection.</returns>
+        protected static ArrayList GetHeaderValues(NameValueCollection headers, string headerName)
+        {
+            ArrayList arrayOfValues = new ArrayList();
+            string[] values = headers.GetValues(headerName);
+
+            if (values != null)
+            {
+                foreach (string value in values)
+                {
+                    // canonization formula requires the string to be left trimmed.
+                    arrayOfValues.Add(value.TrimStart());
+                }
+            }
+
+            return arrayOfValues;
+        }
+
+        /// <summary>
+        /// Appends a string to the canonicalized resource string.
+        /// </summary>
+        /// <param name="canonicalizedString">The canonicalized resource string.</param>
+        /// <param name="stringToAppend">The string to append.</param>
+        /// <returns>The modified canonicalized resource string.</returns>
+        protected static string AppendStringToCanonicalizedString(StringBuilder canonicalizedString, string stringToAppend)
+        {
+            canonicalizedString.Append("\n");
+            canonicalizedString.Append(stringToAppend);
+
+            return canonicalizedString.ToString();
+        }
+
+        /// <summary>
+        /// Gets the canonicalized resource string for a Blob or Queue service request under the Shared Key Lite authentication scheme.
+        /// </summary>
+        /// <param name="address">The resource URI.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The canonicalized resource string.</returns>
+        protected static string GetCanonicalizedResource(Uri address, string accountName)
+        {
+            // Algorithm is as follows
+            // 1. Start with the empty string ("")
+            // 2. Append the account name owning the resource preceded by a
+            //     the name of the account making the request but the account that owns the
+            //     resource being accessed.
+            // 3. Append the path part of the un-decoded HTTP Request-URI, up-to but not
+            //     including the query string.
+            // 4. If the request addresses a particular component of a resource, like?comp=
+            //     metadata then append the sub-resource including question mark (like ?comp=
+            //     metadata)
+            StringBuilder canonicalizedResource = new StringBuilder("/");
+            canonicalizedResource.Append(accountName);
+
+            // Note that AbsolutePath starts with a '/'.
+            canonicalizedResource.Append(address.AbsolutePath);
+            NameValueCollection queryVariables = HttpUtility.ParseQueryString(address.Query);
+
+            // Add only comp for the old scheme
+            string compQueryParameterValue = queryVariables["comp"];
+
+            if (compQueryParameterValue != null)
+            {
+                canonicalizedResource.Append("?comp=");
+                canonicalizedResource.Append(compQueryParameterValue);
+            }
+
+            return canonicalizedResource.ToString();
+        }
+
+        /// <summary>
+        /// Gets the canonicalized resource string for a Blob or Queue service request under the Shared Key authentication scheme.
+        /// </summary>
+        /// <param name="address">The resource URI.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The canonicalized resource string.</returns>
+        protected static string GetCanonicalizedResourceVersion2(Uri address, string accountName)
+        {
+            // Resource path
+            StringBuilder resourcepath = new StringBuilder("/");
+            resourcepath.Append(accountName);
+
+            // Note that AbsolutePath starts with a '/'.
+            resourcepath.Append(address.AbsolutePath);
+
+            CanonicalizedString canonicalizedResource = new CanonicalizedString(resourcepath.ToString());
+
+            // query parameters
+            NameValueCollection queryVariables = HttpUtility.ParseQueryString(address.Query);
+            NameValueCollection lowercasedKeyNameValue = new NameValueCollection();
+
+            foreach (string key in queryVariables.Keys)
+            {
+                // sort the value and organize it as comma separated values
+                object[] values = queryVariables.GetValues(key);
+
+                ArrayList sortedValues = new ArrayList(values);
+                sortedValues.Sort();
+
+                StringBuilder stringValue = new StringBuilder();
+
+                foreach (object value in sortedValues)
+                {
+                    if (stringValue.Length > 0)
+                    {
+                        stringValue.Append(",");
+                    }
+
+                    stringValue.Append(value.ToString());
+                }
+
+                // key turns out to be null for ?a&b&c&d
+                lowercasedKeyNameValue.Add(key == null ? key : key.ToLowerInvariant(), stringValue.ToString());
+            }
+
+            ArrayList sortedKeys = new ArrayList(lowercasedKeyNameValue.AllKeys);
+
+            sortedKeys.Sort();
+
+            foreach (string key in sortedKeys)
+            {
+                StringBuilder queryParamString = new StringBuilder(string.Empty);
+
+                queryParamString.Append(key);
+                queryParamString.Append(":");
+                queryParamString.Append(lowercasedKeyNameValue[key]);
+
+                canonicalizedResource.AppendCanonicalizedElement(queryParamString.ToString());
+            }
+
+            return canonicalizedResource.Value;
+        }
+
+        /// <summary>
+        /// Adds the canonicalized resource for version 2.
+        /// </summary>
+        /// <param name="address">The address.</param>
+        /// <param name="accountName">Name of the account.</param>
+        /// <param name="canonicalizedString">The canonicalized string.</param>
+        private static void AddCanonicalizedResourceVer2(Uri address, string accountName, CanonicalizedString canonicalizedString)
+        {
+            // Now we append the canonicalized resource element.
+            string canonicalizedResource = GetCanonicalizedResourceVersion2(address, accountName);
+
+            canonicalizedString.AppendCanonicalizedElement(canonicalizedResource);
+        }
+
+        /// <summary>
+        /// Add the resource name.
+        /// </summary>
+        /// <param name="address">The address.</param>
+        /// <param name="accountName">Name of the account.</param>
+        /// <param name="canonicalizedString">The canonicalized string.</param>
+        private static void AddCanonicalizedResource(Uri address, string accountName, CanonicalizedString canonicalizedString)
+        {
+            // Now we append the canonicalized resource element.
+            string canonicalizedResource = GetCanonicalizedResource(address, accountName);
+            canonicalizedString.AppendCanonicalizedElement(canonicalizedResource);
+        }
+
+        /// <summary>
+        /// Add x-ms- prefixed headers in a fixed order.
+        /// </summary>
+        /// <param name="headers">The headers.</param>
+        /// <param name="canonicalizedString">The canonicalized string.</param>
+        private static void AddCanonicalizedHeaders(NameValueCollection headers, CanonicalizedString canonicalizedString)
+        {
+            // Look for header names that start with HeaderNames.PrefixForStorageHeader
+            // Then sort them in case-insensitive manner.
+            ArrayList httpStorageHeaderNameArray = new ArrayList();
+
+            foreach (string key in headers.Keys)
+            {
+                if (key.ToLowerInvariant().StartsWith(Constants.HeaderConstants.PrefixForStorageHeader, StringComparison.Ordinal))
+                {
+                    httpStorageHeaderNameArray.Add(key.ToLowerInvariant());
+                }
+            }
+
+            httpStorageHeaderNameArray.Sort();
+
+            // Now go through each header's values in the sorted order and append them to the canonicalized string.
+            foreach (string key in httpStorageHeaderNameArray)
+            {
+                StringBuilder canonicalizedElement = new StringBuilder(key);
+                string delimiter = ":";
+                ArrayList values = GetHeaderValues(headers, key);
+
+                // Go through values, unfold them, and then append them to the canonicalized element string.
+                foreach (string value in values)
+                {
+                    // Unfolding is simply removal of CRLF.
+                    string unfoldedValue = value.Replace("\r\n", string.Empty);
+
+                    // Append it to the canonicalized element string.
+                    canonicalizedElement.Append(delimiter);
+                    canonicalizedElement.Append(unfoldedValue);
+                    delimiter = ",";
+                }
+
+                // Now, add this canonicalized element to the canonicalized header string.
+                canonicalizedString.AppendCanonicalizedElement(canonicalizedElement.ToString());
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/CanonicalizationStrategyFactory.cs b/microsoft-azure-api/StorageClient/Protocol/CanonicalizationStrategyFactory.cs
new file mode 100644
index 0000000000000..74ce66c23b6ef
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/CanonicalizationStrategyFactory.cs
@@ -0,0 +1,210 @@
+//-----------------------------------------------------------------------
+// <copyright file="CanonicalizationStrategyFactory.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CanonicalizationStrategyFactory class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// Retrieve appropriate version of CanonicalizationStrategy based on the webrequest
+    /// for Blob Queue and Table.
+    /// </summary>
+    internal static class CanonicalizationStrategyFactory
+    {
+        /// <summary>
+        /// Stores the version 1 blob/queue full signing strategy.
+        /// </summary>
+        private static SharedKeyLiteCanonicalizer blobQueueFullVer1;
+
+        /// <summary>
+        /// Stores the version 1 table lite signing strategy.
+        /// </summary>
+        private static SharedKeyLiteTableCanonicalizer tableLiteVer1;
+
+        /// <summary>
+        /// Stores the version 2 blob/queue full signing strategy.
+        /// </summary>
+        private static SharedKeyCanonicalizer blobQueueFullVer2;
+
+        /// <summary>
+        /// Stores the version 1 table full signing strategy.
+        /// </summary>
+        private static SharedKeyTableCanonicalizer tableFullVer1;
+
+        /// <summary>
+        /// Gets the BLOB queue full ver1.
+        /// </summary>
+        /// <value>The BLOB queue full ver1.</value>
+        private static SharedKeyLiteCanonicalizer BlobQueueFullVer1
+        {
+            get
+            {
+                if (blobQueueFullVer1 == null)
+                {
+                    blobQueueFullVer1 = new SharedKeyLiteCanonicalizer();
+                }
+
+                return blobQueueFullVer1;
+            }
+        }
+
+        /// <summary>
+        /// Gets the table lite ver1.
+        /// </summary>
+        /// <value>The table lite ver1.</value>
+        private static SharedKeyLiteTableCanonicalizer TableLiteVer1
+        {
+            get
+            {
+                if (tableLiteVer1 == null)
+                {
+                    tableLiteVer1 = new SharedKeyLiteTableCanonicalizer();
+                }
+
+                return tableLiteVer1;
+            }
+        }
+
+        /// <summary>
+        /// Gets the table full ver1.
+        /// </summary>
+        /// <value>The table full ver1.</value>
+        private static SharedKeyTableCanonicalizer TableFullVer1
+        {
+            get
+            {
+                if (tableFullVer1 == null)
+                {
+                    tableFullVer1 = new SharedKeyTableCanonicalizer();
+                }
+
+                return tableFullVer1;
+            }
+        }
+
+        /// <summary>
+        /// Gets the BLOB queue full ver2.
+        /// </summary>
+        /// <value>The BLOB queue full ver2.</value>
+        private static SharedKeyCanonicalizer BlobQueueFullVer2
+        {
+            get
+            {
+                if (blobQueueFullVer2 == null)
+                {
+                    blobQueueFullVer2 = new SharedKeyCanonicalizer();
+                }
+
+                return blobQueueFullVer2;
+            }
+        }
+
+        /// <summary>
+        /// Gets canonicalization strategy for Blob and Queue SharedKey Authentication.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <returns>The canonicalization strategy.</returns>
+        public static CanonicalizationStrategy GetBlobQueueFullCanonicalizationStrategy(HttpWebRequest request)
+        {
+            if (IsTargetVersion2(request))
+            {
+                return BlobQueueFullVer2;
+            }
+            else
+            {
+                return BlobQueueFullVer1;
+            }
+        }
+
+        /// <summary>
+        /// Get canonicalization strategy for Tables for SharedKeyLite Authentication.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <returns>The canonicalization strategy.</returns>
+        public static CanonicalizationStrategy GetTableLiteCanonicalizationStrategy(HttpWebRequest request)
+        {
+            return TableLiteVer1;
+        }
+
+        /// <summary>
+        /// Gets the table full canonicalization strategy.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <returns>The canonicalization strategy.</returns>
+        public static CanonicalizationStrategy GetTableFullCanonicalizationStrategy(HttpWebRequest request)
+        {
+            return TableFullVer1;
+        }
+
+        /// <summary>
+        /// Gets the BLOB queue lite canonicalization strategy.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <returns>The canonicalization strategy.</returns>
+        public static CanonicalizationStrategy GetBlobQueueLiteCanonicalizationStrategy(HttpWebRequest request)
+        {
+            if (IsTargetVersion2(request))
+            {
+                // Old SharedKey Authentication is the new SharedKeyLite Authentication
+                return BlobQueueFullVer1;
+            }
+            else
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.BlobQSharedKeyLiteUnsuppported, request.Headers[Constants.HeaderConstants.StorageVersionHeader]);
+                throw new NotSupportedException(errorMessage);
+            }
+        }
+
+        /// <summary>
+        /// Determines whether [is target version2] [the specified request].
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <returns>
+        /// Returns <c>true</c> if [is target version2] [the specified request]; otherwise, <c>false</c>.
+        /// </returns>
+        private static bool IsTargetVersion2(HttpWebRequest request)
+        {
+            string version = request.Headers[Constants.HeaderConstants.StorageVersionHeader];
+            DateTime versionTime;
+
+            if (DateTime.TryParse(
+                version,
+                CultureInfo.InvariantCulture,
+                DateTimeStyles.AdjustToUniversal,
+                out versionTime))
+            {
+                DateTime canonicalizationVer2Date = new DateTime(2009, 09, 19);
+
+                return versionTime.Date >= canonicalizationVer2Date;
+            }
+
+            return version.Equals("2009-09-19");
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/CanonicalizedString.cs b/microsoft-azure-api/StorageClient/Protocol/CanonicalizedString.cs
new file mode 100644
index 0000000000000..b2bca7c01a398
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/CanonicalizedString.cs
@@ -0,0 +1,74 @@
+//-----------------------------------------------------------------------
+// <copyright file="CanonicalizedString.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the CanonicalizedString class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// An internal class that stores the canonicalized string version of an HTTP request.
+    /// </summary>
+    internal class CanonicalizedString
+    {
+        /// <summary>
+        /// Stores the internal <see cref="StringBuilder"/> that holds the canonicalized string.
+        /// </summary>
+        private StringBuilder canonicalizedString = new StringBuilder();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CanonicalizedString"/> class.
+        /// </summary>
+        /// <param name="initialElement">The first canonicalized element to start the string with.</param>
+        internal CanonicalizedString(string initialElement)
+        {
+            this.canonicalizedString.Append(initialElement);
+        }
+
+        /// <summary>
+        /// Gets the canonicalized string.
+        /// </summary>
+        internal string Value
+        {
+            get
+            {
+                return this.canonicalizedString.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Append additional canonicalized element to the string.
+        /// </summary>
+        /// <param name="element">An additional canonicalized element to append to the string.</param>
+        internal void AppendCanonicalizedElement(string element)
+        {
+            this.canonicalizedString.Append("\n");
+            this.canonicalizedString.Append(element);
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/ConditionHeaderKind.cs b/microsoft-azure-api/StorageClient/Protocol/ConditionHeaderKind.cs
new file mode 100644
index 0000000000000..e6999353e2ac3
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ConditionHeaderKind.cs
@@ -0,0 +1,53 @@
+//-----------------------------------------------------------------------
+// <copyright file="ConditionHeaderKind.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ConditionHeaderKind enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Specifies the kinds of conditional headers that may be set for a request.
+    /// </summary>
+    public enum ConditionHeaderKind
+    {
+        /// <summary>
+        /// Indicates that no conditional headers are set.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// The If-Unmodified-Since header.
+        /// </summary>
+        IfUnmodifiedSince,
+
+        /// <summary>
+        /// The If-Match header.
+        /// </summary>
+        IfMatch,
+
+        /// <summary>
+        /// The If-Modified-Since header.
+        /// </summary>
+        IfModifiedSince,
+
+        /// <summary>
+        /// The If-None-Match header.
+        /// </summary>
+        IfNoneMatch
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/Constants.cs b/microsoft-azure-api/StorageClient/Protocol/Constants.cs
new file mode 100644
index 0000000000000..3680c975b7322
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/Constants.cs
@@ -0,0 +1,782 @@
+//-----------------------------------------------------------------------
+// <copyright file="Constants.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the Constants class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+
+    /// <summary>
+    /// Contains storage constants.
+    /// </summary>
+    internal class Constants
+    {        
+        /// <summary>
+        /// Maximum number of shared access policy identifiers supported by server.
+        /// </summary>
+        public const int MaxSharedAccessPolicyIdentifiers = 5;
+
+        /// <summary>
+        /// Default client side timeout for all service clients.
+        /// </summary>
+        public static readonly TimeSpan DefaultClientSideTimeout = TimeSpan.FromSeconds(90);
+
+        /// <summary>
+        /// Default Write Block Size used by Blob stream.
+        /// </summary>
+        public const long DefaultWriteBlockSizeBytes = 4 * Constants.MB;
+
+        /// <summary>
+        /// Default Read Ahead Size used by Blob stream.     
+        /// </summary>
+        public const long DefaultReadAheadSizeBytes = 512 * Constants.KB;
+
+        /// <summary>
+        /// The maximum size of a blob before it must be separated into blocks.
+        /// </summary>
+        public const long MaxSingleUploadBlobSize = 64 * MB;
+
+        /// <summary>
+        /// The maximum size of a blob with blocks.
+        /// </summary>
+        public const long MaxBlobSize = 200 * GB;
+
+        /// <summary>
+        /// The maximum size of a single block.
+        /// </summary>
+        public const long MaxBlockSize = 4 * 1024 * 1024;
+
+        /// <summary>
+        /// The maximum number of blocks.
+        /// </summary>
+        public const long MaxBlockNumber = 50000;
+
+        /// <summary>
+        /// Default size of buffer for unknown sized requests.
+        /// </summary>
+        internal const int DefaultBufferSize = 84000;
+
+        /// <summary>
+        /// This is used to create V1 BlockIDs. The prefix must be Base64 compatible.
+        /// </summary>
+        internal static readonly string V1BlockPrefix = "MD5/";
+
+        /// <summary>
+        /// This is the offset of the V2 MD5 string where the MD5/ tag resides.
+        /// </summary>
+        internal static readonly int V1MD5blockIdExpectedLength = 28;
+
+        /// <summary>
+        /// This is used to create BlockIDs. The prefix must be Base64 compatible.
+        /// </summary>
+        internal const string V2blockPrefix = "V2/";
+
+        /// <summary>
+        /// This is used to create BlockIDs. The prefix must be Base64 compatible.
+        /// </summary>
+        internal static readonly string V2MD5blockIdFormat = V2blockPrefix + "{0}/{1}";
+
+        /// <summary>
+        /// This is the offset of the V2 MD5 string where the hash value resides.
+        /// </summary>
+        internal static readonly int V2MD5blockIdMD5Offset = V2blockPrefix.Length + 8 + 1;
+
+        /// <summary>
+        /// This is the expected length of a V2 MD5 Block ID string.
+        /// </summary>
+        internal static readonly int V2MD5blockIdExpectedLength = V2MD5blockIdMD5Offset + 24;        
+
+        /// <summary>
+        /// The size of a page in a PageBlob.
+        /// </summary>
+        internal const long PageSize = 512;
+        
+        /// <summary>
+        /// A constant representing a kilo-byte (Non-SI version).
+        /// </summary>
+        internal const long KB = 1024;
+
+        /// <summary>
+        /// A constant representing a megabyte (Non-SI version).
+        /// </summary>
+        internal const long MB = 1024 * KB;
+
+        /// <summary>
+        /// A constant representing a megabyte (Non-SI version).
+        /// </summary>
+        internal const long GB = 1024 * MB;
+
+        /// <summary>
+        /// XML element for committed blocks.
+        /// </summary>
+        internal const string CommittedBlocksElement = "CommittedBlocks";
+
+        /// <summary>
+        /// XML element for uncommitted blocks.
+        /// </summary>
+        internal const string UncommittedBlocksElement = "UncommittedBlocks";
+
+        /// <summary>
+        /// XML element for blocks.
+        /// </summary>
+        internal const string BlockElement = "Block";
+
+        /// <summary>
+        /// XML element for names.
+        /// </summary>
+        internal const string NameElement = "Name";
+
+        /// <summary>
+        /// XML element for sizes.
+        /// </summary>
+        internal const string SizeElement = "Size";
+
+        /// <summary>
+        /// XML element for block lists.
+        /// </summary>
+        internal const string BlockListElement = "BlockList";
+
+        /// <summary>
+        /// XML element for queue message lists.
+        /// </summary>
+        internal const string MessagesElement = "QueueMessagesList";
+
+        /// <summary>
+        /// XML element for queue messages.
+        /// </summary>
+        internal const string MessageElement = "QueueMessage";
+
+        /// <summary>
+        /// XML element for message IDs.
+        /// </summary>
+        internal const string MessageIdElement = "MessageId";
+
+        /// <summary>
+        /// XML element for insertion times.
+        /// </summary>
+        internal const string InsertionTimeElement = "InsertionTime";
+
+        /// <summary>
+        /// XML element for expiration times.
+        /// </summary>
+        internal const string ExpirationTimeElement = "ExpirationTime";
+
+        /// <summary>
+        /// XML element for pop receipts.
+        /// </summary>
+        internal const string PopReceiptElement = "PopReceipt";
+
+        /// <summary>
+        /// XML element for the time next visible fields.
+        /// </summary>
+        internal const string TimeNextVisibleElement = "TimeNextVisible";
+
+        /// <summary>
+        /// XML element for message texts.
+        /// </summary>
+        internal const string MessageTextElement = "MessageText";
+
+        /// <summary>
+        /// XML element for dequeue counts.
+        /// </summary>
+        internal const string DequeueCountElement = "DequeueCount";
+
+        /// <summary>
+        /// XML element for page ranges.
+        /// </summary>
+        internal const string PageRangeElement = "PageRange";
+
+        /// <summary>
+        /// XML element for page list elements.
+        /// </summary>
+        internal const string PageListElement = "PageListElement";
+
+        /// <summary>
+        /// XML element for page range start elements.
+        /// </summary>
+        internal const string StartElement = "Start";
+
+        /// <summary>
+        /// XML element for page range end elements.
+        /// </summary>
+        internal const string EndElement = "End";
+
+        /// <summary>
+        /// XML element for delimiters.
+        /// </summary>
+        internal const string DelimiterElement = "Delimiter";
+
+        /// <summary>
+        /// XML element for blob prefixes.
+        /// </summary>
+        internal const string BlobPrefixElement = "BlobPrefix";
+
+        /// <summary>
+        /// XML element for content type fields.
+        /// </summary>
+        internal const string ContentTypeElement = "Content-Type";
+
+        /// <summary>
+        /// XML element for content encoding fields.
+        /// </summary>
+        internal const string ContentEncodingElement = "Content-Encoding";
+
+        /// <summary>
+        /// XML element for content language fields.
+        /// </summary>
+        internal const string ContentLanguageElement = "Content-Language";
+
+        /// <summary>
+        /// XML element for content length fields.
+        /// </summary>
+        internal const string ContentLengthElement = "Content-Length";
+
+        /// <summary>
+        /// XML element for content MD5 fields.
+        /// </summary>
+        internal const string ContentMD5Element = "Content-MD5";
+
+        /// <summary>
+        /// XML element for blobs.
+        /// </summary>
+        internal const string BlobsElement = "Blobs";
+
+        /// <summary>
+        /// XML element for prefixes.
+        /// </summary>
+        internal const string PrefixElement = "Prefix";
+
+        /// <summary>
+        /// XML element for maximum results.
+        /// </summary>
+        internal const string MaxResultsElement = "MaxResults";
+
+        /// <summary>
+        /// XML element for markers.
+        /// </summary>
+        internal const string MarkerElement = "Marker";
+
+        /// <summary>
+        /// XML element for the next marker.
+        /// </summary>
+        internal const string NextMarkerElement = "NextMarker";
+
+        /// <summary>
+        /// XML element for the ETag.
+        /// </summary>
+        internal const string EtagElement = "Etag";
+
+        /// <summary>
+        /// XML element for the last modified date.
+        /// </summary>
+        internal const string LastModifiedElement = "Last-Modified";
+
+        /// <summary>
+        /// XML element for the Url.
+        /// </summary>
+        internal const string UrlElement = "Url";
+
+        /// <summary>
+        /// XML element for blobs.
+        /// </summary>
+        internal const string BlobElement = "Blob";
+
+        /// <summary>
+        /// Constant signalling a page blob.
+        /// </summary>
+        internal const string PageBlobValue = "PageBlob";
+
+        /// <summary>
+        /// Constant signalling a block blob.
+        /// </summary>
+        internal const string BlockBlobValue = "BlockBlob";
+
+        /// <summary>
+        /// Constant signalling the blob is locked.
+        /// </summary>
+        internal const string LockedValue = "Locked";
+
+        /// <summary>
+        /// Constant signalling the blob is unlocked.
+        /// </summary>
+        internal const string UnlockedValue = "Unlocked";
+
+        /// <summary>
+        /// XML element for blob types.
+        /// </summary>
+        internal const string BlobTypeElement = "BlobType";
+
+        /// <summary>
+        /// XML element for the lease status.
+        /// </summary>
+        internal const string LeaseStatusElement = "LeaseStatus";
+
+        /// <summary>
+        /// XML element for snapshots.
+        /// </summary>
+        internal const string SnapshotElement = "Snapshot";
+
+        /// <summary>
+        /// XML element for containers.
+        /// </summary>
+        internal const string ContainersElement = "Containers";
+
+        /// <summary>
+        /// XML element for a container.
+        /// </summary>
+        internal const string ContainerElement = "Container";
+
+        /// <summary>
+        /// XML element for queues.
+        /// </summary>
+        internal const string QueuesElement = "Queues";
+
+        /// <summary>
+        /// XML element for the queue name.
+        /// </summary>
+        internal const string QueueNameElement = "QueueName";
+
+        /// <summary>
+        /// Version 2 of the XML element for the queue name.
+        /// </summary>
+        internal const string QueueNameElementVer2 = "Name";
+
+        /// <summary>
+        /// XML element for the queue.
+        /// </summary>
+        internal const string QueueElement = "Queue";
+
+        /// <summary>
+        /// XML element for the metadata.
+        /// </summary>
+        internal const string MetadataElement = "Metadata";
+
+        /// <summary>
+        /// XML element for an invalid metadata name.
+        /// </summary>
+        internal const string InvalidMetadataName = "x-ms-invalid-name";
+
+        /// <summary>
+        /// XPath query for error codes.
+        /// </summary>
+        internal const string ErrorCodeQuery = "//Error/Code";
+
+        /// <summary>
+        /// XPath query for error messages.
+        /// </summary>
+        internal const string ErrorMessageQuery = "//Error/Message";
+
+        /// <summary>
+        /// XML element for maximum results.
+        /// </summary>
+        internal const string MaxResults = "MaxResults";
+
+        /// <summary>
+        /// XML element for committed blocks.
+        /// </summary>
+        internal const string CommittedElement = "Committed";
+
+        /// <summary>
+        /// XML element for uncommitted blocks.
+        /// </summary>
+        internal const string UncommittedElement = "Uncommitted";
+
+        /// <summary>
+        /// XML element for the latest.
+        /// </summary>
+        internal const string LatestElement = "Latest";
+
+        /// <summary>
+        /// XML element for signed identifiers.
+        /// </summary>
+        internal const string SignedIdentifiers = "SignedIdentifiers";
+
+        /// <summary>
+        /// XML element for a signed identifier.
+        /// </summary>
+        internal const string SignedIdentifier = "SignedIdentifier";
+
+        /// <summary>
+        /// XML element for access policies.
+        /// </summary>
+        internal const string AccessPolicy = "AccessPolicy";
+
+        /// <summary>
+        /// XML attribute for IDs.
+        /// </summary>
+        internal const string Id = "Id";
+
+        /// <summary>
+        /// XML element for the start time of an access policy.
+        /// </summary>
+        internal const string Start = "Start";
+
+        /// <summary>
+        /// XML element for the end of an access policy.
+        /// </summary>
+        internal const string Expiry = "Expiry";
+
+        /// <summary>
+        /// XML element for the permissions of an access policy.
+        /// </summary>
+        internal const string Permission = "Permission";
+
+        /// <summary>
+        /// The maximum size of a string property for the table service in bytes.
+        /// </summary>
+        internal const int TableServiceMaxStringPropertySizeInBytes = 64 * 1024;
+
+        /// <summary>
+        /// The maximum size of a string property for the table service in chars.
+        /// </summary>
+        internal const int TableServiceMaxStringPropertySizeInChars = TableServiceMaxStringPropertySizeInBytes / 2;
+
+        /// <summary>
+        /// The minimum supported <see cref="DateTime"/> value for the table service.
+        /// </summary>
+        internal static readonly DateTime TableServiceMinSupportedDateTime = DateTime.FromFileTime(0).ToUniversalTime().AddYears(200);
+
+        /// <summary>
+        /// The name of the special table used to store tables.
+        /// </summary>
+        internal const string TableServiceTablesName = "Tables";
+
+        /// <summary>
+        /// The timeout after which the WCF Data Services bug workaround kicks in. This should be greater than the timeout we pass to DataServiceContext (90 seconds).
+        /// </summary>
+        internal static readonly TimeSpan TableWorkaroundTimeout = TimeSpan.FromSeconds(120);
+
+        /// <summary>
+        /// The Uri path component to access the messages in a queue.
+        /// </summary>
+        internal const string Messages = "messages";
+
+        /// <summary>
+        /// XML root element for errors.
+        /// </summary>
+        internal const string ErrorRootElement = "Error";
+
+        /// <summary>
+        /// XML element for error codes.
+        /// </summary>
+        internal const string ErrorCode = "Code";
+
+        /// <summary>
+        /// XML element for error messages.
+        /// </summary>
+        internal const string ErrorMessage = "Message";
+
+        /// <summary>
+        /// XML element for exception details.
+        /// </summary>
+        internal const string ErrorException = "ExceptionDetails";
+
+        /// <summary>
+        /// XML element for exception messages.
+        /// </summary>
+        internal const string ErrorExceptionMessage = "ExceptionMessage";
+
+        /// <summary>
+        /// XML element for stack traces.
+        /// </summary>
+        internal const string ErrorExceptionStackTrace = "StackTrace";
+
+        /// <summary>
+        /// XML element for the authentication error details.
+        /// </summary>
+        internal const string AuthenticationErrorDetail = "AuthenticationErrorDetail";
+
+        /// <summary>
+        /// XML namespace for the WCF Data Services metadata.
+        /// </summary>
+        internal const string DataWebMetadataNamespace = "http://schemas.microsoft.com/ado/2007/08/dataservices/metadata";
+
+        /// <summary>
+        /// XML element for table error codes.
+        /// </summary>
+        internal const string TableErrorCodeElement = "code";
+
+        /// <summary>
+        /// XML element for table error messages.
+        /// </summary>
+        internal const string TableErrorMessageElement = "message";
+
+        /// <summary>
+        /// Constants for HTTP headers.
+        /// </summary>
+        internal class HeaderConstants
+        {
+            /// <summary>
+            /// Master Windows Azure Storage header prefix.
+            /// </summary>
+            internal const string PrefixForStorageHeader = "x-ms-";
+
+            /// <summary>
+            /// Header prefix for properties.
+            /// </summary>
+            internal const string PrefixForStorageProperties = "x-ms-prop-";
+
+            /// <summary>
+            /// Header prefix for metadata.
+            /// </summary>
+            internal const string PrefixForStorageMetadata = "x-ms-meta-";
+
+            /// <summary>
+            /// Header for data ranges.
+            /// </summary>
+            internal const string StorageRangeHeader = PrefixForStorageHeader + "range";
+
+            /// <summary>
+            /// Header for storage version.
+            /// </summary>
+            internal const string StorageVersionHeader = PrefixForStorageHeader + "version";
+
+            /// <summary>
+            /// Header for copy source.
+            /// </summary>
+            internal const string CopySourceHeader = PrefixForStorageHeader + "copy-source";
+
+            /// <summary>
+            /// Header for the If-Match condition.
+            /// </summary>
+            internal const string SourceIfMatchHeader = PrefixForStorageHeader + "source-if-match";
+
+            /// <summary>
+            /// Header for the If-Modified-Since condition.
+            /// </summary>
+            internal const string SourceIfModifiedSinceHeader = PrefixForStorageHeader + "source-if-modified-since";
+
+            /// <summary>
+            /// Header for the If-None-Match condition.
+            /// </summary>
+            internal const string SourceIfNoneMatchHeader = PrefixForStorageHeader + "source-if-none-match";
+
+            /// <summary>
+            /// Header for the If-Unmodified-Since condition.
+            /// </summary>
+            internal const string SourceIfUnmodifiedSinceHeader = PrefixForStorageHeader + "source-if-unmodified-since";
+
+            /// <summary>
+            /// Header for the blob content length.
+            /// </summary>
+            internal const string Size = PrefixForStorageHeader + "blob-content-length";
+
+            /// <summary>
+            /// Header for the blob type.
+            /// </summary>
+            internal const string BlobType = PrefixForStorageHeader + "blob-type";
+
+            /// <summary>
+            /// Header for snapshots.
+            /// </summary>
+            internal const string SnapshotHeader = PrefixForStorageHeader + "snapshot";
+
+            /// <summary>
+            /// Header to delete snapshots.
+            /// </summary>
+            internal const string DeleteSnapshotHeader = PrefixForStorageHeader + "delete-snapshots";
+
+            /// <summary>
+            /// Header that specifies approximate message count of a queue.
+            /// </summary>
+            internal const string ApproximateMessagesCount = PrefixForStorageHeader + "approximate-messages-count";
+
+            /// <summary>
+            /// Header that specifies a range.
+            /// </summary>
+            internal const string RangeHeader = PrefixForStorageHeader + "range";
+
+            /// <summary>
+            /// Header that specifies blob caching control.
+            /// </summary>
+            internal const string CacheControlHeader = PrefixForStorageHeader + "blob-cache-control";
+
+            /// <summary>
+            /// Header that specifies blob content encoding.
+            /// </summary>
+            internal const string ContentEncodingHeader = PrefixForStorageHeader + "blob-content-encoding";
+
+            /// <summary>
+            /// Header that specifies blob content language.
+            /// </summary>
+            internal const string ContentLanguageHeader = PrefixForStorageHeader + "blob-content-language";
+
+            /// <summary>
+            /// Header that specifies blob content MD5.
+            /// </summary>
+            internal const string BlobContentMD5Header = PrefixForStorageHeader + "blob-content-md5";
+
+            /// <summary>
+            /// Header that specifies blob content type.
+            /// </summary>
+            internal const string ContentTypeHeader = PrefixForStorageHeader + "blob-content-type";
+
+            /// <summary>
+            /// Header that specifies blob content length.
+            /// </summary>
+            internal const string ContentLengthHeader = PrefixForStorageHeader + "blob-content-length";
+
+            /// <summary>
+            /// Header that specifies lease ID.
+            /// </summary>
+            internal const string LeaseIdHeader = PrefixForStorageHeader + "lease-id";
+
+            /// <summary>
+            /// Header that specifies lease status.
+            /// </summary>
+            internal const string LeaseStatus = PrefixForStorageHeader + "lease-status";
+
+            /// <summary>
+            /// Header that specifies page write mode.
+            /// </summary>
+            internal const string PageWrite = PrefixForStorageHeader + "page-write";
+
+            /// <summary>
+            /// Header that specifies the date.
+            /// </summary>
+            internal const string Date = PrefixForStorageHeader + "date";
+
+            /// <summary>
+            /// Header indicating the request ID.
+            /// </summary>
+            internal const string RequestIdHeader = PrefixForStorageHeader + "request-id";
+
+            /// <summary>
+            /// Header that specifies public access to blobs.
+            /// </summary>
+            internal const string BlobPublicAccess = PrefixForStorageHeader + "blob-public-access";
+
+            /// <summary>
+            /// Format string for specifying ranges.
+            /// </summary>
+            internal const string RangeHeaderFormat = "bytes={0}-{1}";
+
+            /// <summary>
+            /// Current storage version header value.
+            /// </summary>
+            internal const string TargetStorageVersion = "2011-08-18";
+
+            /// <summary>
+            /// Specifies the page blob type.
+            /// </summary>
+            internal const string PageBlob = "PageBlob";
+
+            /// <summary>
+            /// Specifies the block blob type.
+            /// </summary>
+            internal const string BlockBlob = "BlockBlob";
+
+            /// <summary>
+            /// Specifies only snapshots are to be included.
+            /// </summary>
+            internal const string SnapshotsOnlyValue = "only";
+
+            /// <summary>
+            /// Specifies snapshots are to be included.
+            /// </summary>
+            internal const string IncludeSnapshotsValue = "include";
+
+            /// <summary>
+            /// Specifies the value to use for UserAgent header.
+            /// </summary>
+            internal const string UserAgent = "WA-Storage/1.6.0";
+
+            /// <summary>
+            /// Specifies the pop receipt for a message.
+            /// </summary>
+            internal const string PopReceipt = PrefixForStorageHeader + "popreceipt";
+
+            /// <summary>
+            /// Specifies the next visible time for a message.
+            /// </summary>
+            internal const string NextVisibleTime = PrefixForStorageHeader + "time-next-visible";
+        }
+
+        /// <summary>
+        /// Constants for query strings.
+        /// </summary>
+        internal class QueryConstants
+        {
+            /// <summary>
+            /// Query component for snapshot time.
+            /// </summary>
+            internal const string Snapshot = "snapshot";
+
+            /// <summary>
+            /// Query component for the signed SAS start time.
+            /// </summary>
+            internal const string SignedStart = "st";
+
+            /// <summary>
+            /// Query component for the signed SAS expiry time.
+            /// </summary>
+            internal const string SignedExpiry = "se";
+
+            /// <summary>
+            /// Query component for the signed SAS resource.
+            /// </summary>
+            internal const string SignedResource = "sr";
+
+            /// <summary>
+            /// Query component for the signed SAS permissions.
+            /// </summary>
+            internal const string SignedPermissions = "sp";
+
+            /// <summary>
+            /// Query component for the signed SAS identifier.
+            /// </summary>
+            internal const string SignedIdentifier = "si";
+
+            /// <summary>
+            /// Query component for the signed SAS version.
+            /// </summary>
+            internal const string SignedVersion = "sv";
+
+            /// <summary>
+            /// Query component for SAS signature.
+            /// </summary>
+            internal const string Signature = "sig";
+
+            /// <summary>
+            /// Query component for message time-to-live.
+            /// </summary>
+            internal const string MessageTimeToLive = "messagettl";
+
+            /// <summary>
+            /// Query component for message visibility timeout.
+            /// </summary>
+            internal const string VisibilityTimeout = "visibilitytimeout";
+
+            /// <summary>
+            /// Query component for message pop receipt.
+            /// </summary>
+            internal const string PopReceipt = "popreceipt";
+
+            /// <summary>
+            /// Query component for resource type.
+            /// </summary>
+            internal const string ResourceType = "restype";
+
+            /// <summary>
+            /// Query component for the operation (component) to access.
+            /// </summary>
+            internal const string Component = "comp";
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/ContainerRequest.cs b/microsoft-azure-api/StorageClient/Protocol/ContainerRequest.cs
new file mode 100644
index 0000000000000..7b3c20c74d2a3
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ContainerRequest.cs
@@ -0,0 +1,327 @@
+//-----------------------------------------------------------------------
+// <copyright file="ContainerRequest.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ContainerRequest class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.IO;
+    using System.Net;
+    using System.Text;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides a set of methods for constructing requests for container operations.
+    /// </summary>
+    public static class ContainerRequest
+    {
+        /// <summary>
+        /// Constructs a web request to create a new container.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest Create(Uri uri, int timeout)
+        {
+            UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
+            return Request.Create(uri, timeout, containerBuilder);
+        }
+
+        /// <summary>
+        /// Constructs a web request to delete the container and all of blobs within it.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest Delete(Uri uri, int timeout)
+        {
+            UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
+            return Request.Delete(uri, timeout, containerBuilder);
+        }
+
+        /// <summary>
+        /// Constructs a web request to retrieve the container's metadata.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest GetMetadata(Uri uri, int timeout)
+        {
+            UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
+            return Request.GetMetadata(uri, timeout, containerBuilder);
+        }
+
+        /// <summary>
+        /// Constructs a web request to return the user-defined metadata for this container.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest GetProperties(Uri uri, int timeout)
+        {
+            UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
+            return Request.GetProperties(uri, timeout, containerBuilder);
+        }
+
+        /// <summary>
+        /// Constructs a web request to set user-defined metadata for the container.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest SetMetadata(Uri uri, int timeout)
+        {
+            UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
+            return Request.SetMetadata(uri, timeout, containerBuilder);
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void SignRequest(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForBlobAndQueue(request, credentials);
+        }
+
+        /// <summary>
+        /// Adds user-defined metadata to the request as one or more name-value pairs.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="metadata">The user-defined metadata.</param>
+        public static void AddMetadata(HttpWebRequest request, NameValueCollection metadata)
+        {
+            Request.AddMetadata(request, metadata);
+        }
+
+        /// <summary>
+        /// Adds user-defined metadata to the request as a single name-value pair.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="name">The metadata name.</param>
+        /// <param name="value">The metadata value.</param>
+        public static void AddMetadata(HttpWebRequest request, string name, string value)
+        {
+            Request.AddMetadata(request, name, value);
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key Lite authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void SignRequestForSharedKeyLite(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForBlobAndQueuesSharedKeyLite(request, credentials);
+        }
+
+        /// <summary>
+        /// Adds a conditional header to the request.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="header">The type of conditional header to add.</param>
+        /// <param name="etag">The container's ETag.</param>
+        public static void AddConditional(HttpWebRequest request, ConditionHeaderKind header, string etag)
+        {
+            Request.AddConditional(request, header, etag);
+        }
+
+        /// <summary>
+        /// Adds a conditional header to the request.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="header">The type of conditional header to add.</param>
+        /// <param name="dateTime">The date and time specification for the request.</param>
+        public static void AddConditional(HttpWebRequest request, ConditionHeaderKind header, DateTime dateTime)
+        {
+            Request.AddConditional(request, header, dateTime);
+        }
+
+        /// <summary>
+        /// Constructs a web request to return a listing of all containers in this storage account.
+        /// </summary>
+        /// <param name="uri">The absolute URI for the account.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="listingContext">A set of parameters for the listing operation.</param>
+        /// <param name="detailsIncluded">Additional details to return with the listing.</param>
+        /// <returns>A web request for the specified operation.</returns>
+        public static HttpWebRequest List(Uri uri, int timeout, ListingContext listingContext, ContainerListingDetails detailsIncluded)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "list");
+
+            if (listingContext != null)
+            {
+                if (listingContext.Prefix != null)
+                {
+                    builder.Add("prefix", listingContext.Prefix);
+                }
+
+                if (listingContext.Marker != null)
+                {
+                    builder.Add("marker", listingContext.Marker);
+                }
+
+                if (listingContext.MaxResults != null)
+                {
+                    builder.Add("maxresults", listingContext.MaxResults.ToString());
+                }
+            }
+
+            if ((detailsIncluded & ContainerListingDetails.Metadata) != 0)
+            {
+                builder.Add("include", "metadata");
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to return the ACL for this container.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns><returns>A web request to use to perform the operation.</returns></returns>
+        public static HttpWebRequest GetAcl(Uri uri, int timeout)
+        {
+            UriQueryBuilder builder = GetContainerUriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "acl");
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Sets the ACL for the container.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="publicAccess">The type of public access to allow for the container.</param>
+        /// <returns><returns>A web request to use to perform the operation.</returns></returns>
+        public static HttpWebRequest SetAcl(Uri uri, int timeout, BlobContainerPublicAccessType publicAccess)
+        {
+            UriQueryBuilder builder = GetContainerUriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "acl");
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.ContentLength = 0;
+            request.Method = "PUT";
+
+            if (publicAccess != BlobContainerPublicAccessType.Off)
+            {
+                request.Headers.Add("x-ms-blob-public-access", publicAccess.ToString().ToLower());
+            }
+
+            return request;
+        }
+
+        ////public string SharedAccessAuthenticatedURI(Uri uri, string permission) { return ""; }
+
+        /// <summary>
+        /// Writes a collection of shared access policies to the specified stream in XML format.
+        /// </summary>
+        /// <param name="sharedAccessPolicies">A collection of shared access policies.</param>
+        /// <param name="outputStream">An output stream.</param>
+        public static void WriteSharedAccessIdentifiers(SharedAccessPolicies sharedAccessPolicies, Stream outputStream)
+        {
+            CommonUtils.AssertNotNull("sharedAccessPolicies", sharedAccessPolicies);
+            CommonUtils.AssertNotNull("outputStream", outputStream);
+
+            if (sharedAccessPolicies.Count > Constants.MaxSharedAccessPolicyIdentifiers)
+            {
+                string errorMessage = string.Format(
+                    CultureInfo.CurrentCulture,
+                    SR.TooManyPolicyIdentifiers,
+                    sharedAccessPolicies.Count,
+                    Constants.MaxSharedAccessPolicyIdentifiers);
+
+                throw new ArgumentOutOfRangeException("sharedAccessPolicies", errorMessage);
+            }
+
+            XmlWriterSettings settings = new XmlWriterSettings();
+            settings.Encoding = Encoding.UTF8;
+
+            using (XmlWriter writer = XmlWriter.Create(outputStream, settings))
+            {
+                writer.WriteStartElement(Constants.SignedIdentifiers);
+
+                foreach (var key in sharedAccessPolicies.Keys)
+                {
+                    writer.WriteStartElement(Constants.SignedIdentifier);
+
+                    // Set the identifier
+                    writer.WriteElementString(Constants.Id, key);
+
+                    // Set the permissions
+                    writer.WriteStartElement(Constants.AccessPolicy);
+
+                    var policy = sharedAccessPolicies[key];
+
+                    writer.WriteElementString(
+                        Constants.Start,
+                        SharedAccessSignatureHelper.GetDateTimeOrEmpty(policy.SharedAccessStartTime));
+                    writer.WriteElementString(
+                        Constants.Expiry,
+                        SharedAccessSignatureHelper.GetDateTimeOrEmpty(policy.SharedAccessExpiryTime));
+                    writer.WriteElementString(
+                        Constants.Permission,
+                        SharedAccessPolicy.PermissionsToString(policy.Permissions));
+                    writer.WriteEndElement();
+                    writer.WriteEndElement();
+                }
+
+                writer.WriteEndDocument();
+            }
+        }
+
+        /// <summary>
+        /// Gets the container Uri query builder.
+        /// </summary>
+        /// <returns>A <see cref="UriQueryBuilder"/> for the container.</returns>
+        internal static UriQueryBuilder GetContainerUriQueryBuilder()
+        {
+            UriQueryBuilder uriBuilder = new UriQueryBuilder();
+            uriBuilder.Add(Constants.QueryConstants.ResourceType, "container");
+            return uriBuilder;
+        }
+
+        /// <summary>
+        /// Creates the web request.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the container.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="query">The query builder to use.</param>
+        /// <returns><returns>A web request to use to perform the operation.</returns></returns>
+        private static HttpWebRequest CreateWebRequest(Uri uri, int timeout, UriQueryBuilder query)
+        {
+            return Request.CreateWebRequest(uri, timeout, query);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/ContainerResponse.cs b/microsoft-azure-api/StorageClient/Protocol/ContainerResponse.cs
new file mode 100644
index 0000000000000..411f331c94ab4
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ContainerResponse.cs
@@ -0,0 +1,118 @@
+//-----------------------------------------------------------------------
+// <copyright file="ContainerResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ContainerResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Net;
+
+    /// <summary>
+    /// Provides a set of methods for parsing responses from container operations.
+    /// </summary>
+    public static class ContainerResponse
+    {
+        /// <summary>
+        /// Returns extended error information from the storage service, that is in addition to the HTTP status code returned with the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object containing extended error information returned with the response.</returns>
+        public static StorageExtendedErrorInformation GetError(HttpWebResponse response)
+        {
+            return Response.GetError(response);
+        }
+
+        /// <summary>
+        /// Gets a collection of user-defined metadata from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A collection of user-defined metadata, as name-value pairs.</returns>
+        public static NameValueCollection GetMetadata(HttpWebResponse response)
+        {
+            return Response.GetMetadata(response);
+        }
+
+        /// <summary>
+        /// Gets an array of values for a specified name-value pair from the user-defined metadata included in the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <param name="name">The name associated with the metadata values to return.</param>
+        /// <returns>An array of metadata values.</returns>
+        public static string[] GetMetadata(HttpWebResponse response, string name)
+        {
+            return Response.GetMetadata(response, name);
+        }
+
+        /// <summary>
+        /// Gets the container's attributes, including its metadata and properties, from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>The container's attributes.</returns>
+        public static BlobContainerAttributes GetAttributes(HttpWebResponse response)
+        {
+            var containerAttributes = new BlobContainerAttributes();
+            containerAttributes.Uri = new Uri(response.ResponseUri.GetLeftPart(UriPartial.Path));
+            var segments = containerAttributes.Uri.Segments;
+            containerAttributes.Name = segments[segments.Length - 1];
+
+            var containerProperties = containerAttributes.Properties;
+            containerProperties.ETag = response.Headers[HttpResponseHeader.ETag];
+            containerProperties.LastModifiedUtc = response.LastModified.ToUniversalTime();
+
+            containerAttributes.Metadata = GetMetadata(response);
+
+            return containerAttributes;
+        }
+
+        /// <summary>
+        /// Gets the request ID from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A unique value associated with the request.</returns>
+        public static string GetRequestId(HttpWebResponse response)
+        {
+            return Response.GetRequestId(response);
+        }
+
+        /// <summary>
+        /// Gets the ACL for the container from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A value indicating the public access level for the container.</returns>
+        public static string GetAcl(HttpWebResponse response)
+        {
+            return Response.GetHeaders(response)[Constants.HeaderConstants.BlobPublicAccess];
+        }
+
+        /// <summary>
+        /// Parses the response for a container listing operation.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object that may be used for parsing data from the results of a container listing operation.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1011:ConsiderPassingBaseTypesAsParameters",
+            Justification = "Storage only supports HTTP")]
+        public static ListContainersResponse List(HttpWebResponse response)
+        {
+            return new ListContainersResponse(response.GetResponseStream());
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/Credentials.cs b/microsoft-azure-api/StorageClient/Protocol/Credentials.cs
new file mode 100644
index 0000000000000..a2f5250153cab
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/Credentials.cs
@@ -0,0 +1,90 @@
+//-----------------------------------------------------------------------
+// <copyright file="Credentials.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the Credentials class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+
+    /// <summary>
+    /// Represents the credentials used to sign a request against the storage services.
+    /// </summary>
+    public class Credentials
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Credentials"/> class.
+        /// </summary>
+        /// <param name="accountName">The storage account name.</param>
+        /// <param name="key">The access key.</param>
+        public Credentials(string accountName, byte[] key)
+        {
+            if (String.IsNullOrEmpty(accountName))
+            {
+                throw new ArgumentException("accountName");
+            }
+
+            if (key == null)
+            {
+                throw new ArgumentNullException("key");
+            }
+
+            this.AccountName = accountName;
+            this.Key = new StorageKey(key);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Credentials"/> class.
+        /// </summary>
+        /// <param name="accountName">The storage account name.</param>
+        /// <param name="base64EncodedKey">The access key, as a Base64-encoded string.</param>
+        public Credentials(string accountName, string base64EncodedKey)
+            : this(accountName, Convert.FromBase64String(base64EncodedKey))
+        {
+        }
+
+        /// <summary>
+        /// Gets the account name to be used in signing the request.
+        /// </summary>
+        /// <value>The name of the account.</value>
+        public string AccountName { get; private set; }
+
+        /// <summary>
+        /// Gets the access key to be used in signing the request.
+        /// </summary>
+        internal StorageKey Key { get; private set; }
+
+        /// <summary>
+        /// Exports the value of the access key to an array of bytes.
+        /// </summary>
+        /// <returns>The account access key.</returns>
+        public byte[] ExportKey()
+        {
+            return this.Key.GetKey();
+        }
+
+        /// <summary>
+        /// Exports the value of the access key to a Base64-encoded string.
+        /// </summary>
+        /// <returns>The account access key.</returns>
+        public string ExportBase64EncodedKey()
+        {
+            return this.Key.GetBase64EncodedKey();
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/GetBlockListResponse.cs b/microsoft-azure-api/StorageClient/Protocol/GetBlockListResponse.cs
new file mode 100644
index 0000000000000..c3bea9402c766
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/GetBlockListResponse.cs
@@ -0,0 +1,117 @@
+//-----------------------------------------------------------------------
+// <copyright file="GetBlockListResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the GetBlockListResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides methods for parsing the response from an operation to return a block list.
+    /// </summary>
+    public class GetBlockListResponse : ResponseParsingBase<ListBlockItem>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetBlockListResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream to be parsed.</param>
+        internal GetBlockListResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of <see cref="ListBlockItem"/> objects from the response.
+        /// </summary>
+        /// <value>An enumerable collection of <see cref="ListBlockItem"/> objects.</value>
+        public IEnumerable<ListBlockItem> Blocks
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Parses the XML response returned by an operation to retrieve a list of blocks.
+        /// </summary>
+        /// <returns>An enumerable collection of <see cref="ListBlockItem"/> objects.</returns>
+        protected override IEnumerable<ListBlockItem> ParseXml()
+        {
+            bool committedBlocks = true;
+            while (reader.Read())
+            {
+                // Run through the stream until we find what we are looking for.  Retain what we've found.
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                {
+                    switch (reader.Name)
+                    {
+                        case Constants.BlockElement:
+                            // We found a block.
+                            ListBlockItem block = null;
+                            long size = 0;
+                            string blockId = null;
+
+                            // Go until we are out of the block.
+                            bool needToRead = true;
+                            while (true)
+                            {
+                                if (needToRead && !reader.Read())
+                                {
+                                    break;
+                                }
+
+                                needToRead = true;
+
+                                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                                {
+                                    switch (reader.Name)
+                                    {
+                                        case Constants.SizeElement:
+                                            size = reader.ReadElementContentAsLong();
+                                            needToRead = false;
+                                            break;
+                                        case Constants.NameElement:
+                                            blockId = reader.ReadElementContentAsString();
+                                            needToRead = false;
+                                            break;
+                                    }
+                                }
+                                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.BlockElement)
+                                {
+                                    block = new ListBlockItem() { Name = blockId, Size = size, Committed = committedBlocks };
+                                    break;
+                                }
+                            }
+
+                            yield return block;
+                            break;
+                        case Constants.CommittedBlocksElement:
+                            committedBlocks = true;
+                            break;
+                        case Constants.UncommittedBlocksElement:
+                            committedBlocks = false;
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/GetMessagesResponse.cs b/microsoft-azure-api/StorageClient/Protocol/GetMessagesResponse.cs
new file mode 100644
index 0000000000000..26b5422e54f19
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/GetMessagesResponse.cs
@@ -0,0 +1,151 @@
+//-----------------------------------------------------------------------
+// <copyright file="GetMessagesResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the GetMessagesResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides methods for parsing the response from an operation to get messages from a queue.
+    /// </summary>
+    public class GetMessagesResponse : ResponseParsingBase<QueueMessage>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetMessagesResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream of messages to parse.</param>
+        internal GetMessagesResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of <see cref="QueueMessage"/> objects from the response.
+        /// </summary>
+        /// <value>An enumerable collection of <see cref="QueueMessage"/> objects.</value>
+        public IEnumerable<QueueMessage> Messages
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Parses the XML response returned by an operation to get messages from a queue.
+        /// </summary>
+        /// <returns>An enumerable collection of <see cref="QueueMessage"/> objects.</returns>
+        protected override IEnumerable<QueueMessage> ParseXml()
+        {
+            // While we're still in the QueueMessageList section.
+            while (reader.Read())
+            {
+                // We found a queue message.
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.MessageElement)
+                {
+                    QueueMessage message = null;
+                    string id = null;
+                    string popReceipt = null;
+                    DateTime? insertionTime = null;
+                    DateTime? expirationTime = null;
+                    DateTime? timeNextVisible = null;
+                    string text = null;
+                    int dequeueCount = 0;
+
+                    // Go until we are out of the block.
+                    bool needToRead = true;
+                    while (true)
+                    {
+                        if (needToRead && !reader.Read())
+                        {
+                            break;
+                        }
+
+                        needToRead = true;
+
+                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                        {
+                            switch (reader.Name)
+                            {
+                                case Constants.MessageIdElement:
+                                    id = reader.ReadElementContentAsString();
+                                    needToRead = false;
+                                    break;
+                                case Constants.PopReceiptElement:
+                                    popReceipt = reader.ReadElementContentAsString();
+                                    needToRead = false;
+                                    break;
+                                case Constants.InsertionTimeElement:
+                                    insertionTime = reader.ReadElementContentAsString().ToUTCTime();
+                                    needToRead = false;
+                                    break;
+                                case Constants.ExpirationTimeElement:
+                                    expirationTime = reader.ReadElementContentAsString().ToUTCTime();
+                                    needToRead = false;
+                                    break;
+                                case Constants.TimeNextVisibleElement:
+                                    timeNextVisible = reader.ReadElementContentAsString().ToUTCTime();
+                                    needToRead = false;
+                                    break;
+                                case Constants.MessageTextElement:
+                                    text = reader.ReadElementContentAsString();
+                                    needToRead = false;
+                                    break;
+                                case Constants.DequeueCountElement:
+                                    dequeueCount = reader.ReadElementContentAsInt();
+                                    needToRead = false;
+                                    break;
+                            }
+                        }
+                        else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.MessageElement)
+                        {
+                            message = new QueueMessage();
+                            message.Text = text;
+                            message.Id = id;
+                            message.PopReceipt = popReceipt;
+                            message.DequeueCount = dequeueCount;
+
+                            if (insertionTime != null)
+                            {
+                                message.InsertionTime = (DateTime)insertionTime;
+                            }
+
+                            if (expirationTime != null)
+                            {
+                                message.ExpirationTime = (DateTime)expirationTime;
+                            }
+
+                            message.TimeNextVisible = timeNextVisible;
+                            break;
+                        }
+                    }
+
+                    yield return message;
+                }
+                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.MessagesElement)
+                {
+                    break;
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/GetPageRangesResponse.cs b/microsoft-azure-api/StorageClient/Protocol/GetPageRangesResponse.cs
new file mode 100644
index 0000000000000..3426319ddfa47
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/GetPageRangesResponse.cs
@@ -0,0 +1,109 @@
+//-----------------------------------------------------------------------
+// <copyright file="GetPageRangesResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the GetPageRangesResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides methods for parsing the response from an operation to get a range of pages for a page blob.
+    /// </summary>
+    public class GetPageRangesResponse : ResponseParsingBase<PageRange>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="GetPageRangesResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream of page ranges to be parsed.</param>
+        internal GetPageRangesResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of <see cref="PageRange"/> objects from the response.
+        /// </summary>
+        /// <value>An enumerable collection of <see cref="PageRange"/> objects.</value>
+        public IEnumerable<PageRange> PageRanges
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Parses the XML response for an operation to get a range of pages for a page blob.
+        /// </summary>
+        /// <returns>An enumerable collection of <see cref="PageRange"/> objects.</returns>
+        protected override IEnumerable<PageRange> ParseXml()
+        {
+            // While we're still in the QueueMessageList section.
+            while (reader.Read())
+            {
+                // We found a queue message.
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.PageRangeElement)
+                {
+                    PageRange pageRange = null;
+                    long start = 0L;
+                    long end = 0L;
+                    bool needToRead = true;
+
+                    // Go until we are out of the block.
+                    while (true)
+                    {
+                        if (needToRead && !reader.Read())
+                        {
+                            break;
+                        }
+
+                        needToRead = true;
+
+                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                        {
+                            switch (reader.Name)
+                            {
+                                case Constants.StartElement:
+                                    start = reader.ReadElementContentAsLong();
+                                    needToRead = false;
+                                    break;
+                                case Constants.EndElement:
+                                    end = reader.ReadElementContentAsLong();
+                                    needToRead = false;
+                                    break;
+                            }
+                        }
+                        else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.PageRangeElement)
+                        {
+                            pageRange = new PageRange(start, end);
+                            break;
+                        }
+                    }
+
+                    yield return pageRange;
+                }
+                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.PageListElement)
+                {
+                    break;
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/IListBlobEntry.cs b/microsoft-azure-api/StorageClient/Protocol/IListBlobEntry.cs
new file mode 100644
index 0000000000000..d6b7a78e11636
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/IListBlobEntry.cs
@@ -0,0 +1,29 @@
+//-----------------------------------------------------------------------
+// <copyright file="IListBlobEntry.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the IListBlobEntry interface.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{   
+    /// <summary>
+    /// Defines an interface for blob items that are returned in the XML response for a blob listing operation.
+    /// </summary>
+    public interface IListBlobEntry 
+    {
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/LeaseAction.cs b/microsoft-azure-api/StorageClient/Protocol/LeaseAction.cs
new file mode 100644
index 0000000000000..bf7dfe55f4b50
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/LeaseAction.cs
@@ -0,0 +1,48 @@
+//-----------------------------------------------------------------------
+// <copyright file="LeaseAction.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the LeaseAction enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Describes actions that can be performed on a lease.
+    /// </summary>
+    public enum LeaseAction
+    {
+        /// <summary>
+        /// Acquire the lease.
+        /// </summary>
+        Acquire,
+
+        /// <summary>
+        /// Renew the lease.
+        /// </summary>
+        Renew,
+
+        /// <summary>
+        /// Release the lease.
+        /// </summary>
+        Release,
+
+        /// <summary>
+        /// Break the lease.
+        /// </summary>
+        Break
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/ListBlobsResponse.cs b/microsoft-azure-api/StorageClient/Protocol/ListBlobsResponse.cs
new file mode 100644
index 0000000000000..6771f7bbc53cc
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ListBlobsResponse.cs
@@ -0,0 +1,458 @@
+//-----------------------------------------------------------------------
+// <copyright file="ListBlobsResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ListBlobsResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Xml;
+    
+    /// <summary>
+    /// Provides methods for parsing the response from a blob listing operation.
+    /// </summary>
+    public class ListBlobsResponse : ResponseParsingBase<IListBlobEntry>
+    {
+        /// <summary>
+        /// Stores the blob prefix.
+        /// </summary>
+        private string prefix;
+
+        /// <summary>
+        /// Signals when the blob prefix can be consumed.
+        /// </summary>
+        private bool prefixConsumable;
+
+        /// <summary>
+        /// Stores the marker.
+        /// </summary>
+        private string marker;
+
+        /// <summary>
+        /// Signals when the marker can be consumed.
+        /// </summary>
+        private bool markerConsumable;
+
+        /// <summary>
+        /// Stores the blob delimiter.
+        /// </summary>
+        private string delimiter;
+
+        /// <summary>
+        /// Signals when the blob delimiter can be consumed.
+        /// </summary>
+        private bool delimiterConsumable;
+
+        /// <summary>
+        /// Stores the max results.
+        /// </summary>
+        private int maxResults;
+
+        /// <summary>
+        /// Signals when the max results can be consumed.
+        /// </summary>
+        private bool maxResultsConsumable;
+
+        /// <summary>
+        /// Stores the next marker.
+        /// </summary>
+        private string nextMarker;
+
+        /// <summary>
+        /// Signals when the next marker can be consumed.
+        /// </summary>
+        private bool nextMarkerConsumable;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ListBlobsResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream to be parsed.</param>
+        internal ListBlobsResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets the listing context from the XML response.
+        /// </summary>
+        /// <value>A set of parameters for the listing operation.</value>
+        public BlobListingContext ListingContext
+        {
+            get
+            {
+                string prefix = this.Prefix;
+                int maxResults = this.MaxResults;
+                string delimiter = this.Delimiter;
+                string nextMarker = this.NextMarker;
+                BlobListingContext listingContext = new BlobListingContext(
+                    prefix,
+                    maxResults,
+                    delimiter,
+                    BlobListingDetails.None);
+                listingContext.Marker = nextMarker;
+                return listingContext;
+            }
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of objects that implement <see cref="IListBlobEntry"/> from the response.
+        /// </summary>
+        /// <value>An enumerable collection of objects that implement <see cref="IListBlobEntry"/>.</value>
+        public IEnumerable<IListBlobEntry> Blobs
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Prefix value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The Prefix value.</value>
+        public string Prefix
+        {
+            get
+            {
+                this.Variable(ref this.prefixConsumable);
+
+                return this.prefix;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Marker value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The Marker value.</value>
+        public string Marker
+        {
+            get
+            {
+                this.Variable(ref this.markerConsumable);
+
+                return this.marker;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Delimiter value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The Delimiter value.</value>
+        public string Delimiter
+        {
+            get
+            {
+                this.Variable(ref this.delimiterConsumable);
+
+                return this.delimiter;
+            }
+        }
+
+        /// <summary>
+        /// Gets the MaxResults value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The MaxResults value.</value>
+        public int MaxResults
+        {
+            get
+            {
+                this.Variable(ref this.maxResultsConsumable);
+
+                return this.maxResults;
+            }
+        }
+
+        /// <summary>
+        /// Gets the NextMarker value from the XML response, if the listing was not complete.
+        /// </summary>
+        /// <value>The NextMarker value.</value>
+        public string NextMarker
+        {
+            get
+            {
+                this.Variable(ref this.nextMarkerConsumable);
+
+                return this.nextMarker;
+            }
+        }
+
+        /// <summary>
+        /// Parses the response XML for a blob listing operation.
+        /// </summary>
+        /// <returns>An enumerable collection of objects that implement <see cref="IListBlobEntry"/>.</returns>
+        protected override IEnumerable<IListBlobEntry> ParseXml()
+        {
+            bool needToRead = true;
+
+            while (true)
+            {
+                if (needToRead && !reader.Read())
+                {
+                    break;
+                }
+
+                needToRead = true;
+
+                // Run through the stream until we find what we are looking for.  Retain what we've found.
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                {
+                    switch (reader.Name)
+                    {
+                        case Constants.DelimiterElement:
+                            needToRead = false;
+                            this.delimiter = reader.ReadElementContentAsString();
+                            this.delimiterConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.MarkerElement:
+                            needToRead = false;
+                            this.marker = reader.ReadElementContentAsString();
+                            this.markerConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.NextMarkerElement:
+                            needToRead = false;
+                            this.nextMarker = reader.ReadElementContentAsString();
+                            this.nextMarkerConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.MaxResultsElement:
+                            needToRead = false;
+                            this.maxResults = reader.ReadElementContentAsInt();
+                            this.maxResultsConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.PrefixElement:
+                            needToRead = false;
+                            this.prefix = reader.ReadElementContentAsString();
+                            this.prefixConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.BlobsElement:
+                            // While we're still in the blobs section.
+                            while (reader.Read())
+                            {
+                                // We found a blob.
+                                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.BlobElement)
+                                {
+                                    BlobAttributes blob = null;
+                                    string url = null;
+                                    DateTime? lastModifiedTime = null;
+                                    string etag = null;
+                                    string name = null;
+                                    long? contentLength = null;
+                                    string contentType = null;
+                                    string contentEncoding = null;
+                                    string contentLanguage = null;
+                                    string contentMD5 = null;
+                                    BlobType? blobType = null;
+                                    LeaseStatus? leaseStatus = null;
+                                    DateTime? snapshot = null;
+                                    NameValueCollection metadata = null;
+
+                                    // Go until we are out of the blob.
+                                    bool blobNeedToRead = true;
+
+                                    while (true)
+                                    {
+                                        if (blobNeedToRead && !reader.Read())
+                                        {
+                                            break;
+                                        }
+
+                                        blobNeedToRead = true;
+
+                                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                                        {
+                                            switch (reader.Name)
+                                            {
+                                                case Constants.UrlElement:
+                                                    url = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.LastModifiedElement:
+                                                    lastModifiedTime = reader.ReadElementContentAsString().ToUTCTime();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.EtagElement:
+                                                    etag = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.NameElement:
+                                                    name = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.ContentLengthElement:
+                                                    contentLength = reader.ReadElementContentAsLong();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.ContentTypeElement:
+                                                    contentType = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.ContentEncodingElement:
+                                                    contentEncoding = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.ContentLanguageElement:
+                                                    contentLanguage = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.ContentMD5Element:
+                                                    contentMD5 = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.BlobTypeElement:
+                                                    string blobTypeString = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+
+                                                    switch (blobTypeString)
+                                                    {
+                                                        case Constants.BlockBlobValue:
+                                                            blobType = BlobType.BlockBlob;
+                                                            break;
+                                                        case Constants.PageBlobValue:
+                                                            blobType = BlobType.PageBlob;
+                                                            break;
+                                                    }
+
+                                                    break;
+                                                case Constants.LeaseStatusElement:
+                                                    string leaseStatusString = reader.ReadElementContentAsString();
+                                                    blobNeedToRead = false;
+
+                                                    switch (leaseStatusString)
+                                                    {
+                                                        case Constants.LockedValue:
+                                                            leaseStatus = LeaseStatus.Locked;
+                                                            break;
+                                                        case Constants.UnlockedValue:
+                                                            leaseStatus = LeaseStatus.Unlocked;
+                                                            break;
+                                                    }
+
+                                                    break;
+                                                case Constants.SnapshotElement:
+                                                    snapshot = reader.ReadElementContentAsString().ToUTCTime();
+                                                    blobNeedToRead = false;
+                                                    break;
+                                                case Constants.MetadataElement:
+                                                    metadata = Response.ParseMetadata(reader);
+                                                    blobNeedToRead = false;
+                                                    break;
+                                            }
+                                        }
+                                        else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.BlobElement)
+                                        {
+                                            blob = new BlobAttributes();
+                                            blob.Properties = new BlobProperties();
+                                            blob.Properties.ContentEncoding = contentEncoding;
+                                            blob.Properties.ContentLanguage = contentLanguage;
+                                            blob.Properties.ContentMD5 = contentMD5;
+                                            blob.Properties.Length = contentLength ?? 0;
+                                            blob.Properties.ContentType = contentType;
+                                            blob.Properties.ETag = etag;
+
+                                            if (lastModifiedTime != null)
+                                            {
+                                                blob.Properties.LastModifiedUtc = (DateTime)lastModifiedTime;
+                                            }
+
+                                            var blobNameSectionIndex = url.LastIndexOf(NavigationHelper.Slash + name);
+                                            string baseUri = url.Substring(0, blobNameSectionIndex + 1);
+                                            var ub = new UriBuilder(baseUri);
+                                            ub.Path += Uri.EscapeUriString(name);
+                                            if (baseUri.Length + name.Length < url.Length)
+                                            {
+                                                // it's a url for snapshot. 
+                                                // Snapshot blob URI example:http://<yourstorageaccount>.blob.core.windows.net/<yourcontainer>/<yourblobname>?snapshot=2009-12-03T15%3a26%3a19.4466877Z 
+                                                ub.Query = url.Substring(baseUri.Length + name.Length + 1);
+                                            }
+
+                                            blob.Uri = ub.Uri;
+                                            
+                                            blob.Properties.LeaseStatus = leaseStatus ?? LeaseStatus.Unspecified;
+
+                                            if (snapshot != null)
+                                            {
+                                                blob.Snapshot = (DateTime)snapshot;
+                                            }
+
+                                            blob.Properties.BlobType = blobType ?? BlobType.Unspecified;
+
+                                            if (metadata != null)
+                                            {
+                                                blob.Metadata = metadata;
+                                            }
+
+                                            break;
+                                        }
+                                    }
+
+                                    yield return new BlobEntry(name, blob);
+                                }
+                                else if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.BlobPrefixElement)
+                                {
+                                    BlobPrefixEntry commonPrefix = new BlobPrefixEntry();
+
+                                    // Go until we are out of the blob.
+                                    bool blobPrefixNeedToRead = true;
+
+                                    while (true)
+                                    {
+                                        if (blobPrefixNeedToRead && !reader.Read())
+                                        {
+                                            break;
+                                        }
+
+                                        blobPrefixNeedToRead = true;
+
+                                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                                        {
+                                            switch (reader.Name)
+                                            {
+                                                case Constants.NameElement:
+                                                    commonPrefix.Name = reader.ReadElementContentAsString();
+                                                    blobPrefixNeedToRead = false;
+                                                    break;
+                                            }
+                                        }
+                                        else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.BlobPrefixElement)
+                                        {
+                                            break;
+                                        }
+                                    }
+
+                                    yield return commonPrefix;
+                                }
+                                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.BlobsElement)
+                                {
+                                    this.allObjectsParsed = true;
+                                    break;
+                                }
+                            }
+
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/ListContainersResponse.cs b/microsoft-azure-api/StorageClient/Protocol/ListContainersResponse.cs
new file mode 100644
index 0000000000000..f60270a1bc8f6
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ListContainersResponse.cs
@@ -0,0 +1,303 @@
+//-----------------------------------------------------------------------
+// <copyright file="ListContainersResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ListContainersResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides methods for parsing the response from a container listing operation.
+    /// </summary>
+    public class ListContainersResponse : ResponseParsingBase<BlobContainerEntry>
+    {
+        /// <summary>
+        /// Stores the container prefix.
+        /// </summary>
+        private string prefix;
+
+        /// <summary>
+        /// Signals when the container prefix can be consumed.
+        /// </summary>
+        private bool prefixConsumable;
+
+        /// <summary>
+        /// Stores the marker.
+        /// </summary>
+        private string marker;
+
+        /// <summary>
+        /// Signals when the marker can be consumed.
+        /// </summary>
+        private bool markerConsumable;
+
+        /// <summary>
+        /// Stores the max results.
+        /// </summary>
+        private int maxResults;
+
+        /// <summary>
+        /// Signals when the max results can be consumed.
+        /// </summary>
+        private bool maxResultsConsumable;
+
+        /// <summary>
+        /// Stores the next marker.
+        /// </summary>
+        private string nextMarker;
+
+        /// <summary>
+        /// Signals when the next marker can be consumed.
+        /// </summary>
+        private bool nextMarkerConsumable;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ListContainersResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream to be parsed.</param>
+        internal ListContainersResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets the listing context from the XML response.
+        /// </summary>
+        /// <value>A set of parameters for the listing operation.</value>
+        public ListingContext ListingContext
+        {
+            get
+            {
+                // Force a parsing in order
+                ListingContext listingContext = new ListingContext(this.Prefix, this.MaxResults);
+                listingContext.Marker = this.NextMarker;
+                return listingContext;
+            }
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of <see cref="BlobContainerEntry"/> objects from the response.
+        /// </summary>
+        /// <value>An enumerable collection of <see cref="BlobContainerEntry"/> objects.</value>
+        public IEnumerable<BlobContainerEntry> Containers
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Prefix value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The Prefix value.</value>
+        public string Prefix
+        {
+            get
+            {
+                this.Variable(ref this.prefixConsumable);
+
+                return this.prefix;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Marker value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The Marker value.</value>
+        public string Marker
+        {
+            get
+            {
+                this.Variable(ref this.markerConsumable);
+
+                return this.marker;
+            }
+        }
+
+        /// <summary>
+        /// Gets the MaxResults value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The MaxResults value.</value>
+        public int MaxResults
+        {
+            get
+            {
+                this.Variable(ref this.maxResultsConsumable);
+
+                return this.maxResults;
+            }
+        }
+
+        /// <summary>
+        /// Gets the NextMarker value from the XML response, if the listing was not complete.
+        /// </summary>
+        /// <value>The NextMarker value.</value>
+        public string NextMarker
+        {
+            get
+            {
+                this.Variable(ref this.nextMarkerConsumable);
+
+                return this.nextMarker;
+            }
+        }
+
+        /// <summary>
+        /// Parses the response XML for a container listing operation.
+        /// </summary>
+        /// <returns>An enumerable collection of <see cref="BlobContainerEntry"/> objects.</returns>
+        protected override IEnumerable<BlobContainerEntry> ParseXml()
+        {
+            bool needToRead = true;
+
+            while (true)
+            {
+                if (needToRead && !reader.Read())
+                {
+                    break;
+                }
+
+                needToRead = true;
+
+                // Run through the stream until we find what we are looking for.  Retain what we've found.
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                {
+                    switch (reader.Name)
+                    {
+                        case Constants.MarkerElement:
+                            needToRead = false;
+                            this.marker = reader.ReadElementContentAsString();
+                            this.markerConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.NextMarkerElement:
+                            needToRead = false;
+                            this.nextMarker = reader.ReadElementContentAsString();
+                            this.nextMarkerConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.MaxResultsElement:
+                            needToRead = false;
+                            this.maxResults = reader.ReadElementContentAsInt();
+                            this.maxResultsConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.PrefixElement:
+                            needToRead = false;
+                            this.prefix = reader.ReadElementContentAsString();
+                            this.prefixConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.ContainersElement:
+                            while (reader.Read())
+                            {
+                                // We found a container.
+                                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.ContainerElement)
+                                {
+                                    BlobContainerAttributes container = null;
+                                    Uri uri = null;
+                                    DateTime? lastModifiedTime = null;
+                                    string etag = null;
+                                    string name = null;
+                                    NameValueCollection metadata = null;
+
+                                    // Go until we are out of the container.
+                                    bool containersNeedToRead = true;
+                                    while (true)
+                                    {
+                                        if (containersNeedToRead && !reader.Read())
+                                        {
+                                            break;
+                                        }
+
+                                        containersNeedToRead = true;
+
+                                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                                        {
+                                            switch (reader.Name)
+                                            {
+                                                case Constants.UrlElement:
+                                                    string url = reader.ReadElementContentAsString();
+                                                    containersNeedToRead = false;
+                                                    Uri.TryCreate(url, UriKind.Absolute, out uri);
+                                                    break;
+                                                case Constants.LastModifiedElement:
+                                                    lastModifiedTime = reader.ReadElementContentAsString().ToUTCTime();
+                                                    containersNeedToRead = false;
+                                                    break;
+                                                case Constants.EtagElement:
+                                                    etag = reader.ReadElementContentAsString();
+                                                    containersNeedToRead = false;
+                                                    break;
+                                                case Constants.NameElement:
+                                                    name = reader.ReadElementContentAsString();
+                                                    containersNeedToRead = false;
+                                                    break;
+                                                case Constants.MetadataElement:
+                                                    metadata = Response.ParseMetadata(reader);
+                                                    containersNeedToRead = false;
+                                                    break;
+                                            }
+                                        }
+                                        else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.ContainerElement)
+                                        {
+                                            container = new BlobContainerAttributes();
+                                            container.Name = name;
+                                            container.Uri = uri;
+
+                                            if (metadata != null)
+                                            {
+                                                container.Metadata = metadata;
+                                            }
+
+                                            var containerProperties = container.Properties;
+                                            containerProperties.ETag = etag;
+
+                                            if (lastModifiedTime != null)
+                                            {
+                                                containerProperties.LastModifiedUtc = (DateTime)lastModifiedTime;
+                                            }
+
+                                            break;
+                                        }
+                                    }
+
+                                    yield return new BlobContainerEntry
+                                    {
+                                        Attributes = container
+                                    };
+                                }
+                                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.ContainersElement)
+                                {
+                                    this.allObjectsParsed = true;
+                                    break;
+                                }
+                            }
+
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/ListQueuesResponse.cs b/microsoft-azure-api/StorageClient/Protocol/ListQueuesResponse.cs
new file mode 100644
index 0000000000000..14092cfad0254
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ListQueuesResponse.cs
@@ -0,0 +1,277 @@
+//-----------------------------------------------------------------------
+// <copyright file="ListQueuesResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ListQueuesResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides methods for parsing the response from a queue listing operation.
+    /// </summary>
+    public class ListQueuesResponse : ResponseParsingBase<QueueEntry>
+    {
+        /// <summary>
+        /// Stores the prefix.
+        /// </summary>
+        private string prefix;
+
+        /// <summary>
+        /// Signals when the prefix can be consumed.
+        /// </summary>
+        private bool prefixConsumable;
+
+        /// <summary>
+        /// Stores the marker.
+        /// </summary>
+        private string marker;
+
+        /// <summary>
+        /// Signals when the marker can be consumed.
+        /// </summary>
+        private bool markerConsumable;
+
+        /// <summary>
+        /// Stores the max results.
+        /// </summary>
+        private int maxResults;
+
+        /// <summary>
+        /// Signals when the max results can be consumed.
+        /// </summary>
+        private bool maxResultsConsumable;
+
+        /// <summary>
+        /// Stores the next marker.
+        /// </summary>
+        private string nextMarker;
+
+        /// <summary>
+        /// Signals when the next marker can be consumed.
+        /// </summary>
+        private bool nextMarkerConsumable;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ListQueuesResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream to be parsed.</param>
+        internal ListQueuesResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets the listing context from the XML response.
+        /// </summary>
+        /// <value>A set of parameters for the listing operation.</value>
+        public ListingContext ListingContext
+        {
+            get
+            {
+                // Force a parsing in order
+                ListingContext listingContext = new ListingContext(this.Prefix, this.MaxResults);
+
+                listingContext.Marker = this.NextMarker;
+
+                return listingContext;
+            }
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of <see cref="QueueEntry"/> objects from the response.
+        /// </summary>
+        /// <value>An enumerable collection of <see cref="QueueEntry"/> objects.</value>
+        public IEnumerable<QueueEntry> Queues
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Prefix value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The Prefix value.</value>
+        public string Prefix
+        {
+            get
+            {
+                this.Variable(ref this.prefixConsumable);
+
+                return this.prefix;
+            }
+        }
+
+        /// <summary>
+        /// Gets the Marker value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The Marker value.</value>
+        public string Marker
+        {
+            get
+            {
+                this.Variable(ref this.markerConsumable);
+
+                return this.marker;
+            }
+        }
+
+        /// <summary>
+        /// Gets the MaxResults value provided for the listing operation from the XML response.
+        /// </summary>
+        /// <value>The MaxResults value.</value>
+        public int MaxResults
+        {
+            get
+            {
+                this.Variable(ref this.maxResultsConsumable);
+
+                return this.maxResults;
+            }
+        }
+
+        /// <summary>
+        /// Gets the NextMarker value from the XML response, if the listing was not complete.
+        /// </summary>
+        /// <value>The NextMarker value.</value>
+        public string NextMarker
+        {
+            get
+            {
+                this.Variable(ref this.nextMarkerConsumable);
+
+                return this.nextMarker;
+            }
+        }
+
+        /// <summary>
+        /// Parses the response XML for a queue listing operation.
+        /// </summary>
+        /// <returns>An enumerable collection of <see cref="QueueEntry"/> objects.</returns>
+        protected override IEnumerable<QueueEntry> ParseXml()
+        {
+            bool needToRead = true;
+            while (true)
+            {
+                if (needToRead && !reader.Read())
+                {
+                    break;
+                }
+
+                needToRead = true;
+
+                // Run through the stream until we find what we are looking for.  Retain what we've found.
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                {
+                    switch (reader.Name)
+                    {
+                        case Constants.MarkerElement:
+                            needToRead = false;
+                            this.marker = reader.ReadElementContentAsString();
+                            this.markerConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.NextMarkerElement:
+                            needToRead = false;
+                            this.nextMarker = reader.ReadElementContentAsString();
+                            this.nextMarkerConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.MaxResultsElement:
+                            needToRead = false;
+                            this.maxResults = reader.ReadElementContentAsInt();
+                            this.maxResultsConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.PrefixElement:
+                            needToRead = false;
+                            this.prefix = reader.ReadElementContentAsString();
+                            this.prefixConsumable = true;
+                            yield return null;
+                            break;
+                        case Constants.QueuesElement:
+                            // While we're still in the queues section.
+                            while (reader.Read())
+                            {
+                                // We found a queue.
+                                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.QueueElement)
+                                {
+                                    QueueEntry queue = null;
+                                    Uri uri = null;
+                                    string name = null;
+                                    NameValueCollection metadata = null;
+
+                                    // Go until we are out of the queue.
+                                    bool queuesNeedToRead = true;
+                                    while (true)
+                                    {
+                                        if (queuesNeedToRead && !reader.Read())
+                                        {
+                                            break;
+                                        }
+
+                                        queuesNeedToRead = true;
+
+                                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                                        {
+                                            switch (reader.Name)
+                                            {
+                                                case Constants.UrlElement:
+                                                    string url = reader.ReadElementContentAsString();
+                                                    queuesNeedToRead = false;
+                                                    Uri.TryCreate(url, UriKind.Absolute, out uri);
+                                                    break;
+                                                case Constants.QueueNameElement:
+                                                case Constants.QueueNameElementVer2:
+                                                    name = reader.ReadElementContentAsString();
+                                                    queuesNeedToRead = false;
+                                                    break;
+                                                case Constants.MetadataElement:
+                                                    metadata = Response.ParseMetadata(reader);
+                                                    queuesNeedToRead = false;
+                                                    break;
+                                            }
+                                        }
+                                        else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.QueueElement)
+                                        {
+                                            queue = new QueueEntry(name, new QueueAttributes() { Uri = uri, Metadata = metadata ?? (new NameValueCollection()) });
+                                            break;
+                                        }
+                                    }
+
+                                    yield return queue;
+                                }
+                                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.QueuesElement)
+                                {
+                                    this.allObjectsParsed = true;
+                                    break;
+                                }
+                            }
+
+                            break;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/ListingContext.cs b/microsoft-azure-api/StorageClient/Protocol/ListingContext.cs
new file mode 100644
index 0000000000000..cb042160fcdcd
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ListingContext.cs
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------
+// <copyright file="ListingContext.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ListingContext class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Represents the listing context for enumeration operations.
+    /// </summary>
+    public class ListingContext
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ListingContext"/> class.
+        /// </summary>
+        /// <param name="prefix">The resource name prefix.</param>
+        /// <param name="maxResults">The maximum number of resources to return in a single operation, up to the per-operation limit of 5000.</param>
+        public ListingContext(string prefix, int? maxResults)
+        {
+            this.Prefix = prefix;
+            this.MaxResults = maxResults;
+            this.Marker = null;
+        }
+
+        /// <summary>
+        /// Gets or sets the Prefix value.
+        /// </summary>
+        /// <value>The Prefix value.</value>
+        public string Prefix { get; set; }
+
+        /// <summary>
+        /// Gets or sets the MaxResults value.
+        /// </summary>
+        /// <value>The MaxResults value.</value>
+        public int? MaxResults { get; set; }
+
+        /// <summary>
+        /// Gets or sets the Marker value.
+        /// </summary>
+        /// <value>The Marker value.</value>
+        public string Marker { get; set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/LoggingOperations.cs b/microsoft-azure-api/StorageClient/Protocol/LoggingOperations.cs
new file mode 100644
index 0000000000000..fd7d4f6cd87c8
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/LoggingOperations.cs
@@ -0,0 +1,56 @@
+//-----------------------------------------------------------------------
+// <copyright file="LoggingOperations.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the LoggingOperations enum.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+
+    /// <summary>
+    /// Enumeration representing the state of logging in a service.
+    /// </summary>
+    [Flags]
+    public enum LoggingOperations
+    {
+        /// <summary>
+        /// Logging is disabled.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        /// Log read operations.
+        /// </summary>
+        Read = 0x1,
+
+        /// <summary>
+        /// Log write operations.
+        /// </summary>
+        Write = 0x2,
+
+        /// <summary>
+        /// Log delete operations.
+        /// </summary>
+        Delete = 0x4,
+
+        /// <summary>
+        /// Log all operations.
+        /// </summary>
+        All = 0x7
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/LoggingProperties.cs b/microsoft-azure-api/StorageClient/Protocol/LoggingProperties.cs
new file mode 100644
index 0000000000000..554c57abceb93
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/LoggingProperties.cs
@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------
+// <copyright file="LoggingProperties.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the LoggingProperties class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+
+    /// <summary>
+    /// Class representing the service properties pertaining to logging.
+    /// </summary>
+    public class LoggingProperties
+    {
+        /// <summary>
+        /// Gets or sets the version of the analytics service.
+        /// </summary>
+        /// <value>A string identifying the version of the service.</value>
+        public string Version
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the state of logging.
+        /// </summary>
+        /// <value>A combination of <see cref="LoggingOperations"/> flags describing the operations that are logged.</value>
+        public LoggingOperations LoggingOperations
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the logging retention policy.
+        /// </summary>
+        /// <value>The number of days to retain the logs.</value>
+        public int? RetentionDays
+        {
+            get;
+            set;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/MetricsLevel.cs b/microsoft-azure-api/StorageClient/Protocol/MetricsLevel.cs
new file mode 100644
index 0000000000000..7a79fc2216019
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/MetricsLevel.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="MetricsLevel.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the MetricsLevel enum.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Enumeration representing the state of metrics collection in a service.
+    /// </summary>
+    public enum MetricsLevel
+    {
+        /// <summary>
+        /// Metrics collection is disabled.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Service-level metrics collection is enabled.
+        /// </summary>
+        Service,
+
+        /// <summary>
+        /// Service-level and API metrics collection are enabled.
+        /// </summary>
+        ServiceAndApi
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/MetricsProperties.cs b/microsoft-azure-api/StorageClient/Protocol/MetricsProperties.cs
new file mode 100644
index 0000000000000..99052535a985d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/MetricsProperties.cs
@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------
+// <copyright file="MetricsProperties.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the MetricsProperties class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+
+    /// <summary>
+    /// Class representing the service properties pertaining to metrics.
+    /// </summary>
+    public class MetricsProperties
+    {
+        /// <summary>
+        /// Gets or sets the version of the analytics service.
+        /// </summary>
+        /// <value>A string identifying the version of the service.</value>
+        public string Version
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the state of metrics collection.
+        /// </summary>
+        /// <value>A <see cref="MetricsLevel"/> value indicating which metrics to collect, if any.</value>
+        public MetricsLevel MetricsLevel
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the logging retention policy.
+        /// </summary>
+        /// <value>The number of days to retain the logs.</value>
+        public int? RetentionDays
+        {
+            get;
+            set;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/PageWrite.cs b/microsoft-azure-api/StorageClient/Protocol/PageWrite.cs
new file mode 100644
index 0000000000000..68dee8631944e
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/PageWrite.cs
@@ -0,0 +1,38 @@
+//-----------------------------------------------------------------------
+// <copyright file="PageWrite.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the PageWrite enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Describes actions that may be used for writing to a page blob or clearing a set of pages.
+    /// </summary>
+    public enum PageWrite
+    {
+        /// <summary>
+        /// Update the page with new data.
+        /// </summary>
+        Update,
+
+        /// <summary>
+        /// Clear the page.
+        /// </summary>
+        Clear
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/ParseExtensions.cs b/microsoft-azure-api/StorageClient/Protocol/ParseExtensions.cs
new file mode 100644
index 0000000000000..a7eed64c64cb8
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ParseExtensions.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="ParseExtensions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ParseExtensions class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+
+    /// <summary>
+    /// A class to help with parsing.
+    /// </summary>
+    internal static class ParseExtensions
+    {
+        /// <summary>
+        /// Converts a string to UTC time.
+        /// </summary>
+        /// <param name="str">The string to convert.</param>
+        /// <returns>A UTC representation of the string.</returns>
+        internal static DateTime ToUTCTime(this string str)
+        {
+            return DateTime.Parse(
+                str,
+                System.Globalization.DateTimeFormatInfo.InvariantInfo,
+                System.Globalization.DateTimeStyles.AdjustToUniversal);
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/PeekMessagesResponse.cs b/microsoft-azure-api/StorageClient/Protocol/PeekMessagesResponse.cs
new file mode 100644
index 0000000000000..a808551816dfa
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/PeekMessagesResponse.cs
@@ -0,0 +1,139 @@
+//-----------------------------------------------------------------------
+// <copyright file="PeekMessagesResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the PeekMessagesResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides methods for parsing the response from an operation to peek messages from a queue.
+    /// </summary>
+    public class PeekMessagesResponse : ResponseParsingBase<QueueMessage>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PeekMessagesResponse"/> class.
+        /// </summary>
+        /// <param name="stream">The stream to be parsed.</param>
+        internal PeekMessagesResponse(Stream stream) : base(stream)
+        {
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of <see cref="QueueMessage"/> objects from the response.
+        /// </summary>
+        /// <value>An enumerable collection of <see cref="QueueMessage"/> objects.</value>
+        public IEnumerable<QueueMessage> Messages
+        {
+            get
+            {
+                return this.ObjectsToParse;
+            }
+        }
+
+        /// <summary>
+        /// Parses the XML response returned by an operation to get messages from a queue.
+        /// </summary>
+        /// <returns>An enumerable collection of <see cref="QueueMessage"/> objects.</returns>
+        protected override IEnumerable<QueueMessage> ParseXml()
+        {
+            // While we're still in the QueueMessageList section.
+            while (reader.Read())
+            {
+                // We found a queue message.
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement && reader.Name == Constants.MessageElement)
+                {
+                    QueueMessage message = null;
+                    string id = null;
+                    DateTime? insertionTime = null;
+                    DateTime? expirationTime = null;
+                    string text = null;
+                    int dequeueCount = 0;
+
+                    // Go until we are out of the block.
+                    bool needToRead = true;
+                    while (true)
+                    {
+                        if (needToRead && !reader.Read())
+                        {
+                            break;
+                        }
+
+                        needToRead = true;
+
+                        if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                        {
+                            switch (reader.Name)
+                            {
+                                case Constants.MessageIdElement:
+                                    id = reader.ReadElementContentAsString();
+                                    needToRead = false;
+                                    break;
+                                case Constants.InsertionTimeElement:
+                                    insertionTime = reader.ReadElementContentAsString().ToUTCTime();
+                                    needToRead = false;
+                                    break;
+                                case Constants.ExpirationTimeElement:
+                                    expirationTime = reader.ReadElementContentAsString().ToUTCTime();
+                                    needToRead = false;
+                                    break;
+                                case Constants.MessageTextElement:
+                                    text = reader.ReadElementContentAsString();
+                                    needToRead = false;
+                                    break;
+                                case Constants.DequeueCountElement:
+                                    dequeueCount = reader.ReadElementContentAsInt();
+                                    needToRead = false;
+                                    break;
+                            }
+                        }
+                        else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.MessageElement)
+                        {
+                            message = new QueueMessage();
+                            message.Id = id;
+                            message.Text = text;
+                            message.DequeueCount = dequeueCount;
+
+                            if (expirationTime != null)
+                            {
+                                message.ExpirationTime = (DateTime)expirationTime;
+                            }
+
+                            if (insertionTime != null)
+                            {
+                                message.InsertionTime = (DateTime)insertionTime;
+                            }
+
+                            break;
+                        }
+                    }
+
+                    yield return message;
+                }
+                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.MessagesElement)
+                {
+                    break;
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/PutBlockListItem.cs b/microsoft-azure-api/StorageClient/Protocol/PutBlockListItem.cs
new file mode 100644
index 0000000000000..048db85853e8d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/PutBlockListItem.cs
@@ -0,0 +1,51 @@
+//-----------------------------------------------------------------------
+// <copyright file="PutBlockListItem.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the PutBlockListItem class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Represents a block in a block list.
+    /// </summary>
+    public class PutBlockListItem
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PutBlockListItem"/> class.
+        /// </summary>
+        /// <param name="id">The block ID.</param>
+        /// <param name="searchMode">One of the enumeration values that specifies in which block lists to search for the block.</param>
+        public PutBlockListItem(string id, BlockSearchMode searchMode)
+        {
+            this.Id = id;
+            this.SearchMode = searchMode;
+        }
+
+        /// <summary>
+        /// Gets the block ID.
+        /// </summary>
+        /// <value>The block ID.</value>
+        public string Id { get; private set; }
+
+        /// <summary>
+        /// Gets a value that indicates which block lists to search for the block.
+        /// </summary>
+        /// <value>One of the enumeration values that specifies in which block lists to search for the block.</value>
+        public BlockSearchMode SearchMode { get; private set; }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/PutPageProperties.cs b/microsoft-azure-api/StorageClient/Protocol/PutPageProperties.cs
new file mode 100644
index 0000000000000..2d471ab317add
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/PutPageProperties.cs
@@ -0,0 +1,47 @@
+//-----------------------------------------------------------------------
+// <copyright file="PutPageProperties.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the PutPageProperties class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    /// <summary>
+    /// Represents properties for writing to a page blob.
+    /// </summary>
+    public class PutPageProperties
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PutPageProperties"/> class.
+        /// </summary>
+        public PutPageProperties()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the range of bytes to write to.
+        /// </summary>
+        /// <value>The page range.</value>
+        public PageRange Range { get; set; }
+
+        /// <summary>
+        /// Gets or sets the type of write operation.
+        /// </summary>
+        /// <value>The type of page write operation.</value>
+        public PageWrite PageWrite { get; set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/QueueEntry.cs b/microsoft-azure-api/StorageClient/Protocol/QueueEntry.cs
new file mode 100644
index 0000000000000..f32d0c18f6721
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/QueueEntry.cs
@@ -0,0 +1,54 @@
+//-----------------------------------------------------------------------
+// <copyright file="QueueEntry.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the QueueEntry class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+
+    /// <summary>
+    /// Represents a queue item returned in the XML response for a queue listing operation.
+    /// </summary>
+    public class QueueEntry
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="QueueEntry"/> class.
+        /// </summary>
+        /// <param name="name">The name of the queue.</param>
+        /// <param name="attributes">The queue's attributes.</param>
+        internal QueueEntry(string name, QueueAttributes attributes)
+        {
+            this.Name = name;
+            this.Attributes = attributes;
+        }
+
+        /// <summary>
+        /// Gets the name of the queue.
+        /// </summary>
+        /// <value>The queue name.</value>
+        public string Name { get; private set; }
+
+        /// <summary>
+        /// Gets the queue's attributes.
+        /// </summary>
+        /// <value>The queue's attributes.</value>
+        public QueueAttributes Attributes { get; internal set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/QueueMessage.cs b/microsoft-azure-api/StorageClient/Protocol/QueueMessage.cs
new file mode 100644
index 0000000000000..b00a2da765f5d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/QueueMessage.cs
@@ -0,0 +1,82 @@
+//-----------------------------------------------------------------------
+// <copyright file="QueueMessage.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the QueueMessage class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+
+    /// <summary>
+    /// Represents a message retrieved from a queue.
+    /// </summary>
+    public class QueueMessage
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="QueueMessage"/> class.
+        /// </summary>
+        internal QueueMessage()
+        {
+        }
+
+        /// <summary>
+        /// Gets the message expiration time.
+        /// </summary>
+        /// <value>The message expiration time.</value>
+        public DateTime ExpirationTime { get; internal set; }
+
+        /// <summary>
+        /// Gets the message ID.
+        /// </summary>
+        /// <value>The message ID.</value>
+        public string Id { get; internal set; }
+
+        /// <summary>
+        /// Gets the time the message was added to the queue.
+        /// </summary>
+        /// <value>The message insertion time.</value>
+        public DateTime InsertionTime { get; internal set; }
+
+        /// <summary>
+        /// Gets the time the message is next visible.
+        /// </summary>
+        /// <value>The time the message is next visible.</value>
+        public DateTime? TimeNextVisible { get; internal set; }
+
+        /// <summary>
+        /// Gets the pop receipt for the message.
+        /// </summary>
+        /// <value>The message's pop receipt.</value>
+        public string PopReceipt { get; internal set; }
+
+        /// <summary>
+        /// Gets the text of the message.
+        /// </summary>
+        /// <value>The message text.</value>
+        public string Text { get; internal set; }
+
+        /// <summary>
+        /// Gets the number of times this message has been dequeued.
+        /// </summary>
+        /// <value>The dequeue count.</value>
+        public int DequeueCount { get; internal set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/QueueRequest.cs b/microsoft-azure-api/StorageClient/Protocol/QueueRequest.cs
new file mode 100644
index 0000000000000..2f6c5e49bd0fc
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/QueueRequest.cs
@@ -0,0 +1,386 @@
+//-----------------------------------------------------------------------
+// <copyright file="QueueRequest.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the QueueRequest class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Net;
+    using System.Text;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides a set of methods for constructing requests for queue operations.
+    /// </summary>
+    public static class QueueRequest
+    {
+        /// <summary>
+        /// Constructs a web request to create a queue.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        public static HttpWebRequest Create(Uri uri, int timeout)
+        {
+            return Request.Create(uri, timeout, null);
+        }
+
+        /// <summary>
+        /// Constructs a web request to delete a queue.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        public static HttpWebRequest Delete(Uri uri, int timeout)
+        {
+            return Request.Delete(uri, timeout, null);
+        }
+
+        /// <summary>
+        /// Constructs a web request to return the user-defined metadata for the queue.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        public static HttpWebRequest GetMetadata(Uri uri, int timeout)
+        {
+            return Request.GetMetadata(uri, timeout, null);
+        }
+
+        /// <summary>
+        /// Constructs a web request to set user-defined metadata for the queue.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request for performing the operation.</returns>        
+        public static HttpWebRequest SetMetadata(Uri uri, int timeout)
+        {
+            return Request.SetMetadata(uri, timeout, null);
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void SignRequest(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForBlobAndQueue(request, credentials);
+        }
+
+        /// <summary>
+        /// Adds user-defined metadata to the request as one or more name-value pairs.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="metadata">The user-defined metadata.</param>
+        public static void AddMetadata(HttpWebRequest request, NameValueCollection metadata)
+        {
+            Request.AddMetadata(request, metadata);
+        }
+
+        /// <summary>
+        /// Adds user-defined metadata to the request as a single name-value pair.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="name">The metadata name.</param>
+        /// <param name="value">The metadata value.</param>
+        public static void AddMetadata(HttpWebRequest request, string name, string value)
+        {
+            Request.AddMetadata(request, name, value);
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key Lite authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void SignRequestForSharedKeyLite(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForBlobAndQueuesSharedKeyLite(request, credentials);
+        }
+
+        /// <summary>
+        /// Constructs a web request to return a listing of all queues in the storage account.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="listingContext">A set of parameters for the listing operation.</param>
+        /// <param name="detailsIncluded">One of the enumeration values indicating which details to include in the listing.</param>
+        /// <returns>A web request to use to perform the operation.</returns>
+        public static HttpWebRequest List(Uri uri, int timeout, ListingContext listingContext, QueueListingDetails detailsIncluded)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "list");
+
+            if (listingContext != null)
+            {
+                if (listingContext.Prefix != null)
+                {
+                    builder.Add("prefix", listingContext.Prefix);
+                }
+
+                if (listingContext.Marker != null)
+                {
+                    builder.Add("marker", listingContext.Marker);
+                }
+
+                if (listingContext.MaxResults != null)
+                {
+                    builder.Add("maxresults", listingContext.MaxResults.ToString());
+                }
+            }
+
+            if ((detailsIncluded & QueueListingDetails.Metadata) != 0)
+            {
+                builder.Add("include", "metadata");
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to clear all messages in the queue.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request for the specified operation.</returns>
+        public static HttpWebRequest ClearMessages(Uri uri, int timeout)
+        {
+            HttpWebRequest request = CreateWebRequest(uri, timeout, null);
+
+            request.Method = "DELETE";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to delete the specified message.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="popReceipt">The pop receipt value for the message.</param>
+        /// <returns>A web request for the specified operation.</returns>
+        public static HttpWebRequest DeleteMessage(Uri uri, int timeout, string popReceipt)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add(Constants.QueryConstants.PopReceipt, popReceipt);
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "DELETE";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to retrieve a specified number of messages.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="numberOfMessages">The number of messages to retrieve.</param>
+        /// <param name="visibilityTimeout">The visibility timeout for the message or messages.</param>
+        /// <returns>A web request for the specified operation.</returns>
+        public static HttpWebRequest GetMessages(Uri uri, int timeout, int? numberOfMessages, int? visibilityTimeout)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+
+            if (numberOfMessages != null)
+            {
+                builder.Add("numofmessages", numberOfMessages.ToString());
+            }
+
+            if (visibilityTimeout != null)
+            {
+                builder.Add(Constants.QueryConstants.VisibilityTimeout, visibilityTimeout.ToString());
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Constructs a web request to retrieve a specified number of messages without changing their visibility.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="numberOfMessages">The number of messages to retrieve.</param>
+        /// <returns>A web request for performing the specified operation.</returns>
+        public static HttpWebRequest PeekMessages(Uri uri, int timeout, int? numberOfMessages)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+            builder.Add("peekonly", "true");
+
+            if (numberOfMessages != null)
+            {
+                builder.Add("numofmessages", numberOfMessages.ToString());
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Generates a web request to add a message to a queue.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue's messages.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="messageTimeToLive">The message time-to-live, or null if no time-to-live is specified.</param>
+        /// <returns>A web request for the put operation.</returns>
+        public static HttpWebRequest PutMessage(Uri uri, int timeout, int? messageTimeToLive)
+        {
+            return PutMessage(uri, timeout, messageTimeToLive, null);
+        }
+
+        /// <summary>
+        /// Generates a web request to add a message to a queue.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue's messages.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <param name="messageTimeToLive">The message time-to-live in seconds. If null, the service default will be used.</param>
+        /// <param name="visibilityTimeout">The length of time from now during which the message will be invisible, in seconds.
+        /// If null, the message will be visible immediately.</param>
+        /// <returns>A web request for the put operation.</returns>
+        public static HttpWebRequest PutMessage(Uri uri, int timeout, int? messageTimeToLive, int? visibilityTimeout)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+
+            if (visibilityTimeout != null)
+            {
+                builder.Add(Constants.QueryConstants.VisibilityTimeout, visibilityTimeout.ToString());
+            }
+
+            if (messageTimeToLive != null)
+            {
+                builder.Add(Constants.QueryConstants.MessageTimeToLive, messageTimeToLive.ToString());
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "POST";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Generates a web request to update a message.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the message to update.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <param name="popReceipt">The pop receipt of the message.</param>
+        /// <param name="visibilityTimeout">The length of time from now during which the message will be invisible, in seconds.</param>
+        /// <returns>A web request for the update operation.</returns>
+        public static HttpWebRequest UpdateMessage(Uri uri, int timeout, string popReceipt, int visibilityTimeout)
+        {
+            UriQueryBuilder builder = new UriQueryBuilder();
+
+            builder.Add(Constants.QueryConstants.PopReceipt, popReceipt);
+            builder.Add(Constants.QueryConstants.VisibilityTimeout, visibilityTimeout.ToString());
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "PUT";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Creates a web request to get the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <returns>A web request to get the service properties.</returns>
+        public static HttpWebRequest GetServiceProperties(Uri uri, int timeout)
+        {
+            return Request.GetServiceProperties(uri, timeout);
+        }
+
+        /// <summary>
+        /// Creates a web request to set the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <returns>A web request to set the service properties.</returns>
+        public static HttpWebRequest SetServiceProperties(Uri uri, int timeout)
+        {
+            return Request.SetServiceProperties(uri, timeout);
+        }
+
+        /// <summary>
+        /// Writes service properties to a stream, formatted in XML.
+        /// </summary>
+        /// <param name="properties">The service properties to format and write to the stream.</param>
+        /// <param name="outputStream">The stream to which the formatted properties are to be written.</param>
+        public static void WriteServiceProperties(ServiceProperties properties, Stream outputStream)
+        {
+            Request.WriteServiceProperties(properties, outputStream);
+        }
+
+        /// <summary>
+        /// Generates the message request body from a string containing the message.
+        /// </summary>
+        /// <param name="message">The content of the message.</param>
+        /// <returns>The message request body as an array of bytes.</returns>
+        public static byte[] GenerateMessageRequestBody(string message)
+        {
+            XmlWriterSettings settings = new XmlWriterSettings();
+            settings.Encoding = Encoding.UTF8;
+            settings.NewLineHandling = NewLineHandling.Entitize;
+            
+            byte[] result = null;
+            using (MemoryStream stream = new MemoryStream())
+            {
+                using (XmlWriter writer = XmlWriter.Create(stream, settings))
+                {
+                    writer.WriteStartElement(Constants.MessageElement);
+                    writer.WriteElementString(Constants.MessageTextElement, message);
+                    writer.WriteEndDocument();
+                    writer.Close();
+                }
+
+                result = stream.ToArray();
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Creates the web request.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the queue.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <param name="query">The query.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        private static HttpWebRequest CreateWebRequest(Uri uri, int timeout, UriQueryBuilder query)
+        {
+            return Request.CreateWebRequest(uri, timeout, query);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/QueueResponse.cs b/microsoft-azure-api/StorageClient/Protocol/QueueResponse.cs
new file mode 100644
index 0000000000000..993f112544d67
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/QueueResponse.cs
@@ -0,0 +1,188 @@
+//-----------------------------------------------------------------------
+// <copyright file="QueueResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the QueueResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Net;
+
+    /// <summary>
+    /// Provides a set of methods for parsing responses from queue operations.
+    /// </summary>
+    public static class QueueResponse
+    {
+        /// <summary>
+        /// Returns extended error information from the storage service, that is in addition to the HTTP status code returned with the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object containing extended error information returned with the response.</returns>
+        public static StorageExtendedErrorInformation GetError(HttpWebResponse response)
+        {
+            return Response.GetError(response);
+        }
+
+        /// <summary>
+        /// Gets a collection of user-defined metadata from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A collection of user-defined metadata, as name-value pairs.</returns>
+        public static NameValueCollection GetMetadata(HttpWebResponse response)
+        {
+            return Response.GetMetadata(response);
+        }
+
+        /// <summary>
+        /// Gets an array of values for a specified name-value pair from a response that includes user-defined metadata.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <param name="name">The name associated with the metadata values to return.</param>
+        /// <returns>An array of metadata values.</returns>
+        public static string[] GetMetadata(HttpWebResponse response, string name)
+        {
+            return Response.GetMetadata(response, name);
+        }
+
+        /// <summary>
+        /// Gets the request ID from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A unique value associated with the request.</returns>
+        public static string GetRequestId(HttpWebResponse response)
+        {
+            return Response.GetRequestId(response);
+        }
+
+        /// <summary>
+        /// Extracts the pop receipt from a web response header.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>The pop receipt stored in the header of the response.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Storage only supports HTTP")]
+        public static string GetPopReceipt(HttpWebResponse response)
+        {
+            return response.Headers[Constants.HeaderConstants.PopReceipt];
+        }
+
+        /// <summary>
+        /// Extracts the next visibility time from a web response header.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>The time of next visibility stored in the header of the response.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Storage only supports HTTP")]
+        public static DateTime GetNextVisibleTime(HttpWebResponse response)
+        {
+            string timeString = response.Headers[Constants.HeaderConstants.NextVisibleTime];
+
+            return timeString.ToUTCTime();
+        }
+
+        /// <summary>
+        /// Gets the approximate message count for the queue.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>The approximate count for the queue.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Storage only supports HTTP")]
+        public static string GetApproximateMessageCount(HttpWebResponse response)
+        {
+            return response.Headers[Constants.HeaderConstants.ApproximateMessagesCount];
+        }
+
+        /// <summary>
+        /// Parses the response from an operation to get messages from the queue.
+        /// </summary>
+        /// <param name="stream">The stream to parse.</param>
+        /// <returns>An object that may be used for parsing data from the results of a message retrieval operation.</returns>
+        public static GetMessagesResponse GetMessages(Stream stream)
+        {
+            return new GetMessagesResponse(stream);
+        }
+
+        /// <summary>
+        /// Parses the response from an operation to get messages from the queue.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object that may be used for parsing data from the results of a message retrieval operation.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Storage only supports HTTP")]
+        public static GetMessagesResponse GetMessages(HttpWebResponse response)
+        {
+            return new GetMessagesResponse(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Parses the response for a queue listing operation.
+        /// </summary>
+        /// <param name="stream">The response stream.</param>
+        /// <returns>An object that may be used for parsing data from the results of a queue listing operation.</returns>
+        public static ListQueuesResponse List(Stream stream)
+        {
+            return new ListQueuesResponse(stream);
+        }
+
+        /// <summary>
+        /// Parses the response for a queue listing operation.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object that may be used for parsing data from the results of a queue listing operation.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1011:ConsiderPassingBaseTypesAsParameters",
+            Justification = "Storage only supports HTTP")]
+        public static ListQueuesResponse List(HttpWebResponse response)
+        {
+            return new ListQueuesResponse(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Parses the response from an operation to peek messages from the queue.
+        /// </summary>
+        /// <param name="stream">The stream to parse.</param>
+        /// <returns>An object that may be used for parsing data from the results of a message peeking operation.</returns>
+        public static PeekMessagesResponse PeekMessages(Stream stream)
+        {
+            return new PeekMessagesResponse(stream);
+        }
+
+        /// <summary>
+        /// Parses the response from an operation to peek messages from the queue.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object that may be used for parsing data from the results of a message peeking operation.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1011:ConsiderPassingBaseTypesAsParameters",
+            Justification = "Storage only supports HTTP")]
+        public static PeekMessagesResponse PeekMessages(HttpWebResponse response)
+        {
+            return new PeekMessagesResponse(response.GetResponseStream());
+        }
+
+        /// <summary>
+        /// Reads service properties from a stream.
+        /// </summary>
+        /// <param name="inputStream">The stream from which to read the service properties.</param>
+        /// <returns>The service properties stored in the stream.</returns>
+        public static ServiceProperties ReadServiceProperties(Stream inputStream)
+        {
+            return Response.ReadServiceProperties(inputStream);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/Request.cs b/microsoft-azure-api/StorageClient/Protocol/Request.cs
new file mode 100644
index 0000000000000..cbcfd836a19cc
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/Request.cs
@@ -0,0 +1,532 @@
+//-----------------------------------------------------------------------
+// <copyright file="Request.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the Request class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Net;
+    using System.Runtime.CompilerServices;
+    using System.Text;
+    using System.Xml;
+    using System.Xml.Linq;
+    
+    /// <summary>
+    /// Factory class for creating requests internally.
+    /// </summary>
+    internal static class Request
+    {
+        /// <summary>
+        /// Internal override for the storage version string.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+            "SA1401:FieldsMustBePrivate",
+            Justification = "Unable to change while remaining backwards compatible.")]
+        internal static string TargetVersionOverride;
+
+        /// <summary>
+        /// Initializes static members of the Request class.
+        /// </summary>
+        static Request()
+        {
+            Request.UserAgent = Constants.HeaderConstants.UserAgent;
+        }
+
+        /// <summary>
+        /// Gets or sets the user agent to send over the wire to identify the client.
+        /// </summary>
+        private static string UserAgent { get; set; }
+
+        /// <summary>
+        /// Creates the web request.
+        /// </summary>
+        /// <param name="uri">The request Uri.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="builder">The builder.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        internal static HttpWebRequest CreateWebRequest(Uri uri, int timeout, UriQueryBuilder builder)
+        {
+            if (builder == null)
+            {
+                builder = new UriQueryBuilder();
+            }
+
+            if (timeout != 0)
+            {
+                builder.Add("timeout", timeout.ToString());
+            }
+
+            Uri uriRequest = builder.AddToUri(uri);
+
+            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(uriRequest);
+
+            request.Headers.Add(Constants.HeaderConstants.StorageVersionHeader, GetTargetVersion());
+            request.UserAgent = Request.UserAgent;
+            return request;
+        }
+
+        /// <summary>
+        /// Creates the specified Uri.
+        /// </summary>
+        /// <param name="uri">The Uri to create.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="builder">The builder.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        internal static HttpWebRequest Create(Uri uri, int timeout, UriQueryBuilder builder)
+        {
+            if (builder == null)
+            {
+                builder = new UriQueryBuilder();
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+            request.ContentLength = 0;
+            request.Method = "PUT";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Deletes the specified Uri.
+        /// </summary>
+        /// <param name="uri">The Uri to delete.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="builder">The builder.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        internal static HttpWebRequest Delete(Uri uri, int timeout, UriQueryBuilder builder)
+        {
+            if (builder == null)
+            {
+                builder = new UriQueryBuilder();
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "DELETE";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Gets the metadata.
+        /// </summary>
+        /// <param name="uri">The blob Uri.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="builder">The builder.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        internal static HttpWebRequest GetMetadata(Uri uri, int timeout, UriQueryBuilder builder)
+        {
+            if (builder == null)
+            {
+                builder = new UriQueryBuilder();
+            }
+
+            builder.Add(Constants.QueryConstants.Component, "metadata");
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "HEAD";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Gets the properties.
+        /// </summary>
+        /// <param name="uri">The Uri to query.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="builder">The builder.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        internal static HttpWebRequest GetProperties(Uri uri, int timeout, UriQueryBuilder builder)
+        {
+            if (builder == null)
+            {
+                builder = new UriQueryBuilder();
+            }
+
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "HEAD";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Sets the metadata.
+        /// </summary>
+        /// <param name="uri">The blob Uri.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="builder">The builder.</param>
+        /// <returns>A web request for performing the operation.</returns>
+        internal static HttpWebRequest SetMetadata(Uri uri, int timeout, UriQueryBuilder builder)
+        {
+            if (builder == null)
+            {
+                builder = new UriQueryBuilder();
+            }
+
+            builder.Add(Constants.QueryConstants.Component, "metadata");
+            HttpWebRequest request = CreateWebRequest(uri, timeout, builder);
+
+            request.ContentLength = 0;
+            request.Method = "PUT";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Creates a web request to get the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to get the service properties.</returns>
+        internal static HttpWebRequest GetServiceProperties(Uri uri, int timeout)
+        {
+            UriQueryBuilder builder = GetServiceUriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "properties");
+
+            HttpWebRequest request = Request.CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "GET";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Creates a web request to set the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval.</param>
+        /// <returns>A web request to set the service properties.</returns>
+        internal static HttpWebRequest SetServiceProperties(Uri uri, int timeout)
+        {
+            UriQueryBuilder builder = GetServiceUriQueryBuilder();
+            builder.Add(Constants.QueryConstants.Component, "properties");
+
+            HttpWebRequest request = Request.CreateWebRequest(uri, timeout, builder);
+
+            request.Method = "PUT";
+
+            return request;
+        }
+
+        /// <summary>
+        /// Writes service properties to a stream, formatted in XML.
+        /// </summary>
+        /// <param name="properties">The service properties to format and write to the stream.</param>
+        /// <param name="outputStream">The stream to which the formatted properties are to be written.</param>
+        internal static void WriteServiceProperties(ServiceProperties properties, Stream outputStream)
+        {
+            XDocument propertiesDocument = properties.ToServiceXml();
+            XmlWriterSettings settings = new XmlWriterSettings();
+            settings.Encoding = Encoding.UTF8;
+            settings.NewLineHandling = NewLineHandling.Entitize;
+
+            using (XmlWriter writer = XmlWriter.Create(outputStream, settings))
+            {
+                propertiesDocument.Save(writer);
+                writer.Close();
+            }
+        }
+
+        /// <summary>
+        /// Generates a query builder for building service requests.
+        /// </summary>
+        /// <returns>A <see cref="UriQueryBuilder"/> for building service requests.</returns>
+        internal static UriQueryBuilder GetServiceUriQueryBuilder()
+        {
+            UriQueryBuilder uriBuilder = new UriQueryBuilder();
+            uriBuilder.Add(Constants.QueryConstants.ResourceType, "service");
+            return uriBuilder;
+        }
+
+        /// <summary>
+        /// Signs the request appropriately to make it an authenticated request for Blob and Queue.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal static void SignRequestForBlobAndQueue(HttpWebRequest request, Credentials credentials)
+        {
+            // Add the date header to the request
+            string dateString = ConvertDateTimeToHttpString(DateTime.UtcNow);
+            request.Headers.Add("x-ms-date", dateString);
+
+            // Compute the signature and add the authentication scheme
+            CanonicalizationStrategy canonicalizer = CanonicalizationStrategyFactory.GetBlobQueueFullCanonicalizationStrategy(request);
+
+            string message = canonicalizer.CanonicalizeHttpRequest(request, credentials.AccountName);
+            string computedBase64Signature = StorageKey.ComputeMacSha256(credentials.Key, message);
+
+            request.Headers.Add(
+                "Authorization",
+                string.Format(CultureInfo.InvariantCulture, "{0} {1}:{2}", "SharedKey", credentials.AccountName, computedBase64Signature));
+        }
+
+        /// <summary>
+        /// Signs requests using the SharedKey authentication scheme for the table storage service.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal static void SignRequestForTablesSharedKey(HttpWebRequest request, Credentials credentials)
+        {
+            // Add the date header to the request
+            string dateString = ConvertDateTimeToHttpString(DateTime.UtcNow);
+            request.Headers.Add("x-ms-date", dateString);
+
+            // Compute the signature and add the authentication scheme
+            CanonicalizationStrategy canonicalizer =
+                CanonicalizationStrategyFactory.GetTableFullCanonicalizationStrategy(request);
+
+            string message = canonicalizer.CanonicalizeHttpRequest(request, credentials.AccountName);
+            string computedBase64Signature = StorageKey.ComputeMacSha256(credentials.Key, message);
+
+            request.Headers.Add(
+                "Authorization",
+                string.Format(CultureInfo.InvariantCulture, "{0} {1}:{2}", "SharedKey", credentials.AccountName, computedBase64Signature));
+        }
+
+        /// <summary>
+        /// Adds the metadata.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="metadata">The metadata.</param>
+        internal static void AddMetadata(HttpWebRequest request, NameValueCollection metadata)
+        {
+            if (metadata != null)
+            {
+                foreach (string key in metadata.AllKeys)
+                {
+                    AddMetadata(request, key, metadata[key]);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds the metadata.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="name">The metadata name.</param>
+        /// <param name="value">The metadata value.</param>
+        internal static void AddMetadata(HttpWebRequest request, string name, string value)
+        {
+            CommonUtils.AssertNotNullOrEmpty("value", value);
+
+            request.Headers.Add("x-ms-meta-" + name, value);
+        }
+
+        /// <summary>
+        /// Signs requests using the SharedKeyLite authentication scheme with is used for the table storage service.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal static void SignRequestForTablesSharedKeyLite(HttpWebRequest request, Credentials credentials)
+        {
+            // Add the date header to the request
+            string dateString = ConvertDateTimeToHttpString(DateTime.UtcNow);
+            request.Headers.Add("x-ms-date", dateString);
+
+            // Compute the signature and add the authentication scheme
+            CanonicalizationStrategy canonicalizer =
+                CanonicalizationStrategyFactory.GetTableLiteCanonicalizationStrategy(request);
+
+            string message = canonicalizer.CanonicalizeHttpRequest(request, credentials.AccountName);
+            string computedBase64Signature = StorageKey.ComputeMacSha256(credentials.Key, message);
+
+            request.Headers.Add(
+                "Authorization",
+                string.Format(CultureInfo.InvariantCulture, "{0} {1}:{2}", "SharedKeyLite", credentials.AccountName, computedBase64Signature));
+        }
+
+        /// <summary>
+        /// Signs requests using the SharedKeyLite authentication scheme with is used for the table storage service.
+        /// Currently we only support for table.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="credentials">The credentials.</param>
+        internal static void SignRequestForBlobAndQueuesSharedKeyLite(HttpWebRequest request, Credentials credentials)
+        {
+            // Add the date header to the request
+            string dateString = ConvertDateTimeToHttpString(DateTime.UtcNow);
+            request.Headers.Add("x-ms-date", dateString);
+
+            // Compute the signature and add the authentication scheme
+            CanonicalizationStrategy canonicalizer =
+                CanonicalizationStrategyFactory.GetBlobQueueLiteCanonicalizationStrategy(request);
+
+            string message = canonicalizer.CanonicalizeHttpRequest(request, credentials.AccountName);
+            string computedBase64Signature = StorageKey.ComputeMacSha256(credentials.Key, message);
+
+            request.Headers.Add(
+                "Authorization",
+                string.Format(CultureInfo.InvariantCulture, "{0} {1}:{2}", "SharedKeyLite", credentials.AccountName, computedBase64Signature));
+        }
+
+        /// <summary>
+        /// Adds the lease id.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="leaseId">The lease id.</param>
+        internal static void AddLeaseId(HttpWebRequest request, string leaseId)
+        {
+            if (leaseId != null)
+            {
+                AddOptionalHeader(request, "x-ms-lease-id", leaseId);
+            }
+        }
+
+        /// <summary>
+        /// Adds the optional header.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="name">The metadata name.</param>
+        /// <param name="value">The metadata value.</param>
+        internal static void AddOptionalHeader(HttpWebRequest request, string name, string value)
+        {
+            if (!string.IsNullOrEmpty(value))
+            {
+                request.Headers.Add(name, value);
+            }
+        }
+
+        /// <summary>
+        /// Adds the conditional.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="header">The header.</param>
+        /// <param name="etag">The resource ETag.</param>
+        internal static void AddConditional(HttpWebRequest request, ConditionHeaderKind header, string etag)
+        {
+            if (header == ConditionHeaderKind.IfModifiedSince || header == ConditionHeaderKind.IfUnmodifiedSince)
+            {
+                throw new InvalidOperationException(SR.ConditionalRequiresDateTime);
+            }
+
+            switch (header)
+            {
+                case ConditionHeaderKind.IfMatch:
+                    request.Headers[HttpRequestHeader.IfMatch] = etag;
+                    break;
+                case ConditionHeaderKind.IfNoneMatch:
+                    request.Headers[HttpRequestHeader.IfNoneMatch] = etag;
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Adds the conditional.
+        /// </summary>
+        /// <param name="request">The request.</param>
+        /// <param name="header">The header.</param>
+        /// <param name="dateTime">The date time.</param>
+        internal static void AddConditional(HttpWebRequest request, ConditionHeaderKind header, DateTime dateTime)
+        {
+            if (header == ConditionHeaderKind.IfMatch || header == ConditionHeaderKind.IfNoneMatch)
+            {
+                throw new InvalidOperationException(SR.ConditionalRequiresETag);
+            }
+
+            switch (header)
+            {
+                case ConditionHeaderKind.IfModifiedSince:
+                    request.Headers[HttpRequestHeader.IfModifiedSince] = dateTime.ToString("R", CultureInfo.InvariantCulture);
+                    break;
+                case ConditionHeaderKind.IfUnmodifiedSince:
+                    request.Headers[HttpRequestHeader.IfUnmodifiedSince] = dateTime.ToString("R", CultureInfo.InvariantCulture);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Creates a standard datetime string for the shared key lite authentication scheme.
+        /// </summary>
+        /// <param name="dateTime">DateTime value to convert to a string in the expected format.</param>
+        /// <returns>The converted DateTime.</returns>
+        internal static string ConvertDateTimeToHttpString(DateTime dateTime)
+        {
+            // On the wire everything should be represented in UTC. This assert will catch invalid callers who
+            // are violating this rule.
+            Debug.Assert(
+                dateTime == DateTime.MaxValue ||
+                dateTime == DateTime.MinValue ||
+                dateTime.Kind == DateTimeKind.Utc,
+                "The date must be UTC.");
+
+            // 'R' means rfc1123 date which is what the storage services use for all dates...
+            // It will be in the following format:
+            // Sun, 28 Jan 2008 12:11:37 GMT
+            return dateTime.ToString("R", CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Gets the target version.
+        /// </summary>
+        /// <returns>The target version.</returns>
+        internal static string GetTargetVersion()
+        {
+            string targetVersion = Constants.HeaderConstants.TargetStorageVersion;
+
+            if (!string.IsNullOrEmpty(TargetVersionOverride))
+            {
+                targetVersion = TargetVersionOverride;
+            }
+
+            return targetVersion;
+        }
+
+        /// <summary>
+        /// Converts the date time to snapshot string.
+        /// </summary>
+        /// <param name="dateTime">The date time.</param>
+        /// <returns>The converted string.</returns>
+        internal static string ConvertDateTimeToSnapshotString(DateTime dateTime)
+        {
+            // On the wire everything should be represented in UTC. This assert will catch invalid callers who
+            // are violating this rule.
+            Debug.Assert(
+                dateTime == DateTime.MaxValue ||
+                dateTime == DateTime.MinValue ||
+                dateTime.Kind == DateTimeKind.Utc,
+                "The DateTime must be UTC.");
+
+            return dateTime.ToString("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffff'Z'", CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// This gets the file version, but fails under partial trust with a security exception.
+        /// The caller should catch the exception.
+        /// </summary>
+        /// <returns>File version of current assembly.</returns>
+        /// <remarks>
+        /// Inlining of this fuction is explicitly disabled to support degrading gracefully under partial trust.
+        /// FileVersionInfo.GetVersionInfo has a link demand assoicated with it. Therefore, we must make
+        /// sure we never inline this function, otherwise the caller cannot catch the security 
+        /// exception associated with the link demand.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.NoInlining)]
+        private static string GetFileVersionOrThrowSecurityException()
+        {
+            FileVersionInfo version = FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location);
+            return version.FileVersion;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/ResourceConsumedException.cs b/microsoft-azure-api/StorageClient/Protocol/ResourceConsumedException.cs
new file mode 100644
index 0000000000000..7d201f14eac16
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ResourceConsumedException.cs
@@ -0,0 +1,68 @@
+//-----------------------------------------------------------------------
+// <copyright file="ResourceConsumedException.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ResourceConsumedException class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// The exception that is thrown if the client attempts to parse the response a second time.
+    /// </summary>
+    [Serializable]
+    public class ResourceConsumedException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResourceConsumedException"/> class.
+        /// </summary>
+        public ResourceConsumedException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResourceConsumedException"/> class.
+        /// </summary>
+        /// <param name="message">The message that describes the exception.</param>
+        public ResourceConsumedException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResourceConsumedException"/> class.
+        /// </summary>
+        /// <param name="message">The message for the exception.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception.</param>
+        public ResourceConsumedException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResourceConsumedException"/> class.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> that contains contextual information about the source or destination.</param>
+        protected ResourceConsumedException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/Response.cs b/microsoft-azure-api/StorageClient/Protocol/Response.cs
new file mode 100644
index 0000000000000..f5566357461e2
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/Response.cs
@@ -0,0 +1,202 @@
+//-----------------------------------------------------------------------
+// <copyright file="Response.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the Response class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Net;
+    using System.Xml;
+    using System.Xml.Linq;
+
+    /// <summary>
+    /// Implements the common parsing between all the responses.
+    /// </summary>
+    internal static class Response
+    {
+        /// <summary>
+        /// Gets the error details from the response object.
+        /// </summary>
+        /// <param name="response">The response from server.</param>
+        /// <returns>An extended error information parsed from the input.</returns>
+        internal static StorageExtendedErrorInformation GetError(HttpWebResponse response)
+        {
+            Stream stream = response.GetResponseStream();
+
+            return Utilities.GetExtendedErrorDetailsFromResponse(stream, response.ContentLength);
+        }
+
+        /// <summary>
+        /// Gets the headers (metadata or properties).
+        /// </summary>
+        /// <param name="response">The response from sever.</param>
+        /// <returns>A <see cref="NameValueCollection"/> of all the headers.</returns>
+        internal static NameValueCollection GetHeaders(HttpWebResponse response)
+        {
+            return GetMetadataOrProperties(response, string.Empty);
+        }
+
+        /// <summary>
+        /// Gets the user-defined metadata.
+        /// </summary>
+        /// <param name="response">The response from server.</param>
+        /// <returns>A <see cref="NameValueCollection"/> of the metadata.</returns>
+        internal static NameValueCollection GetMetadata(HttpWebResponse response)
+        {
+            return GetMetadataOrProperties(response, Constants.HeaderConstants.PrefixForStorageMetadata);
+        }
+
+        /// <summary>
+        /// Gets a specific user-defined metadata.
+        /// </summary>
+        /// <param name="response">The response from server.</param>
+        /// <param name="name">The metadata header requested.</param>
+        /// <returns>An array of the values for the metadata.</returns>
+        internal static string[] GetMetadata(HttpWebResponse response, string name)
+        {
+            return response.Headers.GetValues(Constants.HeaderConstants.PrefixForStorageMetadata + name);
+        }
+
+        /// <summary>
+        /// Parses the metadata.
+        /// </summary>
+        /// <param name="reader">The reader.</param>
+        /// <returns>A <see cref="NameValueCollection"/> of metadata.</returns>
+        /// <remarks>
+        /// Precondition: reader at &lt;Metadata&gt;
+        /// Postcondition: reader after &lt;/Metadata&gt; (&lt;Metadata/&gt; consumed)
+        /// </remarks>
+        internal static NameValueCollection ParseMetadata(XmlReader reader)
+        {
+            NameValueCollection metadata = new NameValueCollection();
+            bool needToRead = true;
+            while (true)
+            {
+                if (needToRead && !reader.Read())
+                {
+                    return metadata;
+                }
+
+                if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                {
+                    needToRead = false;
+                    string elementName = reader.Name;
+                    string elementValue = reader.ReadElementContentAsString();
+                    if (elementName != Constants.InvalidMetadataName)
+                    {
+                        metadata.Add(elementName, elementValue);
+                    }
+                } 
+                else if (reader.NodeType == XmlNodeType.EndElement && reader.Name == Constants.MetadataElement)
+                {
+                    reader.Read();
+                    return metadata;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the storage properties.
+        /// </summary>
+        /// <param name="response">The response from server.</param>
+        /// <returns>A <see cref="NameValueCollection"/> of the properties.</returns>
+        internal static NameValueCollection GetProperties(HttpWebResponse response)
+        {
+            return GetMetadataOrProperties(response, Constants.HeaderConstants.PrefixForStorageProperties);
+        }
+
+        /// <summary>
+        /// Gets a specific storage property.
+        /// </summary>
+        /// <param name="response">The response from server.</param>
+        /// <param name="name">The property requested.</param>
+        /// <returns>An array of the values for the property.</returns>
+        internal static string[] GetProperties(HttpWebResponse response, string name)
+        {
+            return response.Headers.GetValues(Constants.HeaderConstants.PrefixForStorageProperties + name);
+        }
+
+        /// <summary>
+        /// Gets the request id.
+        /// </summary>
+        /// <param name="response">The response from server.</param>
+        /// <returns>The request ID.</returns>
+        internal static string GetRequestId(HttpWebResponse response)
+        {
+            string[] values = response.Headers.GetValues(Constants.HeaderConstants.RequestIdHeader);
+
+            if (values.Length == 1)
+            {
+                return values[0];
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Reads service properties from a stream.
+        /// </summary>
+        /// <param name="inputStream">The stream from which to read the service properties.</param>
+        /// <returns>The service properties stored in the stream.</returns>
+        internal static ServiceProperties ReadServiceProperties(Stream inputStream)
+        {
+            using (XmlReader reader = XmlReader.Create(inputStream))
+            {
+                XDocument servicePropertyDocument = XDocument.Load(reader);
+
+                return ServiceProperties.FromServiceXml(servicePropertyDocument);
+            }
+        }
+
+        /// <summary>
+        /// Gets the metadata or properties.
+        /// </summary>
+        /// <param name="response">The response from server.</param>
+        /// <param name="prefix">The prefix for all the headers.</param>
+        /// <returns>A <see cref="NameValueCollection"/> of the headers with the prefix.</returns>
+        private static NameValueCollection GetMetadataOrProperties(HttpWebResponse response, string prefix)
+        {
+            NameValueCollection nameValues = new NameValueCollection();
+            int prefixLength = prefix.Length;
+
+            WebHeaderCollection headers = response.Headers;
+
+            for (int i = 0; i < headers.Count; i++)
+            {
+                string header = headers.GetKey(i);
+
+                if (!header.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                string[] values = headers.GetValues(header);
+
+                for (int j = 0; j < values.Length; j++)
+                {
+                    nameValues.Add(header.Substring(prefixLength), values[j]);
+                }
+            }
+
+            return nameValues;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/ResponseParsingBase.cs b/microsoft-azure-api/StorageClient/Protocol/ResponseParsingBase.cs
new file mode 100644
index 0000000000000..39e2c53581149
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ResponseParsingBase.cs
@@ -0,0 +1,194 @@
+//-----------------------------------------------------------------------
+// <copyright file="ResponseParsingBase.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ResponseParsingBase class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.IO;
+    using System.Xml;
+
+    /// <summary>
+    /// Provides a base class that is used internally to parse XML streams from storage service operations.
+    /// </summary>
+    /// <typeparam name="T">The type to be parsed.</typeparam>
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    public abstract class ResponseParsingBase<T> : IDisposable
+    {
+        /// <summary>
+        /// Indicates that all parsable objects have been consumed. This field is reserved and should not be used.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+            "SA1401:FieldsMustBePrivate",
+            Justification = "Unable to change while remaining backwards compatible.")]
+        protected bool allObjectsParsed;
+
+        /// <summary>
+        /// Stores any objects that have not yet been parsed. This field is reserved and should not be used.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+            "SA1401:FieldsMustBePrivate",
+            Justification = "Unable to change while remaining backwards compatible.")]
+        protected IList<T> outstandingObjectsToParse = new List<T>();
+
+        /// <summary>
+        /// The reader used for parsing. This field is reserved and should not be used.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+            "SA1401:FieldsMustBePrivate",
+            Justification = "Unable to change while remaining backwards compatible.")]
+        protected XmlReader reader;
+
+        /// <summary>
+        /// The IEnumerator over the parsed content.
+        /// </summary>
+        private IEnumerator<T> parser;
+
+        /// <summary>
+        /// Used to make sure that parsing is only done once, since a stream is not re-entrant.
+        /// </summary>
+        private bool enumerableConsumed;
+
+        /// <summary>
+        /// Initializes a new instance of the ResponseParsingBase class.
+        /// </summary>
+        /// <param name="stream">The stream to be parsed.</param>
+        internal ResponseParsingBase(Stream stream)
+        {
+            XmlReaderSettings readerSettings = new XmlReaderSettings();
+            readerSettings.IgnoreWhitespace = false;
+            this.reader = XmlReader.Create(stream, readerSettings);
+            this.parser = this.ParseXmlAndClose().GetEnumerator();
+        }
+
+        /// <summary>
+        /// Gets the parsable objects. This method is reserved and should not be used.
+        /// </summary>
+        /// <value>The objects to parse.</value>
+        protected IEnumerable<T> ObjectsToParse
+        {
+            get
+            {
+                if (this.enumerableConsumed)
+                {
+                    throw new ResourceConsumedException();
+                }
+
+                this.enumerableConsumed = true;
+
+                while (!this.allObjectsParsed && this.parser.MoveNext())
+                {
+                    if (this.parser.Current != null)
+                    {
+                        yield return this.parser.Current;
+                    }
+                }
+
+                foreach (var parsableObject in this.outstandingObjectsToParse)
+                {
+                    yield return parsableObject;
+                }
+
+                this.outstandingObjectsToParse = null;
+            }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. 
+        /// </summary>
+        public void Dispose()
+        {
+            this.Dispose(true);
+
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Parses the XML response. This method is reserved and should not be used.
+        /// </summary>
+        /// <returns>A collection of enumerable objects.</returns>
+        protected abstract IEnumerable<T> ParseXml();
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources, and optional
+        /// managed resources.
+        /// </summary>
+        /// <param name="disposing"><c>True</c> to release both managed and unmanaged resources; otherwise, <c>false</c>.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (this.reader != null)
+                {
+                    this.reader.Close();
+                }
+            }
+
+            this.reader = null;
+        }
+
+        /// <summary>
+        /// This method is reserved and should not be used.
+        /// </summary>
+        /// <param name="consumable"><c>True</c> when the object is consumable.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1045:DoNotPassTypesByReference",
+            MessageId = "0#",
+            Justification = "The consumable flag needs to be referenced so updates will propagate to this method.")]
+        protected void Variable(ref bool consumable)
+        {
+            if (!consumable)
+            {
+                while (this.parser.MoveNext())
+                {
+                    if (this.parser.Current != null)
+                    {
+                        this.outstandingObjectsToParse.Add(this.parser.Current);
+                    }
+
+                    if (consumable)
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses the XML and close.
+        /// </summary>
+        /// <returns>A list of parsed results.</returns>
+        private IEnumerable<T> ParseXmlAndClose()
+        {
+            foreach (var item in this.ParseXml())
+            {
+                yield return item;
+            }
+
+            this.reader.Close();
+            this.reader = null;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/ServiceProperties.cs b/microsoft-azure-api/StorageClient/Protocol/ServiceProperties.cs
new file mode 100644
index 0000000000000..93fd3a6e31abf
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/ServiceProperties.cs
@@ -0,0 +1,335 @@
+//-----------------------------------------------------------------------
+// <copyright file="ServiceProperties.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ServiceProperties class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Xml.Linq;
+
+    /// <summary>
+    /// Class representing a set of properties pertaining to a cloud storage service.
+    /// </summary>
+    public class ServiceProperties
+    {
+        /// <summary>
+        /// The name of the root XML element.
+        /// </summary>
+        internal const string StorageServicePropertiesName = "StorageServiceProperties";
+
+        /// <summary>
+        /// The name of the logging XML element.
+        /// </summary>
+        internal const string LoggingName = "Logging";
+
+        /// <summary>
+        /// The name of the metrics XML element.
+        /// </summary>
+        internal const string MetricsName = "Metrics";
+
+        /// <summary>
+        /// The name of the version XML element.
+        /// </summary>
+        internal const string VersionName = "Version";
+
+        /// <summary>
+        /// The name of the delete operation XML element.
+        /// </summary>
+        internal const string DeleteName = "Delete";
+
+        /// <summary>
+        /// The name of the read operation XML element.
+        /// </summary>
+        internal const string ReadName = "Read";
+
+        /// <summary>
+        /// The name of the write operation XML element.
+        /// </summary>
+        internal const string WriteName = "Write";
+
+        /// <summary>
+        /// The name of the retention policy XML element.
+        /// </summary>
+        internal const string RetentionPolicyName = "RetentionPolicy";
+
+        /// <summary>
+        /// The name of the enabled XML element.
+        /// </summary>
+        internal const string EnabledName = "Enabled";
+
+        /// <summary>
+        /// The name of the days XML element.
+        /// </summary>
+        internal const string DaysName = "Days";
+
+        /// <summary>
+        /// The name of the include APIs XML element.
+        /// </summary>
+        internal const string IncludeApisName = "IncludeAPIs";
+
+        /// <summary>
+        /// The name of the default service version XML element.
+        /// </summary>
+        internal const string DefaultServiceVersionName = "DefaultServiceVersion";
+
+        /// <summary>
+        /// Initializes a new instance of the ServiceProperties class.
+        /// </summary>
+        public ServiceProperties()
+        {
+            this.Logging = new LoggingProperties();
+            this.Metrics = new MetricsProperties();
+        }
+
+        /// <summary>
+        /// Gets or sets the logging properties.
+        /// </summary>
+        /// <value>The logging properties.</value>
+        public LoggingProperties Logging
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the metrics properties.
+        /// </summary>
+        /// <value>The metrics properties.</value>
+        public MetricsProperties Metrics
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the default service version.
+        /// </summary>
+        /// <value>The default service version identifier.</value>
+        public string DefaultServiceVersion
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Constructs a <c>ServiceProperties</c> object from an XML document received from the service.
+        /// </summary>
+        /// <param name="servicePropertiesDocument">The XML document.</param>
+        /// <returns>A <c>ServiceProperties</c> object containing the properties in the XML document.</returns>
+        internal static ServiceProperties FromServiceXml(XDocument servicePropertiesDocument)
+        {
+            XElement servicePropertiesElement = servicePropertiesDocument.Element(StorageServicePropertiesName);
+            ServiceProperties properties = new ServiceProperties()
+            {
+                Logging = ReadLoggingPropertiesFromXml(servicePropertiesElement.Element(LoggingName)),
+                Metrics = ReadMetricsPropertiesFromXml(servicePropertiesElement.Element(MetricsName))
+            };
+
+            XElement defaultServiceVersionXml = servicePropertiesElement.Element(DefaultServiceVersionName);
+            if (defaultServiceVersionXml != null)
+            {
+                properties.DefaultServiceVersion = defaultServiceVersionXml.Value;
+            }
+
+            return properties;
+        }
+
+        /// <summary>
+        /// Converts these properties into XML for communicating with the service.
+        /// </summary>
+        /// <returns>An XML document containing the service properties.</returns>
+        internal XDocument ToServiceXml()
+        {
+            if (this.Logging == null)
+            {
+                throw new InvalidOperationException("Logging cannot be null.");
+            }
+
+            if (this.Metrics == null)
+            {
+                throw new InvalidOperationException("Metrics cannot be null.");
+            }
+
+            XElement storageServiceElement = new XElement(
+                    StorageServicePropertiesName,
+                    GenerateLoggingXml(this.Logging),
+                    GenerateMetricsXml(this.Metrics));
+
+            if (this.DefaultServiceVersion != null)
+            {
+                storageServiceElement.Add(new XElement(DefaultServiceVersionName, this.DefaultServiceVersion));
+            }
+
+            return new XDocument(storageServiceElement);
+        }
+        
+        /// <summary>
+        /// Generates XML representing the given retention policy.
+        /// </summary>
+        /// <param name="retentionDays">The number of days to retain, or null if the policy is disabled.</param>
+        /// <returns>An XML retention policy element.</returns>
+        private static XElement GenerateRetentionPolicyXml(int? retentionDays)
+        {
+            bool enabled = retentionDays != null;
+            XElement xml = new XElement(RetentionPolicyName, new XElement(EnabledName, enabled));
+
+            if (enabled)
+            {
+                xml.Add(new XElement(DaysName, (int)retentionDays));
+            }
+
+            return xml;
+        }
+
+        /// <summary>
+        /// Generates XML representing the given metrics properties.
+        /// </summary>
+        /// <param name="metrics">The metrics properties.</param>
+        /// <returns>An XML metrics element.</returns>
+        private static XElement GenerateMetricsXml(MetricsProperties metrics)
+        {
+            if (!Enum.IsDefined(typeof(MetricsLevel), metrics.MetricsLevel))
+            {
+                throw new InvalidOperationException("Invalid metrics level specified.");
+            }
+
+            if (string.IsNullOrEmpty(metrics.Version))
+            {
+                throw new InvalidOperationException("The metrics version is null or empty.");
+            }
+
+            bool enabled = metrics.MetricsLevel != MetricsLevel.None;
+
+            XElement xml = new XElement(
+                MetricsName,
+                new XElement(VersionName, metrics.Version),
+                new XElement(EnabledName, enabled),
+                GenerateRetentionPolicyXml(metrics.RetentionDays));
+
+            if (enabled)
+            {
+                xml.Add(new XElement(IncludeApisName, metrics.MetricsLevel == MetricsLevel.ServiceAndApi));
+            }
+
+            return xml;
+        }
+
+        /// <summary>
+        /// Generates XML representing the given logging properties.
+        /// </summary>
+        /// <param name="logging">The logging properties.</param>
+        /// <returns>An XML logging element.</returns>
+        private static XElement GenerateLoggingXml(LoggingProperties logging)
+        {
+            if ((LoggingOperations.All & logging.LoggingOperations) != logging.LoggingOperations)
+            {
+                throw new InvalidOperationException("Invalid logging operations specified.");
+            }
+
+            if (string.IsNullOrEmpty(logging.Version))
+            {
+                throw new InvalidOperationException("The logging version is null or empty.");
+            }
+
+            return new XElement(
+                LoggingName,
+                new XElement(VersionName, logging.Version),
+                new XElement(DeleteName, (logging.LoggingOperations & LoggingOperations.Delete) != 0),
+                new XElement(ReadName, (logging.LoggingOperations & LoggingOperations.Read) != 0),
+                new XElement(WriteName, (logging.LoggingOperations & LoggingOperations.Write) != 0),
+                GenerateRetentionPolicyXml(logging.RetentionDays));
+        }
+
+        /// <summary>
+        /// Constructs a <c>LoggingProperties</c> object from an XML element.
+        /// </summary>
+        /// <param name="element">The XML element.</param>
+        /// <returns>A <c>LoggingProperties</c> object containing the properties in the element.</returns>
+        private static LoggingProperties ReadLoggingPropertiesFromXml(XElement element)
+        {
+            LoggingOperations state = LoggingOperations.None;
+            
+            if (bool.Parse(element.Element(DeleteName).Value))
+            {
+                state |= LoggingOperations.Delete;
+            }
+
+            if (bool.Parse(element.Element(ReadName).Value))
+            {
+                state |= LoggingOperations.Read;
+            }
+
+            if (bool.Parse(element.Element(WriteName).Value))
+            {
+                state |= LoggingOperations.Write;
+            }
+
+            return new LoggingProperties()
+            {
+                Version = element.Element(VersionName).Value,
+                LoggingOperations = state,
+                RetentionDays = ReadRetentionPolicyFromXml(element.Element(RetentionPolicyName))
+            };
+        }
+
+        /// <summary>
+        /// Constructs a <c>MetricsProperties</c> object from an XML element.
+        /// </summary>
+        /// <param name="element">The XML element.</param>
+        /// <returns>A <c>MetricsProperties</c> object containing the properties in the element.</returns>
+        private static MetricsProperties ReadMetricsPropertiesFromXml(XElement element)
+        {
+            MetricsLevel state = MetricsLevel.None;
+
+            if (bool.Parse(element.Element(EnabledName).Value))
+            {
+                state = MetricsLevel.Service;
+
+                if (bool.Parse(element.Element(IncludeApisName).Value))
+                {
+                    state = MetricsLevel.ServiceAndApi;
+                }
+            }
+
+            return new MetricsProperties()
+            {
+                Version = element.Element(VersionName).Value,
+                MetricsLevel = state,
+                RetentionDays = ReadRetentionPolicyFromXml(element.Element(RetentionPolicyName))
+            };
+        }
+
+        /// <summary>
+        /// Constructs a retention policy (number of days) from an XML element.
+        /// </summary>
+        /// <param name="element">The XML element.</param>
+        /// <returns>The number of days to retain, or null if retention is disabled.</returns>
+        private static int? ReadRetentionPolicyFromXml(XElement element)
+        {
+            if (!bool.Parse(element.Element(EnabledName).Value))
+            {
+                return null;
+            }
+            else
+            {
+                return int.Parse(element.Element(DaysName).Value);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/SharedKeyCanonicalizer.cs b/microsoft-azure-api/StorageClient/Protocol/SharedKeyCanonicalizer.cs
new file mode 100644
index 0000000000000..5f296c832eb47
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/SharedKeyCanonicalizer.cs
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedKeyCanonicalizer.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedKeyCanonicalizer class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// Provides an implementation of the <see cref="CanonicalizationStrategy"/> class for requests against 
+    /// the Table service under the Shared Key authentication scheme.
+    /// </summary>
+    public sealed class SharedKeyCanonicalizer : CanonicalizationStrategy
+    {
+        /// <summary>
+        /// Canonicalizes the HTTP request.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The canonicalized string for the request.</returns>
+        public override string CanonicalizeHttpRequest(HttpWebRequest request, string accountName)
+        {
+            return CanonicalizeHttpRequestVersion2(
+                request.Address,
+                accountName,
+                request.Method,
+                request.ContentType,
+                request.ContentLength,
+                string.Empty,
+                request.Headers);
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/SharedKeyLiteCanonicalizer.cs b/microsoft-azure-api/StorageClient/Protocol/SharedKeyLiteCanonicalizer.cs
new file mode 100644
index 0000000000000..234d28f962935
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/SharedKeyLiteCanonicalizer.cs
@@ -0,0 +1,57 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedKeyLiteCanonicalizer.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedKeyLiteCanonicalizer class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// Provides an implementation of the <see cref="CanonicalizationStrategy"/> class for blobs and queues
+    /// for use with the Shared Key Lite authentication scheme.
+    /// </summary>
+    public sealed class SharedKeyLiteCanonicalizer : CanonicalizationStrategy
+    {
+        /// <summary>
+        /// Canonicalizes the HTTP request.
+        /// </summary>
+        /// <param name="request">A web request.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The canonicalized string for the request.</returns>
+        public override string CanonicalizeHttpRequest(HttpWebRequest request, string accountName)
+        {
+            return CanonicalizationStrategy.CanonicalizeHttpRequest(
+                request.Address,
+                accountName,
+                request.Method,
+                request.ContentType,
+                string.Empty,
+                request.Headers);
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/SharedKeyLiteTableCanonicalizer.cs b/microsoft-azure-api/StorageClient/Protocol/SharedKeyLiteTableCanonicalizer.cs
new file mode 100644
index 0000000000000..18600cdff4ec7
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/SharedKeyLiteTableCanonicalizer.cs
@@ -0,0 +1,62 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedKeyLiteTableCanonicalizer.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedKeyLiteTableCanonicalizer class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// Provides an implementation of the <see cref="CanonicalizationStrategy"/> class for tables
+    /// for the Shared Key Lite authentication scheme.
+    /// </summary>
+    public sealed class SharedKeyLiteTableCanonicalizer : CanonicalizationStrategy
+    {
+        /// <summary>
+        /// Canonicalizes the HTTP request.
+        /// </summary>
+        /// <param name="request">A web request.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The canonicalized string for the request.</returns>
+        public override string CanonicalizeHttpRequest(HttpWebRequest request, string accountName)
+        {
+            string date = request.Headers[Constants.HeaderConstants.Date];
+
+            if (string.IsNullOrEmpty(date))
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.MissingXmsDateInHeader);
+                throw new ArgumentException(errorMessage, "request");
+            }
+
+            StringBuilder canonicalizedString = new StringBuilder(date);
+            AppendStringToCanonicalizedString(canonicalizedString, GetCanonicalizedResource(request.Address, accountName));
+
+            return canonicalizedString.ToString();
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/SharedKeyTableCanonicalizer.cs b/microsoft-azure-api/StorageClient/Protocol/SharedKeyTableCanonicalizer.cs
new file mode 100644
index 0000000000000..00157903ea84d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/SharedKeyTableCanonicalizer.cs
@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedKeyTableCanonicalizer.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedKeyTableCanonicalizer class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.Linq;
+    using System.Net;
+    using System.Text;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient;
+
+    /// <summary>
+    /// Provides an implementation of the <see cref="CanonicalizationStrategy"/> class for requests against 
+    /// the Table service under the Shared Key authentication scheme.
+    /// </summary>
+    public sealed class SharedKeyTableCanonicalizer : CanonicalizationStrategy
+    {
+        /// <summary>
+        /// Canonicalizes the HTTP request.
+        /// </summary>
+        /// <param name="request">A web request.</param>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <returns>The canonicalized string for the request.</returns>
+        public override string CanonicalizeHttpRequest(HttpWebRequest request, string accountName)
+        {
+            CanonicalizedString canonicalizedString = new CanonicalizedString(request.Method);
+
+            string httpContentMD5Value = request.Headers[HttpRequestHeader.ContentMd5];
+
+            canonicalizedString.AppendCanonicalizedElement(httpContentMD5Value);
+
+            string contentType = request.ContentType;
+            canonicalizedString.AppendCanonicalizedElement(contentType);
+
+            string date = request.Headers[Constants.HeaderConstants.Date];
+            if (string.IsNullOrEmpty(date))
+            {
+                string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.MissingXmsDateInHeader);
+                throw new ArgumentException(errorMessage, "request");
+            }
+
+            canonicalizedString.AppendCanonicalizedElement(date);
+
+            canonicalizedString.AppendCanonicalizedElement(GetCanonicalizedResource(request.Address, accountName));
+
+            return canonicalizedString.ToString();
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Protocol/StorageKey.cs b/microsoft-azure-api/StorageClient/Protocol/StorageKey.cs
new file mode 100644
index 0000000000000..87c7ec64b537f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/StorageKey.cs
@@ -0,0 +1,100 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageKey.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageKey class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System.Security.Cryptography;
+    using System.Text;
+
+    /// <summary>
+    /// Container for storage key.
+    /// </summary>
+    /// <remarks>
+    /// May eventually use native APIs to keep key pinned and not memory.
+    /// </remarks>
+    internal class StorageKey
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageKey"/> class.
+        /// </summary>
+        /// <param name="key">The storage key.</param>
+        public StorageKey(byte[] key)
+        {
+            this.Key = key;
+        }
+
+        /// <summary>
+        /// Gets or sets the key.
+        /// </summary>
+        /// <value>The storage key.</value>
+        private byte[] Key { get; set; }
+
+        /// <summary>
+        /// Computes the mac sha256.
+        /// </summary>
+        /// <param name="storageKey">The storage key.</param>
+        /// <param name="canonicalizedString">The canonicalized string.</param>
+        /// <returns>The computed hash.</returns>
+        internal static string ComputeMacSha256(StorageKey storageKey, string canonicalizedString)
+        {
+            byte[] dataToMAC = Encoding.UTF8.GetBytes(canonicalizedString);
+
+            using (HMACSHA256 hmacsha1 = new HMACSHA256(storageKey.Key))
+            {
+                return System.Convert.ToBase64String(hmacsha1.ComputeHash(dataToMAC));
+            }
+        }
+
+        /// <summary>
+        /// Computes the mac sha512.
+        /// </summary>
+        /// <param name="storageKey">The storage key.</param>
+        /// <param name="canonicalizedString">The canonicalized string.</param>
+        /// <returns>The computed hash.</returns>
+        internal static string ComputeMacSha512(StorageKey storageKey, string canonicalizedString)
+        {
+            byte[] dataToMAC = Encoding.UTF8.GetBytes(canonicalizedString);
+
+            using (HMACSHA512 hmacsha1 = new HMACSHA512(storageKey.Key))
+            {
+                return System.Convert.ToBase64String(hmacsha1.ComputeHash(dataToMAC));
+            }
+        }
+
+        /// <summary>
+        /// Gets the base64 encoded key.
+        /// </summary>
+        /// <returns>The base64 encoded key.</returns>
+        internal string GetBase64EncodedKey()
+        {
+            return System.Convert.ToBase64String(this.Key);
+        }
+
+        /// <summary>
+        /// Gets the key.
+        /// </summary>
+        /// <returns>The storage key.</returns>
+        internal byte[] GetKey()
+        {
+            byte[] keyCopy = (byte[])this.Key.Clone();
+            return keyCopy;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/TableRequest.cs b/microsoft-azure-api/StorageClient/Protocol/TableRequest.cs
new file mode 100644
index 0000000000000..4eae94269ef0c
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/TableRequest.cs
@@ -0,0 +1,86 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableRequest.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableRequest class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.IO;
+    using System.Net;
+
+    /// <summary>
+    /// Provides a set of methods for constructing requests for table operations.
+    /// </summary>
+    public static class TableRequest
+    {
+        /// <summary>
+        /// Creates a web request to get the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <returns>A web request to get the service properties.</returns>
+        public static HttpWebRequest GetServiceProperties(Uri uri, int timeout)
+        {
+            return Request.GetServiceProperties(uri, timeout);
+        }
+
+        /// <summary>
+        /// Creates a web request to set the properties of the service.
+        /// </summary>
+        /// <param name="uri">The absolute URI to the service.</param>
+        /// <param name="timeout">The server timeout interval, in seconds.</param>
+        /// <returns>A web request to set the service properties.</returns>
+        public static HttpWebRequest SetServiceProperties(Uri uri, int timeout)
+        {
+            return Request.SetServiceProperties(uri, timeout);
+        }
+
+        /// <summary>
+        /// Writes service properties to a stream, formatted in XML.
+        /// </summary>
+        /// <param name="properties">The service properties to format and write to the stream.</param>
+        /// <param name="outputStream">The stream to which the formatted properties are to be written.</param>
+        public static void WriteServiceProperties(ServiceProperties properties, Stream outputStream)
+        {
+            Request.WriteServiceProperties(properties, outputStream);
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        /// <remarks>The table service usually expects requests to use Shared Key Lite authentication.
+        /// Use <see cref="SignRequestForSharedKeyLite"/> for those requests.</remarks>
+        public static void SignRequest(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForTablesSharedKey(request, credentials);
+        }
+
+        /// <summary>
+        /// Signs the request for Shared Key Lite authentication.
+        /// </summary>
+        /// <param name="request">The web request.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public static void SignRequestForSharedKeyLite(HttpWebRequest request, Credentials credentials)
+        {
+            Request.SignRequestForTablesSharedKeyLite(request, credentials);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/TableResponse.cs b/microsoft-azure-api/StorageClient/Protocol/TableResponse.cs
new file mode 100644
index 0000000000000..7f0ab4a996096
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/TableResponse.cs
@@ -0,0 +1,61 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableResponse.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableResponse class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System.IO;
+    using System.Net;
+
+    /// <summary>
+    /// Provides a set of methods for parsing responses from table operations.
+    /// </summary>
+    public static class TableResponse
+    {
+        /// <summary>
+        /// Returns extended error information from the storage service, that is in addition to the HTTP status code returned with the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>An object containing extended error information returned with the response.</returns>
+        public static StorageExtendedErrorInformation GetError(HttpWebResponse response)
+        {
+            return Response.GetError(response);
+        }
+
+        /// <summary>
+        /// Gets the request ID from the response.
+        /// </summary>
+        /// <param name="response">The web response.</param>
+        /// <returns>A unique value associated with the request.</returns>
+        public static string GetRequestId(HttpWebResponse response)
+        {
+            return Response.GetRequestId(response);
+        }
+
+        /// <summary>
+        /// Reads service properties from a stream.
+        /// </summary>
+        /// <param name="inputStream">The stream from which to read the service properties.</param>
+        /// <returns>The service properties stored in the stream.</returns>
+        public static ServiceProperties ReadServiceProperties(Stream inputStream)
+        {
+            return Response.ReadServiceProperties(inputStream);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Protocol/UriQueryBuilder.cs b/microsoft-azure-api/StorageClient/Protocol/UriQueryBuilder.cs
new file mode 100644
index 0000000000000..8953f292cc5ab
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Protocol/UriQueryBuilder.cs
@@ -0,0 +1,116 @@
+//-----------------------------------------------------------------------
+// <copyright file="UriQueryBuilder.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the UriQueryBuilder.cs class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Protocol
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+
+    /// <summary>
+    /// A <see cref="UriBuilder"/> style class for creating Uri query strings.
+    /// </summary>
+    internal class UriQueryBuilder
+    {
+        /// <summary>
+        /// Stores the query parameters.
+        /// </summary>
+        private Dictionary<string, string> parameters = new Dictionary<string, string>();
+
+        /// <summary>
+        /// Add the value with Uri escaping.
+        /// </summary>
+        /// <param name="name">The query name.</param>
+        /// <param name="value">The query value.</param>
+        public void Add(string name, string value)
+        {
+            if (value != null)
+            {
+                value = Uri.EscapeDataString(value);
+            }
+
+            this.parameters.Add(name, value);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="System.String"/> that represents this instance.
+        /// </summary>
+        /// <returns>
+        /// A <see cref="System.String"/> that represents this instance.
+        /// </returns>
+        public override string ToString()
+        {
+            StringBuilder sb = new StringBuilder();
+            bool first = true;
+
+            foreach (var pair in this.parameters)
+            {
+                if (first)
+                {
+                    first = false;
+                    sb.Append("?");
+                }
+                else
+                {
+                    sb.Append("&");
+                }
+
+                sb.Append(pair.Key);
+
+                if (pair.Value != null)
+                {
+                    sb.AppendFormat("={0}", pair.Value);
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Add query parameter to an existing Uri. This takes care of any existing query parameters in the Uri.
+        /// </summary>
+        /// <param name="uri">Original Uri which may contain query parameters already.</param>
+        /// <returns>The appended Uri.</returns>
+        internal Uri AddToUri(Uri uri)
+        {
+            // The correct way to add query parameters to a Uri http://msdn.microsoft.com/en-us/library/system.uribuilder.query.aspx
+            string queryToAppend = this.ToString();
+
+            if (queryToAppend.Length > 1)
+            {
+                queryToAppend = queryToAppend.Substring(1);
+            }
+
+            UriBuilder baseUri = new UriBuilder(uri);
+
+            if (baseUri.Query != null && baseUri.Query.Length > 1)
+            {
+                baseUri.Query = baseUri.Query.Substring(1) + "&" + queryToAppend;
+            }
+            else
+            {
+                baseUri.Query = queryToAppend;
+            }
+
+            return baseUri.Uri;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/ProtocolHelper.cs b/microsoft-azure-api/StorageClient/ProtocolHelper.cs
new file mode 100644
index 0000000000000..c7e7457309c09
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ProtocolHelper.cs
@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------
+// <copyright file="ProtocolHelper.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ProtocolHelper class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Net;
+
+    /// <summary>
+    /// Assists in protocol implementation.
+    /// </summary>
+    internal class ProtocolHelper
+    {
+        /// <summary>
+        /// Gets the web request.
+        /// </summary>
+        /// <param name="serviceClient">The service client.</param>
+        /// <param name="options">The options.</param>
+        /// <param name="retrieveRequest">The retrieve request.</param>
+        /// <returns>The web request.</returns>
+        internal static HttpWebRequest GetWebRequest(CloudBlobClient serviceClient, BlobRequestOptions options, Func<int, HttpWebRequest> retrieveRequest)
+        {
+            CommonUtils.AssertNotNull("options", options);            
+
+            int timeoutInSeconds = options.Timeout.RoundUpToSeconds();
+            AccessCondition accessCondition = options.AccessCondition;
+
+            var webRequest = retrieveRequest(timeoutInSeconds);
+            accessCondition.ApplyCondition(webRequest);
+            CommonUtils.ApplyRequestOptimizations(webRequest, -1);
+
+            return webRequest;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/QueueAttributes.cs b/microsoft-azure-api/StorageClient/QueueAttributes.cs
new file mode 100644
index 0000000000000..8d9cfbe1d7bfc
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/QueueAttributes.cs
@@ -0,0 +1,75 @@
+//-----------------------------------------------------------------------
+// <copyright file="QueueAttributes.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the QueueAttributes class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Linq;
+    using System.Net;
+    using Protocol;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a queue's attributes.
+    /// </summary>
+    public class QueueAttributes
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="QueueAttributes"/> class.
+        /// </summary>
+        public QueueAttributes()
+        {
+            this.Metadata = new NameValueCollection();
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="QueueAttributes"/> class.
+        /// </summary>
+        /// <param name="other">The attributes to clone.</param>
+        public QueueAttributes(QueueAttributes other)
+        {
+            if (other.Metadata != null)
+            {
+                this.Metadata = new NameValueCollection(other.Metadata);
+            }
+            else
+            {
+                this.Metadata = new NameValueCollection();
+            }
+
+            this.Uri = other.Uri;
+        }
+
+        /// <summary>
+        /// Gets the queue's user-defined metadata.
+        /// </summary>
+        /// <value>The queue's user-defined metadata.</value>
+        public NameValueCollection Metadata { get; internal set; }
+
+        /// <summary>
+        /// Gets the URI for the queue.
+        /// </summary>
+        /// <value>The queue's URI.</value>
+        public Uri Uri { get; internal set; }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/QueueErrorCodeStrings.cs b/microsoft-azure-api/StorageClient/QueueErrorCodeStrings.cs
new file mode 100644
index 0000000000000..e07b187fd8d67
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/QueueErrorCodeStrings.cs
@@ -0,0 +1,78 @@
+//-----------------------------------------------------------------------
+// <copyright file="QueueErrorCodeStrings.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the QueueErrorCodeStrings class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Provides error code strings that are specific to the Queue service.
+    /// </summary>
+    public static class QueueErrorCodeStrings
+    {
+        /// <summary>
+        /// Error code that may be returned when the specified queue was not found.
+        /// </summary>
+        public const string QueueNotFound = "QueueNotFound";
+
+        /// <summary>
+        /// Error code that may be returned when the specified queue is disabled.
+        /// </summary>
+        public const string QueueDisabled = "QueueDisabled";
+
+        /// <summary>
+        /// Error code that may be returned when the specified queue already exists.
+        /// </summary>
+        public const string QueueAlreadyExists = "QueueAlreadyExists";
+
+        /// <summary>
+        /// Error code that may be returned when the specified queue is not empty.
+        /// </summary>
+        public const string QueueNotEmpty = "QueueNotEmpty";
+
+        /// <summary>
+        /// Error code that may be returned when the specified queue is being deleted.
+        /// </summary>
+        public const string QueueBeingDeleted = "QueueBeingDeleted";
+
+        /// <summary>
+        /// Error code that may be returned when the specified pop receipt does not match.
+        /// </summary>
+        public const string PopReceiptMismatch = "PopReceiptMismatch";
+
+        /// <summary>
+        /// Error code that may be returned when one or more request parameters are invalid.
+        /// </summary>
+        public const string InvalidParameter = "InvalidParameter";
+
+        /// <summary>
+        /// Error code that may be returned when the specified message was not found.
+        /// </summary>
+        public const string MessageNotFound = "MessageNotFound";
+
+        /// <summary>
+        /// Error code that may be returned when the specified message is too large.
+        /// </summary>
+        public const string MessageTooLarge = "MessageTooLarge";
+
+        /// <summary>
+        /// Error code that may be returned when the specified marker is invalid.
+        /// </summary>
+        public const string InvalidMarker = "InvalidMarker";
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/QueueListingDetails.cs b/microsoft-azure-api/StorageClient/QueueListingDetails.cs
new file mode 100644
index 0000000000000..9ec44900dd43f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/QueueListingDetails.cs
@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------
+// <copyright file="QueueListingDetails.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the QueueListingDetails enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Specifies which details to include when listing queues in this storage account.
+    /// </summary>
+    [Flags]
+    public enum QueueListingDetails
+    {
+        /// <summary>
+        /// No additional details.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        /// Retrieve queue metadata.
+        /// </summary>
+        Metadata = 0x1,
+
+        /// <summary>
+        /// Retrieve all available details.
+        /// </summary>
+        All = 0x1
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/RequestWithRetry.cs b/microsoft-azure-api/StorageClient/RequestWithRetry.cs
new file mode 100644
index 0000000000000..d874b11033933
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/RequestWithRetry.cs
@@ -0,0 +1,269 @@
+//-----------------------------------------------------------------------
+// <copyright file="RequestWithRetry.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the RequestWithRetry class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Data.Services.Client;
+    using System.Net;
+    using System.Threading;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+    
+    /// <summary>
+    /// Utility functions that does the heavy lifting of carrying out retries on a IRetrayableRequest.
+    /// </summary>
+    /// <remarks>
+    /// Both synchrous and asynchrous request styles are supported.
+    /// They are used to implement the corresponding XXX, BeginXXX, EndXXX calls where XXX
+    /// is something like GetBlobInfo.
+    /// State passing for return value in the sync call (GetBlobInfo) and out parameters for the async calls
+    /// (EndBlobInfo) is achieved by member variables in the implementation class of IRetryableRequest.
+    /// </remarks>
+    internal static class RequestWithRetry
+    {
+        /// <summary>
+        /// Synchronouses the request with retry.
+        /// </summary>
+        /// <typeparam name="T">The result type of the task.</typeparam>
+        /// <param name="oracle">The oracle to use.</param>
+        /// <param name="impl">The task implementation.</param>
+        /// <returns>The result of the task.</returns>
+        internal static T SynchronousRequestWithRetry<T>(ShouldRetry oracle, Func<Action<T>, TaskSequence> impl)
+        {
+            return TaskImplHelper.ExecuteImpl<T>((setResult) => RequestWithRetryImpl<T>(oracle, impl, setResult));
+        }
+
+        /// <summary>
+        /// Begins the asynchronous request with retry.
+        /// </summary>
+        /// <typeparam name="T">The result type of the task.</typeparam>
+        /// <param name="oracle">The oracle to use.</param>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="callback">The asynchronous callback.</param>
+        /// <param name="state">The asynchronous state.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that represents the asynchronous operation.</returns>
+        internal static IAsyncResult BeginAsynchronousRequestWithRetry<T>(
+            ShouldRetry oracle,
+            Func<Action<T>, TaskSequence> impl,
+            AsyncCallback callback,
+            object state)
+        {
+            return TaskImplHelper.BeginImpl<T>((setResult) => RequestWithRetryImpl<T>(oracle, impl, setResult), callback, state);
+        }
+
+        /// <summary>
+        /// Ends the asynchronous request with retry.
+        /// </summary>
+        /// <typeparam name="T">The result type of the task.</typeparam>
+        /// <param name="asyncResult">The asynchronous result.</param>
+        /// <returns>The result of the completed task.</returns>
+        internal static T EndAsynchronousRequestWithRetry<T>(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImpl<T>(asyncResult);
+        }
+
+        /// <summary>
+        /// Implementation of the *RequestWithRetry methods.
+        /// </summary>
+        /// <typeparam name="T">The result type of the task.</typeparam>
+        /// <param name="retryOracle">The retry oracle.</param>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="setResult">The result report delegate.</param>
+        /// <returns>A <see cref="TaskSequence"/> that performs the request with retries.</returns>
+        internal static TaskSequence RequestWithRetryImpl<T>(ShouldRetry retryOracle, Func<Action<T>, TaskSequence> impl, Action<T> setResult)
+        {
+            int retryCount = 0;
+            bool succeeded = false;
+            bool shouldRetry = false;
+            do
+            {
+                var task = new InvokeTaskSequenceTask<T>(impl);
+                yield return task;
+                
+                TimeSpan delay = TimeSpan.FromMilliseconds(-1);
+
+                try
+                {
+                    var result = task.Result;
+                    succeeded = true;
+                    setResult(result);
+                }
+                catch (TimeoutException e)
+                {
+                    shouldRetry = retryOracle != null ? retryOracle(retryCount++, e, out delay) : false;
+
+                    // We should just throw out the exception if we are not retrying
+                    if (!shouldRetry)
+                    {
+                        throw;
+                    }
+                }
+                catch (StorageServerException e)
+                {
+                    if (e.StatusCode == HttpStatusCode.NotImplemented || e.StatusCode == HttpStatusCode.HttpVersionNotSupported)
+                    {
+                        throw;
+                    }
+
+                    shouldRetry = retryOracle != null ? retryOracle(retryCount++, e, out delay) : false;
+
+                    // We should just throw out the exception if we are not retrying
+                    if (!shouldRetry)
+                    {
+                        throw;
+                    }
+                }
+                catch (InvalidOperationException e)
+                {
+                    DataServiceClientException dsce = CommonUtils.FindInnerDataServiceClientException(e);
+
+                    // rethrow 400 class errors immediately as they can't be retried
+                    // 501 (Not Implemented) and 505 (HTTP Version Not Supported) shouldn't be retried either.
+                    if (dsce != null &&
+                        ((dsce.StatusCode >= 400 && dsce.StatusCode < 500)
+                          || dsce.StatusCode == (int)HttpStatusCode.NotImplemented
+                          || dsce.StatusCode == (int)HttpStatusCode.HttpVersionNotSupported))
+                    {
+                        throw;
+                    }
+
+                    // If it is BlobTypeMismatchExceptionMessage, we should throw without retry
+                    if (e.Message == SR.BlobTypeMismatchExceptionMessage)
+                    {
+                        throw;
+                    }
+
+                    shouldRetry = retryOracle != null ? retryOracle(retryCount++, e, out delay) : false;
+
+                    // We should just throw out the exception if we are not retrying
+                    if (!shouldRetry)
+                    {
+                        throw;
+                    }
+                }
+
+                if (!succeeded && shouldRetry && delay > TimeSpan.Zero)
+                {
+                    using (DelayTask delayTask = new DelayTask(delay))
+                    {
+                        yield return delayTask;
+
+                        // Materialize exceptions
+                        var scratch = delayTask.Result;
+                    }
+                }
+            }
+            while (!succeeded && shouldRetry);
+        }
+
+        /// <summary>
+        /// Implementation of the *RequestWithRetry methods.
+        /// </summary>
+        /// <typeparam name="TResult">The result type of the task.</typeparam>
+        /// <param name="retryOracle">The retry oracle.</param>
+        /// <param name="syncTask">The task implementation.</param>
+        /// <returns>A <see cref="TaskSequence"/> that performs the request with retries.</returns>
+        internal static TResult RequestWithRetrySyncImpl<TResult>(ShouldRetry retryOracle, SynchronousTask<TResult> syncTask)
+        {
+            int retryCount = 0;
+            bool shouldRetry = false;
+
+            do
+            {
+                TimeSpan delay = TimeSpan.FromMilliseconds(-1);
+
+                try
+                {
+                    return syncTask.Execute();
+                }
+                catch (TimeoutException e)
+                {
+                    shouldRetry = retryOracle != null ? retryOracle(retryCount++, e, out delay) : false;
+
+                    // We should just throw out the exception if we are not retrying
+                    if (!shouldRetry)
+                    {
+                        throw;
+                    }
+                }
+                catch (StorageServerException e)
+                {
+                    if (e.StatusCode == HttpStatusCode.NotImplemented || e.StatusCode == HttpStatusCode.HttpVersionNotSupported)
+                    {
+                        throw;
+                    }
+
+                    shouldRetry = retryOracle != null ? retryOracle(retryCount++, e, out delay) : false;
+
+                    // We should just throw out the exception if we are not retrying
+                    if (!shouldRetry)
+                    {
+                        throw;
+                    }
+                }
+                catch (InvalidOperationException e)
+                {
+                    DataServiceClientException dsce = CommonUtils.FindInnerDataServiceClientException(e);
+
+                    // rethrow 400 class errors immediately as they can't be retried
+                    // 501 (Not Implemented) and 505 (HTTP Version Not Supported) shouldn't be retried either.
+                    if (dsce != null &&
+                        ((dsce.StatusCode >= 400 && dsce.StatusCode < 500)
+                          || dsce.StatusCode == (int)HttpStatusCode.NotImplemented
+                          || dsce.StatusCode == (int)HttpStatusCode.HttpVersionNotSupported))
+                    {
+                        throw;
+                    }
+
+                    // If it is BlobTypeMismatchExceptionMessage, we should throw without retry
+                    if (e.Message == SR.BlobTypeMismatchExceptionMessage)
+                    {
+                        throw;
+                    }
+
+                    shouldRetry = retryOracle != null ? retryOracle(retryCount++, e, out delay) : false;
+
+                    // We should just throw out the exception if we are not retrying
+                    if (!shouldRetry)
+                    {
+                        throw;
+                    }
+                }
+
+                if (shouldRetry && delay > TimeSpan.Zero)
+                {
+                    Thread.Sleep(delay);
+                }
+            }
+            while (shouldRetry);
+
+            throw new StorageClientException(
+                StorageErrorCode.None,
+                "Unexpected internal storage client error.",
+                System.Net.HttpStatusCode.Unused,
+                null,
+                null)
+            {
+                HelpLink = "http://go.microsoft.com/fwlink/?LinkID=182765"
+            };
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/ResponseReceivedEventArgs.cs b/microsoft-azure-api/StorageClient/ResponseReceivedEventArgs.cs
new file mode 100644
index 0000000000000..eb370faf5d3be
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ResponseReceivedEventArgs.cs
@@ -0,0 +1,77 @@
+//-----------------------------------------------------------------------
+// <copyright file="ResponseReceivedEventArgs.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ResponseReceivedEventArgs class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Net;
+    using Protocol;
+
+    /// <summary>
+    /// Provides the arguments for the <c>ResponseReceived</c> event.
+    /// </summary>
+    public class ResponseReceivedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets the request ID.
+        /// </summary>
+        /// <value>The request ID.</value>
+        public string RequestId { get; internal set; }
+
+        /// <summary>
+        /// Gets the request headers.
+        /// </summary>
+        /// <value>The collection of request headers.</value>
+        /// <remarks>Modifying the collection of request headers may result in unexpected behavior.</remarks>
+        public NameValueCollection RequestHeaders { get; internal set; }
+
+        /// <summary>
+        /// Gets the request URI.
+        /// </summary>
+        /// <value>The request URI.</value>
+        public Uri RequestUri { get; internal set; }
+
+        /// <summary>
+        /// Gets the response headers.
+        /// </summary>
+        /// <value>The collection of response headers.</value>
+        /// <remarks>Modifying the collection of response headers may result in unexpected behavior.</remarks>
+        public NameValueCollection ResponseHeaders { get; internal set; }
+
+        /// <summary>
+        /// Gets the HTTP status code for the request.
+        /// </summary>
+        /// <value>The HTTP status code for the request.</value>
+        public HttpStatusCode StatusCode { get; internal set; }
+
+        /// <summary>
+        /// Gets the status description for the request.
+        /// </summary>
+        /// <value>The status description for the request.</value>
+        public string StatusDescription { get; internal set; }
+
+        /// <summary>
+        /// Gets an exception returned by the service.
+        /// </summary>
+        /// <value>The exception returned by the service.</value>
+        public Exception Exception { get; internal set; }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/ResultContinuation.cs b/microsoft-azure-api/StorageClient/ResultContinuation.cs
new file mode 100644
index 0000000000000..26c52025ff394
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ResultContinuation.cs
@@ -0,0 +1,241 @@
+//-----------------------------------------------------------------------
+// <copyright file="ResultContinuation.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ResultContinuation class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Xml;
+    using System.Xml.Serialization;
+
+    /// <summary>
+    /// Manage continuation information for various listing operation.
+    /// Can be serialized using XmlSerialization.
+    /// </summary>
+    [Serializable]
+    public sealed class ResultContinuation : IXmlSerializable
+    {
+        /// <summary>
+        /// XML element for the next marker.
+        /// </summary>
+        private const string NextMarkerElement = "NextMarker";
+
+        /// <summary>
+        /// XML element for the next partition key.
+        /// </summary>
+        private const string NextPartitionKeyElement = "NextPartitionKey";
+
+        /// <summary>
+        /// XML element for the next row key.
+        /// </summary>
+        private const string NextRowKeyElement = "NextRowKey";
+
+        /// <summary>
+        /// XML element for the next table name.
+        /// </summary>
+        private const string NextTableNameElement = "NextTableName";
+
+        /// <summary>
+        /// XML element for the token version.
+        /// </summary>
+        private const string VersionElement = "Version";
+
+        /// <summary>
+        /// Stores the current token version value.
+        /// </summary>
+        private const string CurrentVersion = "1.0";
+
+        /// <summary>
+        /// XML element for the token type.
+        /// </summary>
+        private const string TypeElement = "Type";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResultContinuation"/> class.
+        /// </summary>
+        internal ResultContinuation()
+        { 
+        }
+
+        /// <summary>
+        /// Specifies the type of a continuation token.
+        /// </summary>
+        internal enum ContinuationType
+        {
+            /// <summary>
+            /// Default for no continuation.
+            /// </summary>
+            None = 0,
+
+            /// <summary>
+            /// The token is a blob listing continuation token.
+            /// </summary>
+            Blob,
+
+            /// <summary>
+            /// The token is a queue listing continuation token.
+            /// </summary>
+            Queue,
+
+            /// <summary>
+            /// The token is a container listing continuation token.
+            /// </summary>
+            Container,
+
+            /// <summary>
+            /// The token is a table query continuation token.
+            /// </summary>
+            Table
+        }
+
+        /// <summary>
+        /// Gets or sets the NextPartitionKey for TableServiceEntity enumeration operations.
+        /// </summary>
+        internal string NextPartitionKey { get; set; }
+
+        /// <summary>
+        /// Gets or sets the NextRowKey for TableServiceEntity enumeration operations.
+        /// </summary>
+        /// <value>The next row key.</value>
+        internal string NextRowKey { get; set; }
+
+        /// <summary>
+        /// Gets or sets the NextTableName for Table enumeration operations.
+        /// </summary>
+        /// <value>The name of the next table.</value>
+        internal string NextTableName { get; set; }
+
+        /// <summary>
+        /// Gets or sets the NextMarker for continuing results for CloudBlob and CloudBlobContainer and CloudQueue enumeration operations.
+        /// </summary>
+        /// <value>The next marker.</value>
+        internal string NextMarker { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating whether there is continuation information present.
+        /// </summary>
+        /// <returns></returns>
+        internal bool HasContinuation
+        {
+            get { return this.NextMarker != null || this.NextPartitionKey != null || this.NextRowKey != null || this.NextTableName != null; }
+        }
+
+        /// <summary>
+        /// Gets or sets the type.
+        /// </summary>
+        /// <value>The continuation type.</value>
+        internal ContinuationType Type { get; set; }
+
+        /// <summary>
+        /// Gets an XML representation of an object.
+        /// </summary>
+        /// <returns>
+        /// An <see cref="T:System.Xml.Schema.XmlSchema"/> that describes the XML representation of the object that is produced by the <see cref="M:System.Xml.Serialization.IXmlSerializable.WriteXml(System.Xml.XmlWriter)"/> method and consumed by the <see cref="M:System.Xml.Serialization.IXmlSerializable.ReadXml(System.Xml.XmlReader)"/> method.
+        /// </returns>
+        System.Xml.Schema.XmlSchema IXmlSerializable.GetSchema()
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Generates a serializable continuation token from its XML representation.
+        /// </summary>
+        /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the continuation token is deserialized.</param>
+        void IXmlSerializable.ReadXml(System.Xml.XmlReader reader)
+        {
+            CommonUtils.AssertNotNull("reader", reader);
+
+            reader.MoveToContent();
+
+            bool isEmptyElement = reader.IsEmptyElement;
+            reader.ReadStartElement();
+
+            if (!isEmptyElement)
+            {
+                bool more = true;
+                while (more)
+                {
+                    if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement)
+                    {
+                        switch (reader.Name)
+                        {
+                            case VersionElement:
+                                string version = reader.ReadElementContentAsString();
+
+                                // For future versioning
+                                break;
+                            case NextMarkerElement:
+                                this.NextMarker = reader.ReadElementContentAsString();
+                                break;
+                            case NextPartitionKeyElement:
+                                this.NextPartitionKey = reader.ReadElementContentAsString();
+                                break;
+                            case NextRowKeyElement:
+                                this.NextRowKey = reader.ReadElementContentAsString();
+                                break;
+                            case NextTableNameElement:
+                                this.NextTableName = reader.ReadElementContentAsString();
+                                break;
+                            case TypeElement:
+                                this.Type = (ContinuationType)Enum.Parse(typeof(ContinuationType), reader.ReadElementContentAsString());
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        more = reader.Read();
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Converts a serializable continuation token into its XML representation.
+        /// </summary>
+        /// <param name="writer">The <see cref="T:System.Xml.XmlWriter"/> stream to which the continuation token is serialized.</param>
+        void IXmlSerializable.WriteXml(XmlWriter writer)
+        {
+            CommonUtils.AssertNotNull("writer", writer);
+
+            writer.WriteElementString(VersionElement, CurrentVersion);
+
+            writer.WriteElementString(TypeElement, this.Type.ToString());
+
+            if (this.NextMarker != null)
+            {
+                writer.WriteElementString(NextMarkerElement, this.NextMarker);
+            }
+
+            if (this.NextPartitionKey != null)
+            {
+                writer.WriteElementString(NextPartitionKeyElement, this.NextPartitionKey);
+            }
+
+            if (this.NextRowKey != null)
+            {
+                writer.WriteElementString(NextRowKeyElement, this.NextRowKey);
+            }
+
+            if (this.NextTableName != null)
+            {
+                writer.WriteElementString(NextTableNameElement, this.NextTableName);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/ResultPagination.cs b/microsoft-azure-api/StorageClient/ResultPagination.cs
new file mode 100644
index 0000000000000..b428cb94c5627
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ResultPagination.cs
@@ -0,0 +1,133 @@
+//-----------------------------------------------------------------------
+// <copyright file="ResultPagination.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ResultPagination class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Globalization;
+
+    /// <summary>
+    /// Represents a class which manages pagination of results.
+    /// </summary>
+    internal class ResultPagination
+    {
+        /// <summary>
+        /// Stores the results remaining in the current page.
+        /// </summary>
+        private int? remainingResultsInPage;
+
+        /// <summary>
+        /// Stores the page size.
+        /// </summary>
+        private int maxResults;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ResultPagination"/> class.
+        /// </summary>
+        /// <param name="maxResults">Number of results to be returned as a page.
+        /// maxResults of 0 or less means no paging.</param>
+        public ResultPagination(int maxResults)
+        {
+            CommonUtils.AssertInBounds("maxResults", maxResults, 0, Int32.MaxValue);
+
+            this.maxResults = maxResults <= 0 ? 0 : maxResults;
+            if (this.maxResults > 0)
+            {
+                this.remainingResultsInPage = this.maxResults;
+            }
+        }
+
+        /// <summary>
+        /// Gets the maxResults in use for the current Pagination instance
+        /// Returns zero if paging is not in use.
+        /// </summary>
+        /// <value>The size of the effective page.</value>
+        internal int EffectivePageSize
+        {
+            get
+            {
+                return this.maxResults;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether paging is enabled with a valid postive page size. 
+        /// An instance with a non positive page size will return false.
+        /// </summary>
+        internal bool IsPagingEnabled
+        {
+            get
+            {
+                return this.maxResults > 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether there are no more remaining results in the current page.
+        /// Will return false if paging is not enabled.
+        /// </summary>
+        internal bool IsPageCompleted
+        {
+            get
+            {
+                return this.remainingResultsInPage == 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets the size for next request to pass in parameter like MaxResults.
+        /// </summary>
+        /// <returns>Postive value indicating size of a result page if using paging. 
+        /// Else null is returned.</returns>
+        internal int? GetNextRequestPageSize()
+        {
+            if (this.maxResults > 0)
+            {
+                this.remainingResultsInPage = this.remainingResultsInPage.GetValueOrDefault() == 0 ?
+                    this.maxResults : this.remainingResultsInPage;
+            }
+            else
+            {
+                this.remainingResultsInPage = null;
+            }
+
+            return this.remainingResultsInPage;
+        }
+
+        /// <summary>
+        /// Update pagination paramters for new result set returned.
+        /// </summary>
+        /// <param name="currentResultCount">The current result count.</param>
+        internal void UpdatePaginationForResult(int currentResultCount)
+        {
+            if (this.maxResults > 0)
+            {
+                // We are using paging
+                this.remainingResultsInPage = this.remainingResultsInPage.Value - currentResultCount;
+
+                if (this.remainingResultsInPage < 0)
+                {
+                    string errorMessage = string.Format(CultureInfo.CurrentCulture, SR.ServerReturnedMoreThanMaxResults);
+                    throw new InvalidOperationException(errorMessage);
+                }
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/ResultSegment.cs b/microsoft-azure-api/StorageClient/ResultSegment.cs
new file mode 100644
index 0000000000000..12ca32d3e9d04
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ResultSegment.cs
@@ -0,0 +1,238 @@
+//-----------------------------------------------------------------------
+// <copyright file="ResultSegment.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ResultSegment and ResultSegment[T] classes.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a result segment that was retrieved from the total set of possible results.
+    /// </summary>
+    /// <typeparam name="TElement">The type of the element.</typeparam>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a non-generic static helper with the same name.")]
+    public class ResultSegment<TElement>
+    {
+        /// <summary>
+        /// Stores the continuation token used to retrieve the next segment of results.
+        /// </summary>
+        private ResultContinuation continuationToken;
+
+        /// <summary>
+        /// Stores the closure used to retrieve the next set of results.
+        /// </summary>
+        private Func<Action<ResultSegment<TElement>>, TaskSequence> getNext;
+
+        /// <summary>
+        /// Stores the <see cref="RetryPolicy"/> used for requests.
+        /// </summary>
+        private RetryPolicy retryPolicy;
+
+        /// <summary>
+        /// Initializes a new instance of the ResultSegment class.
+        /// </summary>
+        /// <param name="result">The result.</param>
+        /// <param name="moreResults">If set to <c>true</c> there are more results.</param>
+        /// <param name="getNext">The next result segment.</param>
+        /// <param name="retryPolicy">The retry policy.</param>
+        internal ResultSegment(IEnumerable<TElement> result, bool moreResults, Func<Action<ResultSegment<TElement>>, TaskSequence> getNext, RetryPolicy retryPolicy)
+        {
+            this.Results = result;
+            this.HasMoreResults = moreResults;
+            this.getNext = getNext;
+            this.retryPolicy = retryPolicy;
+        }
+
+        /// <summary>
+        /// Gets an enumerable collection of results.
+        /// </summary>
+        /// <value>An enumerable collection of results.</value>
+        public IEnumerable<TElement> Results { get; private set; }
+
+        /// <summary>
+        /// Gets a value indicating whether there are additional results to retrieve.
+        /// </summary>
+        /// <value><c>True</c> if there are additional results; otherwise, <c>false</c>.</value>
+        public bool HasMoreResults { get; private set; }
+
+        /// <summary>
+        /// Gets a continuation token to use to retrieve the next set of results with a subsequent call to the operation.
+        /// </summary>
+        /// <value>The continuation token.</value>
+        public ResultContinuation ContinuationToken
+        {
+            get
+            {
+                if (this.continuationToken != null && this.continuationToken.HasContinuation)
+                {
+                    return this.continuationToken;
+                }
+
+                return null;
+            }
+
+            internal set
+            {
+                this.continuationToken = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the pagination information for Results.
+        /// </summary>
+        /// <value>The pagination.</value>
+        internal ResultPagination Pagination { get; set; }
+
+        /// <summary>
+        /// Gets the retry policy.
+        /// </summary>
+        /// <value>The retry policy.</value>
+        internal RetryPolicy RetryPolicy
+        {
+            get
+            {
+                return this.retryPolicy;
+            }
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to retrieve the next result segment.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginGetNext(AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertSegmentResultNotComplete<TElement>(this);
+
+            return TaskImplHelper.BeginImplWithRetry<ResultSegment<TElement>>(this.GetNextImpl, this.retryPolicy, callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to retrieve the next result segment.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns>The next result segment.</returns>
+        public ResultSegment<TElement> EndGetNext(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<ResultSegment<TElement>>(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets the next result segment.
+        /// </summary>
+        /// <returns>The next result segment.</returns>
+        public ResultSegment<TElement> GetNext()
+        {
+            CommonUtils.AssertSegmentResultNotComplete<TElement>(this);
+
+            return TaskImplHelper.ExecuteImplWithRetry<ResultSegment<TElement>>(this.GetNextImpl, this.retryPolicy);
+        }
+
+        /// <summary>
+        /// Implementation of GetNext (For symmetry with normal tasks.
+        /// </summary>
+        /// <param name="setResult">The action to set the results.</param>
+        /// <returns>A <see cref="TaskSequence"/> representing the operation to get the next set of results.</returns>
+        internal TaskSequence GetNextImpl(Action<ResultSegment<TElement>> setResult)
+        {
+            return this.getNext(setResult);
+        }
+    }
+
+    /// <summary>
+    /// Represents a helper class to support additional operations on ResultSegments 
+    /// such as grouping of results into pages.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a generic class with the same name.")]
+    internal static class ResultSegment
+    {
+        /// <summary>
+        /// Checks if the result segment has more results in the current page if pagination is used.
+        /// If pagination is not used, it checks if a valid continuation is present.
+        /// </summary>
+        /// <param name="pagination">The pagination.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <returns>
+        /// Returns <c>true</c> if there are more results in the page; otherwise, <c>false</c>.
+        /// </returns>
+        internal static bool HasMoreResultsInPage(ResultPagination pagination, ResultContinuation continuationToken)
+        {
+            bool hasContinuation = HasContinuation(continuationToken);
+
+            if (pagination.IsPagingEnabled)
+            {
+                return !pagination.IsPageCompleted && hasContinuation;
+            }
+
+            return hasContinuation;
+        }
+
+        /// <summary>
+        /// Create a result segment from the result result.
+        /// </summary>
+        /// <typeparam name="T">The type of the result.</typeparam>
+        /// <param name="setResult">The set result.</param>
+        /// <param name="resultList">The result list.</param>
+        /// <param name="continuationToken">The continuation token.</param>
+        /// <param name="pagination">The pagination.</param>
+        /// <param name="retryPolicy">The retry policy.</param>
+        /// <param name="continuationFunction">The continuation function.</param>
+        internal static void CreateResultSegment<T>(
+            Action<ResultSegment<T>> setResult,
+            IEnumerable<T> resultList,
+            ResultContinuation continuationToken,
+            ResultPagination pagination,
+            RetryPolicy retryPolicy,
+            Func<ResultPagination, ResultContinuation, Action<ResultSegment<T>>, TaskSequence> continuationFunction)
+        {
+            pagination.UpdatePaginationForResult(resultList.Count());
+
+            setResult(new ResultSegment<T>(
+                resultList,
+                HasMoreResultsInPage(pagination, continuationToken),
+                (setResultInner) => continuationFunction(pagination, continuationToken, setResultInner),
+                retryPolicy)
+                {
+                    ContinuationToken = continuationToken,
+                });
+        }
+
+        /// <summary>
+        /// Checks if the result segment passed in has a valid continuation token.
+        /// </summary>
+        /// <param name="continuation">The continuation.</param>
+        /// <returns>
+        /// Returns <c>true</c> if the specified continuation has continuation; otherwise, <c>false</c>.
+        /// </returns>
+        private static bool HasContinuation(ResultContinuation continuation)
+        {
+            return continuation != null && continuation.HasContinuation;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/RetryPolicies.cs b/microsoft-azure-api/StorageClient/RetryPolicies.cs
new file mode 100644
index 0000000000000..3a281a14241f7
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/RetryPolicies.cs
@@ -0,0 +1,160 @@
+//-----------------------------------------------------------------------
+// <copyright file="RetryPolicies.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the RetryPolicies class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Net;
+
+    /// <summary>
+    /// Defines some standard retry policies.
+    /// </summary>
+    public static class RetryPolicies
+    {
+        /// <summary>
+        /// Indicates the default minimum backoff value that will be used for a policy returned by <see cref="RetryPolicies.RetryExponential (Int32, TimeSpan)"/>. 
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            MessageId = "Backoff",
+            Justification = "Backoff is a compound term.")]
+        public static readonly TimeSpan DefaultMinBackoff = TimeSpan.FromSeconds(3);
+
+        /// <summary>
+        /// Indicates the default maximum backoff value that will be used for a policy returned by <see cref="RetryPolicies.RetryExponential (Int32, TimeSpan)"/>. 
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            MessageId = "Backoff",
+            Justification = "Backoff is a compound term.")]
+        public static readonly TimeSpan DefaultMaxBackoff = TimeSpan.FromSeconds(90);
+        
+        /// <summary>
+        /// Indicates the default client backoff value that will be used by a service client, if no other retry policy has been specified.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            MessageId = "Backoff",
+            Justification = "Backoff is a compound term.")]
+        public static readonly TimeSpan DefaultClientBackoff = TimeSpan.FromSeconds(30);
+        
+        /// <summary>
+        /// Indicates the default retry count that will be used by a service client, if no other retry policy has been specified.
+        /// </summary>
+        public static readonly int DefaultClientRetryCount = 3;
+
+        /// <summary>
+        /// Returns a retry policy that performs no retries.
+        /// </summary>
+        /// <returns>The retry policy.</returns>
+        public static RetryPolicy NoRetry()
+        {
+            return () =>
+            {
+                return (int retryCount, Exception lastException, out TimeSpan retryInterval) =>
+                    {
+                        retryInterval = TimeSpan.Zero;
+                        return false;
+                    };
+            };
+        }
+
+        /// <summary>
+        /// Returns a retry policy that retries a specified number of times, with a specified fixed time interval between retries.
+        /// </summary>
+        /// <param name="retryCount">A non-negative number indicating the number of times to retry.</param>
+        /// <param name="intervalBetweenRetries">The time interval between retries. Use <see cref="System.TimeSpan.Zero"/> to specify that the operation
+        /// should be retried immediately.</param>
+        /// <returns>The retry policy.</returns>
+        public static RetryPolicy Retry(int retryCount, TimeSpan intervalBetweenRetries)
+        {
+            CommonUtils.AssertInBounds("currentRetryCount", retryCount, 0, int.MaxValue);
+            CommonUtils.AssertInBounds("intervalBetweenRetries", intervalBetweenRetries, TimeSpan.Zero, TimeSpan.MaxValue);
+
+            return () =>
+            {
+                return (int currentRetryCount, Exception lastException, out TimeSpan retryInterval) =>
+                {
+                    retryInterval = intervalBetweenRetries;
+                    return currentRetryCount < retryCount;
+                };
+            };
+        }
+
+        /// <summary>
+        /// Returns a policy that retries a specified number of times with a randomized exponential backoff scheme.
+        /// </summary>
+        /// <param name="retryCount">A non-negative number indicating the number of times to retry.</param>
+        /// <param name="deltaBackoff">The multiplier in the exponential backoff scheme.</param>
+        /// <returns>The retry policy.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            MessageId = "Backoff",
+            Justification = "Backoff is a compound term.")]
+        public static RetryPolicy RetryExponential(int retryCount, TimeSpan deltaBackoff)
+        {
+            return RetryExponential(retryCount, DefaultMinBackoff, DefaultMaxBackoff, deltaBackoff);
+        }
+
+        /// <summary>
+        /// Returns a policy that retries a specified number of times with a randomized exponential backoff scheme.
+        /// </summary>
+        /// <param name="retryCount">A non-negative number indicating the number of times to retry.</param>
+        /// <param name="minBackoff">The minimum backoff interval.</param>
+        /// <param name="maxBackoff">The maximum backoff interval.</param>
+        /// <param name="deltaBackoff">The multiplier in the exponential backoff scheme.</param>
+        /// <returns>The retry policy.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            MessageId = "Backoff",
+            Justification = "Backoff is a compound term.")]
+        public static RetryPolicy RetryExponential(int retryCount, TimeSpan minBackoff, TimeSpan maxBackoff, TimeSpan deltaBackoff)
+        {
+            CommonUtils.AssertInBounds("currentRetryCount", retryCount, 0, int.MaxValue);
+            CommonUtils.AssertInBounds("minBackoff", minBackoff, TimeSpan.Zero, TimeSpan.MaxValue);
+            CommonUtils.AssertInBounds("maxBackoff", maxBackoff, TimeSpan.Zero, TimeSpan.MaxValue);
+            CommonUtils.AssertInBounds("deltaBackoff", deltaBackoff, TimeSpan.Zero, TimeSpan.MaxValue);
+
+            return () =>
+            {
+                return (int currentRetryCount, Exception lastException, out TimeSpan retryInterval) =>
+                {
+                    if (currentRetryCount < retryCount)
+                    {
+                        Random r = new Random();
+                        int increment = (int)((Math.Pow(2, currentRetryCount) - 1) * r.Next((int)(deltaBackoff.TotalMilliseconds * 0.8), (int)(deltaBackoff.TotalMilliseconds * 1.2)));
+                        int timeToSleepMsec = (int)Math.Min(minBackoff.TotalMilliseconds + increment, maxBackoff.TotalMilliseconds);
+
+                        retryInterval = TimeSpan.FromMilliseconds(timeToSleepMsec);
+                        return true;
+                    }
+
+                    retryInterval = TimeSpan.Zero;
+                    return false;
+                };
+            };
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/RetryPolicy.cs b/microsoft-azure-api/StorageClient/RetryPolicy.cs
new file mode 100644
index 0000000000000..1d3e2ca45c41e
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/RetryPolicy.cs
@@ -0,0 +1,28 @@
+//-----------------------------------------------------------------------
+// <copyright file="RetryPolicy.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the RetryPolicy delegate.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Returns a delegate that implements a custom retry policy.
+    /// </summary>
+    /// <returns>A delegate that determines whether or not to retry an operation.</returns>
+    public delegate ShouldRetry RetryPolicy();
+}
diff --git a/microsoft-azure-api/StorageClient/SharedAccessPermissions.cs b/microsoft-azure-api/StorageClient/SharedAccessPermissions.cs
new file mode 100644
index 0000000000000..a9421c4f9c7a6
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/SharedAccessPermissions.cs
@@ -0,0 +1,57 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedAccessPermissions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedAccessPermissions enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Text;
+
+    /// <summary>
+    /// Specifies the set of possible permissions for a shared access policy.
+    /// </summary>
+    [Flags]
+    public enum SharedAccessPermissions
+    {
+        /// <summary>
+        /// No shared access granted.
+        /// </summary>
+        None = 0x0,
+
+        /// <summary>
+        /// Read access granted.
+        /// </summary>
+        Read = 0x1,
+
+        /// <summary>
+        /// Write access granted.
+        /// </summary>
+        Write = 0x2,
+
+        /// <summary>
+        /// Delete access granted for blobs.
+        /// </summary>
+        Delete = 0x4,
+
+        /// <summary>
+        /// List access granted.
+        /// </summary>
+        List = 0x8
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/SharedAccessPolicies.cs b/microsoft-azure-api/StorageClient/SharedAccessPolicies.cs
new file mode 100644
index 0000000000000..493c5ca046b97
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/SharedAccessPolicies.cs
@@ -0,0 +1,37 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedAccessPolicies.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedAccessPolicies class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Represents the collection of shared access policies defined for a container.
+    /// </summary>
+    [Serializable]
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.Naming",
+        "CA1710:IdentifiersShouldHaveCorrectSuffix",
+        Justification = "Public APIs should not expose base collection types.")]
+    public class SharedAccessPolicies : Dictionary<string, SharedAccessPolicy>
+    {
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/SharedAccessPolicy.cs b/microsoft-azure-api/StorageClient/SharedAccessPolicy.cs
new file mode 100644
index 0000000000000..8542677c54c92
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/SharedAccessPolicy.cs
@@ -0,0 +1,130 @@
+//-----------------------------------------------------------------------
+// <copyright file="SharedAccessPolicy.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SharedAccessPolicy class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Text;
+
+    /// <summary>
+    /// Represents a shared access policy, which specifies the start time, expiry time, 
+    /// and permissions for a shared access signature.
+    /// </summary>
+    public class SharedAccessPolicy
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SharedAccessPolicy"/> class.
+        /// </summary>
+        public SharedAccessPolicy()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the start time for a shared access signature associated with this shared access policy.
+        /// </summary>
+        /// <value>The shared access start time.</value>
+        public DateTime? SharedAccessStartTime { get; set; }
+
+        /// <summary>
+        /// Gets or sets the expiry time for a shared access signature associated with this shared access policy.
+        /// </summary>
+        /// <value>The shared access expiry time.</value>
+        public DateTime? SharedAccessExpiryTime { get; set; }
+
+        /// <summary>
+        /// Gets or sets the permissions for a shared access signature associated with this shared access policy.
+        /// </summary>
+        /// <value>The permissions.</value>
+        public SharedAccessPermissions Permissions { get; set; }
+
+        /// <summary>
+        /// Converts the permissions specified for the shared access policy to a string.
+        /// </summary>
+        /// <param name="permissions">The shared access permissions.</param>
+        /// <returns>The shared access permissions in string format.</returns>
+        public static string PermissionsToString(SharedAccessPermissions permissions) 
+        {
+            // The service supports a fixed order => rwdl
+            StringBuilder builder = new StringBuilder();
+            if ((permissions & SharedAccessPermissions.Read) == SharedAccessPermissions.Read)
+            {
+                builder.Append("r");
+            }
+
+            if ((permissions & SharedAccessPermissions.Write) == SharedAccessPermissions.Write)
+            {
+                builder.Append("w");
+            }
+
+            if ((permissions & SharedAccessPermissions.Delete) == SharedAccessPermissions.Delete)
+            {
+                builder.Append("d");
+            }
+
+            if ((permissions & SharedAccessPermissions.List) == SharedAccessPermissions.List)
+            {
+                builder.Append("l");
+            }
+
+            return builder.ToString();
+        }
+
+        /// <summary>
+        /// Constructs a <see cref="SharedAccessPermissions"/> object from a permissions string.
+        /// </summary>
+        /// <param name="value">The shared access permissions in string format.</param>
+        /// <returns>A set of shared access permissions.</returns>
+        public static SharedAccessPermissions PermissionsFromString(string value) 
+        {
+            char[] chars = value.ToCharArray();
+            SharedAccessPermissions permissions = 0;
+
+            foreach (char c in chars)
+            {
+                switch (c)
+                {
+                    case 'r':
+                        permissions |= SharedAccessPermissions.Read;
+                        break;
+                    case 'w':
+                        permissions |= SharedAccessPermissions.Write;
+                        break;
+                    case 'd':
+                        permissions |= SharedAccessPermissions.Delete;
+                        break;
+                    case 'l':
+                        permissions |= SharedAccessPermissions.List;
+                        break;
+                    default:
+                        CommonUtils.ArgumentOutOfRange("value", value);
+                        break;
+                }
+            }
+
+            // Incase we ever change none to be something other than 0
+            if (permissions == 0)
+            {
+                permissions |= SharedAccessPermissions.None;
+            }
+
+            return permissions;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/ShouldRetry.cs b/microsoft-azure-api/StorageClient/ShouldRetry.cs
new file mode 100644
index 0000000000000..1995c70fcfb22
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/ShouldRetry.cs
@@ -0,0 +1,37 @@
+//-----------------------------------------------------------------------
+// <copyright file="ShouldRetry.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ShouldRetry delegate.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+
+    /// <summary>
+    /// Determines whether a request should be retried.
+    /// </summary>
+    /// <param name="retryCount">The number of times the request has been retried.</param>
+    /// <param name="lastException">The exception raised by the most recent operation.</param>
+    /// <param name="delay">An optional delay that specifies how long to wait before retrying a request.</param>
+    /// <returns><c>true</c> if the request should be retried; otherwise, <c>false</c>.</returns>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.Design",
+        "CA1021:AvoidOutParameters",
+        Justification = "Custom retry policies are advanced.")]
+    public delegate bool ShouldRetry(int retryCount, Exception lastException, out TimeSpan delay);
+}
diff --git a/microsoft-azure-api/StorageClient/SmallBlockMemoryStream.cs b/microsoft-azure-api/StorageClient/SmallBlockMemoryStream.cs
new file mode 100644
index 0000000000000..e3938a26d6dcc
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/SmallBlockMemoryStream.cs
@@ -0,0 +1,405 @@
+//-----------------------------------------------------------------------
+// <copyright file="SmallBlockMemoryStream.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SmallBlockMemoryStream class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+
+    /// <summary>
+    /// This class provides MemoryStream-like behavior but uses a list of blocks rather than a single piece of bufferBlocks.
+    /// </summary>
+    internal class SmallBlockMemoryStream : Stream
+    {
+        /// <summary>
+        /// The default block size.
+        /// </summary>
+        private const long DefaultBlockSize = 1024 * 1024; // 1MB
+
+        /// <summary>
+        /// The size of the block.
+        /// </summary>
+        private readonly long blockSize;
+
+        /// <summary>
+        /// The underlying bufferBlocks for the stream.
+        /// </summary>
+        private List<byte[]> bufferBlocks = new List<byte[]>();
+
+        /// <summary>
+        /// The currently used length.
+        /// </summary>
+        private long length;
+
+        /// <summary>
+        /// The total capacity of the stream.
+        /// </summary>
+        private long capacity;
+
+        /// <summary>
+        /// The current position.
+        /// </summary>
+        private long position;
+        
+        /// <summary>
+        /// Initializes a new instance of the SmallBlockMemoryStream class with default 64KB block size and no reserved space.
+        /// </summary>
+        public SmallBlockMemoryStream()
+            : this(DefaultBlockSize)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the SmallBlockMemoryStream class with provided block size and no reserved space.
+        /// </summary>
+        /// <param name="blockSize">The size of blocks to use.</param>
+        public SmallBlockMemoryStream(long blockSize)
+            : this(blockSize, 0)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the SmallBlockMemoryStream class.
+        /// </summary>
+        /// <param name="blockSize">The size of blocks to use.</param>
+        /// <param name="reservedSize">The amount of memory to reserve.</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown if <paramref name="blockSize"/> is zero or negative.</exception>
+        public SmallBlockMemoryStream(long blockSize, long reservedSize)
+        {
+            if (blockSize <= 0)
+            {
+                throw new ArgumentOutOfRangeException("blockSize", "BlockSize must be a positive, non-zero value");
+            }
+
+            this.blockSize = blockSize;
+            this.Reserve(reservedSize);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports reading.
+        /// </summary>
+        /// <value>Is <c>true</c> if the stream supports reading; otherwise, <c>false</c>.</value>
+        public override bool CanRead
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports seeking.
+        /// </summary>
+        /// <value>Is true if the stream supports seeking; otherwise, false.</value>
+        public override bool CanSeek
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the current stream supports writing.
+        /// </summary>
+        /// <value>Is true if the stream supports writing; otherwise, false.</value>
+        public override bool CanWrite
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Gets the currently written length.
+        /// </summary>
+        public override long Length
+        {
+            get { return this.length; }
+        }
+
+        /// <summary>
+        /// Represents the current position in the stream.
+        /// </summary>
+        /// <exception cref="ArgumentException">Thrown if position is outside the stream size</exception>
+        public override long Position
+        {
+            get { return this.position; }
+            set { this.Seek(value, SeekOrigin.Begin); }
+        }
+        
+        /// <summary>
+        /// Copies the specified amount of data from internal buffers to the buffer and advances the position.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values 
+        ///                     between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns> The total number of bytes read into the buffer. This can be less than the number of bytes requested 
+        /// if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
+        /// </returns>
+        /// <exception cref="System.ArgumentException">The offset subtracted from the buffer length is less than count.</exception>
+        /// <exception cref="System.ArgumentNullException">The buffer is null.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">The offset or count is negative.</exception>
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            if (buffer == null)
+            {
+                throw new ArgumentNullException("buffer");
+            }
+
+            if (offset < 0)
+            {
+                throw new ArgumentOutOfRangeException("offset", "Offset must be positive");
+            }
+
+            if (count < 0)
+            {
+                throw new ArgumentOutOfRangeException("count", "Count must be positive");
+            }
+
+            if ((buffer.Length - offset) < count)
+            {
+                throw new ArgumentException("Offset and count are beyond the buffer size", "count");
+            }
+
+            return this.ReadInternal(buffer, offset, count);
+        }
+
+        /// <summary>
+        /// Sets the position within the current stream.
+        /// </summary>
+        /// <param name="offset">A byte offset relative to the origin parameter.</param>
+        /// <param name="origin">A value of type System.IO.SeekOrigin indicating the reference point used to obtain the new position.</param>
+        /// <returns>The new position within the current stream.</returns>
+        /// <exception cref="ArgumentException">Thrown if <paramref name="offset"/> is invalid for SeekOrigin.</exception>
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            switch (origin)
+            {
+                case SeekOrigin.Begin:
+                    if (offset < 0)
+                    {
+                        throw new ArgumentException("Attempting to seek before the start of the stream", "origin");
+                    }
+
+                    if (offset > this.length)
+                    {
+                        throw new ArgumentException("Attempting to seek past the end of the stream", "origin");
+                    }
+
+                    this.position = offset;
+                    break;
+                case SeekOrigin.Current:
+                    if (this.position + offset < 0)
+                    {
+                        throw new ArgumentException("Attempting to seek before the start of the stream", "origin");
+                    }
+
+                    if (this.position + offset > this.length)
+                    {
+                        throw new ArgumentException("Attempting to seek past the end of the stream", "origin");
+                    }
+
+                    this.position += offset;
+                    break;
+                case SeekOrigin.End:
+                    if (this.length + offset < 0)
+                    {
+                        throw new ArgumentException("Attempting to seek before the start of the stream", "origin");
+                    }
+
+                    if (offset > 0)
+                    {
+                        throw new ArgumentException("Attempting to seek past the end of the stream", "origin");
+                    }
+
+                    this.position = this.length + offset;
+                    break;
+            }
+
+            return this.position;
+        }
+
+        /// <summary>
+        /// Sets the length of the current stream. (preallocating the bufferBlocks).
+        /// </summary>
+        /// <param name="value">The desired length of the current stream in bytes.</param>
+        /// <exception cref="ArgumentOutOfRangeException">If the <paramref name="value"/> is negative.</exception>
+        public override void SetLength(long value)
+        {
+            this.Reserve(value);
+            this.length = value;
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the current stream.</param>
+        /// <exception cref="System.ArgumentException">Offset subtracted from the buffer length is less than count. </exception>
+        /// <exception cref="System.ArgumentNullException">Thrown if <paramref name="buffer"/> is null</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">Thrown if <paramref name="offset"/> or <paramref name="count"/> is negative</exception>
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            if (buffer == null)
+            {
+                throw new ArgumentNullException("buffer");
+            }
+
+            if (offset < 0)
+            {
+                throw new ArgumentOutOfRangeException("offset", "Offset must be positive");
+            }
+
+            if (count < 0)
+            {
+                throw new ArgumentOutOfRangeException("count", "Count must be positive");
+            }
+
+            if ((buffer.Length - offset) < count)
+            {
+                throw new ArgumentException("Offset subtracted from the buffer length is less than count", "offset");
+            }
+
+            // Grow the buffer if more space is needed
+            if (this.position + count > this.capacity)
+            {
+                this.Reserve(this.position + count);
+            }
+
+            this.WriteInternal(buffer, offset, count);
+
+            // Adjust the length to be the max of currently written data.
+            this.length = Math.Max(this.length, this.position);
+        }
+
+        /// <summary>
+        /// Does not perform any operation as it's an in-memory stream.
+        /// </summary>
+        public override void Flush()
+        {
+        }
+        
+        /// <summary>
+        /// Ensures that the amount of bufferBlocks is greater than or equal to the required size. 
+        /// Does not trim the size.
+        /// </summary>
+        /// <param name="requiredSize">The required size.</param>
+        /// <exception cref="ArgumentOutOfRangeException">If the <paramref name="requiredSize"/> is negative.</exception>
+        private void Reserve(long requiredSize)
+        {
+            if (requiredSize < 0)
+            {
+                throw new ArgumentOutOfRangeException("requiredSize", "The size must be positive");
+            }
+
+            while (requiredSize > this.capacity)
+            {
+                this.AddBlock();
+            }
+        }
+
+        /// <summary>
+        /// Adds another block to the underlying bufferBlocks.
+        /// </summary>
+        private void AddBlock()
+        {
+            this.bufferBlocks.Add(new byte[this.blockSize]);
+            this.capacity += this.blockSize;
+        }
+
+        /// <summary>
+        /// Copies the specified amount of data from internal buffers to the buffer and advances the position.
+        /// </summary>
+        /// <param name="buffer">An array of bytes. When this method returns, the buffer contains the specified byte array with the values 
+        ///                     between offset and (offset + count - 1) replaced by the bytes read from the current source.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin storing the data read from the current stream.</param>
+        /// <param name="count">The maximum number of bytes to be read from the current stream.</param>
+        /// <returns> The total number of bytes read into the buffer. This can be less than the number of bytes requested 
+        /// if that many bytes are not currently available, or zero (0) if the end of the stream has been reached.
+        /// </returns>
+        private int ReadInternal(byte[] buffer, int offset, int count)
+        {
+            // Maximum amount you can read is from current spot to the end.
+            int readLength = (int)Math.Min(this.Length - this.Position, count);
+            int leftToRead = readLength;
+
+            while (leftToRead != 0)
+            {
+                int blockPosition;
+                byte[] currentBlock;
+                this.GetCurrentBlock(out blockPosition, out currentBlock);
+
+                // Copy the block
+                int blockReadLength = Math.Min(leftToRead, currentBlock.Length - blockPosition);
+                Buffer.BlockCopy(currentBlock, blockPosition, buffer, offset, blockReadLength);
+
+                this.AdvancePosition(ref offset, ref leftToRead, blockReadLength);
+            }
+
+            return readLength;
+        }
+
+        /// <summary>
+        /// Writes a sequence of bytes to the current stream and advances the current position within this stream by the number of bytes written.
+        /// (Requires the stream to be of sufficient size for writing).
+        /// </summary>
+        /// <param name="buffer">An array of bytes. This method copies count bytes from buffer to the current stream.</param>
+        /// <param name="offset">The zero-based byte offset in buffer at which to begin copying bytes to the current stream.</param>
+        /// <param name="count">The number of bytes to be written to the current stream.</param>
+        private void WriteInternal(byte[] buffer, int offset, int count)
+        {
+            while (count != 0)
+            {
+                int blockPosition;
+                byte[] currentBlock;
+                this.GetCurrentBlock(out blockPosition, out currentBlock);
+
+                // Copy the block
+                int blockWriteLength = Math.Min(count, currentBlock.Length - blockPosition);
+                Buffer.BlockCopy(buffer, offset, currentBlock, blockPosition, blockWriteLength);
+
+                this.AdvancePosition(ref offset, ref count, blockWriteLength);
+            }
+        }
+
+        /// <summary>
+        /// Advances the current position of the stream and adjust the offset and remainder based on the amount completed.
+        /// </summary>
+        /// <param name="offset">The current offset in the external buffer.</param>
+        /// <param name="leftToProcess">The amount of data left to process.</param>
+        /// <param name="amountProcessed">The amount of data processed.</param>
+        private void AdvancePosition(ref int offset, ref int leftToProcess, int amountProcessed)
+        {
+            // Advance the position in the stream and in the destination buffer
+            this.position += amountProcessed;
+            offset += amountProcessed;
+            leftToProcess -= amountProcessed;
+        }
+
+        /// <summary>
+        /// Calculate the block for the current position.
+        /// </summary>
+        /// <param name="blockPosition">The position within a block.</param>
+        /// <param name="currentBlock">The block reference itself.</param>
+        private void GetCurrentBlock(out int blockPosition, out byte[] currentBlock)
+        {
+            // Calculate the block and position in a block
+            int blockID = (int)(this.position / this.blockSize);
+            blockPosition = (int)(this.position % this.blockSize);
+            currentBlock = this.bufferBlocks[blockID];
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/StorageClientException.cs b/microsoft-azure-api/StorageClient/StorageClientException.cs
new file mode 100644
index 0000000000000..3749b23780fcb
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StorageClientException.cs
@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageClientException.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageClientException class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Net;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// Represents an exception thrown by the Windows Azure storage client library.
+    /// </summary>
+    [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors",
+        Justification = "Since this exception comes from the server, there must be an HTTP response code associated with it, hence we exclude the default constructor taking only a string but no status code.")]
+    [Serializable]
+    public class StorageClientException : StorageException
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageClientException"/> class.
+        /// </summary>
+        public StorageClientException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageClientException"/> class.
+        /// </summary>
+        /// <param name="errorCode">The storage client error code.</param>
+        /// <param name="message">The message that describes the exception.</param>
+        /// <param name="statusCode">The HTTP status code returned in the response.</param>
+        /// <param name="extendedErrorInfo">The extended error information.</param>
+        /// <param name="innerException">The <see cref="Exception"/> instance that caused the current exception.</param>
+        internal StorageClientException(
+            StorageErrorCode errorCode,
+            string message,
+            HttpStatusCode statusCode,
+            StorageExtendedErrorInformation extendedErrorInfo,
+            Exception innerException)
+            : base(errorCode, message, statusCode, extendedErrorInfo, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageClientException"/> class with
+        /// serialized data.
+        /// </summary>
+        /// <param name="info">The object that contains serialized data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> object that contains contextual information
+        /// about the source or destination.</param>
+        protected StorageClientException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/StorageErrorCode.cs b/microsoft-azure-api/StorageClient/StorageErrorCode.cs
new file mode 100644
index 0000000000000..9c47e85f3fb4f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StorageErrorCode.cs
@@ -0,0 +1,128 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageErrorCode.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageErrorCode enumeration.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Describes error codes that may be returned by the Windows Azure storage services or the storage client library.
+    /// </summary>
+    public enum StorageErrorCode
+    {
+        /// <summary>
+        /// No error specified.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// An internal server occurred (server-side error).
+        /// </summary>
+        ServiceInternalError = 1,
+
+        /// <summary>
+        /// The service timed out (server-side error).
+        /// </summary>
+        ServiceTimeout,
+
+        /// <summary>
+        /// A service integrity check failed (server-side error).
+        /// </summary>
+        ServiceIntegrityCheckFailed,
+
+        /// <summary>
+        /// A transport error occurred (server-side error).
+        /// </summary>
+        TransportError,
+        
+        /// <summary>
+        /// The service returned a bad response (server-side error).
+        /// </summary>
+        ServiceBadResponse,
+
+        /// <summary>
+        /// The specified resource was not found (client-side error).
+        /// </summary>
+        ResourceNotFound,
+
+        /// <summary>
+        /// The specified account was not found (client-side error).
+        /// </summary>
+        AccountNotFound,
+        
+        /// <summary>
+        /// The specified container was not found (client-side error).
+        /// </summary>
+        ContainerNotFound,
+
+        /// <summary>
+        /// The specified blob was not found (client-side error).
+        /// </summary>
+        BlobNotFound,
+
+        /// <summary>
+        /// An authentication error occurred (client-side error).
+        /// </summary>
+        AuthenticationFailure,
+
+        /// <summary>
+        /// Access was denied (client-side error).
+        /// </summary>
+        AccessDenied,
+
+        /// <summary>
+        /// The specified resource already exists (client-side error).
+        /// </summary>
+        ResourceAlreadyExists,
+
+        /// <summary>
+        /// The specified container already exists (client-side error).
+        /// </summary>
+        ContainerAlreadyExists,
+
+        /// <summary>
+        /// The specified blob already exists (client-side error).
+        /// </summary>
+        BlobAlreadyExists,
+
+        /// <summary>
+        /// The request was incorrect or badly formed (client-side error).
+        /// </summary>
+        BadRequest,
+
+        /// <summary>
+        /// The specified condition failed (client-side error).
+        /// </summary>
+        ConditionFailed,
+
+        /// <summary>
+        /// There was an error with the gateway used for the request (client-side error).
+        /// </summary>
+        BadGateway,
+
+        /// <summary>
+        /// The requested operation is not implemented on the specified resource (client-side error).
+        /// </summary>
+        NotImplemented,
+
+        /// <summary>
+        /// The request version header is not supported (client-side error).
+        /// </summary>
+        HttpVersionNotSupported,
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/StorageErrorCodeStrings.cs b/microsoft-azure-api/StorageClient/StorageErrorCodeStrings.cs
new file mode 100644
index 0000000000000..70589da2ac48c
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StorageErrorCodeStrings.cs
@@ -0,0 +1,208 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageErrorCodeStrings.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageErrorCodeStrings class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Provides error code strings that are common to all storage services.
+    /// </summary>
+    public static class StorageErrorCodeStrings
+    {
+        /// <summary>
+        /// The specified HTTP verb is not supported.
+        /// </summary>
+        public const string UnsupportedHttpVerb = "UnsupportedHttpVerb";
+
+        /// <summary>
+        /// The Content-Length header is required for this request.
+        /// </summary>
+        public const string MissingContentLengthHeader = "MissingContentLengthHeader";
+
+        /// <summary>
+        /// A required header was missing.
+        /// </summary>
+        public const string MissingRequiredHeader = "MissingRequiredHeader";
+
+        /// <summary>
+        /// A required XML node was missing.
+        /// </summary>
+        public const string MissingRequiredXmlNode = "MissingRequiredXmlNode";
+
+        /// <summary>
+        /// One or more header values are not supported.
+        /// </summary>
+        public const string UnsupportedHeader = "UnsupportedHeader";
+
+        /// <summary>
+        /// One or more XML nodes are not supported.
+        /// </summary>
+        public const string UnsupportedXmlNode = "UnsupportedXmlNode";
+
+        /// <summary>
+        /// One or more header values are invalid.
+        /// </summary>
+        public const string InvalidHeaderValue = "InvalidHeaderValue";
+
+        /// <summary>
+        /// One or more XML node values are invalid.
+        /// </summary>
+        public const string InvalidXmlNodeValue = "InvalidXmlNodeValue";
+
+        /// <summary>
+        /// A required query parameter is missing.
+        /// </summary>
+        public const string MissingRequiredQueryParameter = "MissingRequiredQueryParameter";
+
+        /// <summary>
+        /// One or more query parameters is not supported.
+        /// </summary>
+        public const string UnsupportedQueryParameter = "UnsupportedQueryParameter";
+
+        /// <summary>
+        /// One or more query parameters are invalid.
+        /// </summary>
+        public const string InvalidQueryParameterValue = "InvalidQueryParameterValue";
+
+        /// <summary>
+        /// One or more query parameters are out of range.
+        /// </summary>
+        public const string OutOfRangeQueryParameterValue = "OutOfRangeQueryParameterValue";
+
+        /// <summary>
+        /// The URI is invalid.
+        /// </summary>
+        public const string InvalidUri = "InvalidUri";
+
+        /// <summary>
+        /// The HTTP verb is invalid.
+        /// </summary>
+        public const string InvalidHttpVerb = "InvalidHttpVerb";
+
+        /// <summary>
+        /// The metadata key is empty.
+        /// </summary>
+        public const string EmptyMetadataKey = "EmptyMetadataKey";
+
+        /// <summary>
+        /// The request body is too large.
+        /// </summary>
+        public const string RequestBodyTooLarge = "RequestBodyTooLarge";
+
+        /// <summary>
+        /// The specified XML document is invalid.
+        /// </summary>
+        public const string InvalidXmlDocument = "InvalidXmlDocument";
+
+        /// <summary>
+        /// An internal error occurred.
+        /// </summary>
+        public const string InternalError = "InternalError";
+
+        /// <summary>
+        /// Authentication failed.
+        /// </summary>
+        public const string AuthenticationFailed = "AuthenticationFailed";
+
+        /// <summary>
+        /// The specified MD5 hash does not match the server value.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1709:IdentifiersShouldBeCasedCorrectly",
+            MessageId = "Md",
+            Justification = "The casing matches the storage constant the identifier represents.")]
+        public const string Md5Mismatch = "Md5Mismatch";
+
+        /// <summary>
+        /// The specified MD5 hash is invalid.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1709:IdentifiersShouldBeCasedCorrectly",
+            MessageId = "Md",
+            Justification = "The casing matches the storage constant the identifier represents.")]
+        public const string InvalidMd5 = "InvalidMd5";
+
+        /// <summary>
+        /// The input is out of range.
+        /// </summary>
+        public const string OutOfRangeInput = "OutOfRangeInput";
+
+        /// <summary>
+        /// The input is invalid.
+        /// </summary>
+        public const string InvalidInput = "InvalidInput";
+
+        /// <summary>
+        /// The operation timed out.
+        /// </summary>
+        public const string OperationTimedOut = "OperationTimedOut";
+
+        /// <summary>
+        /// The specified resource was not found.
+        /// </summary>
+        public const string ResourceNotFound = "ResourceNotFound";
+
+        /// <summary>
+        /// The specified metadata is invalid.
+        /// </summary>
+        public const string InvalidMetadata = "InvalidMetadata";
+
+        /// <summary>
+        /// The specified metadata is too large.
+        /// </summary>
+        public const string MetadataTooLarge = "MetadataTooLarge";
+
+        /// <summary>
+        /// The specified condition was not met.
+        /// </summary>
+        public const string ConditionNotMet = "ConditionNotMet";
+
+        /// <summary>
+        /// The specified range is invalid.
+        /// </summary>
+        public const string InvalidRange = "InvalidRange";
+
+        /// <summary>
+        /// The specified container was not found.
+        /// </summary>
+        public const string ContainerNotFound = "ContainerNotFound";
+
+        /// <summary>
+        /// The specified container already exists.
+        /// </summary>
+        public const string ContainerAlreadyExists = "ContainerAlreadyExists";
+
+        /// <summary>
+        /// The specified container is disabled.
+        /// </summary>
+        public const string ContainerDisabled = "ContainerDisabled";
+
+        /// <summary>
+        /// The specified container is being deleted.
+        /// </summary>
+        public const string ContainerBeingDeleted = "ContainerBeingDeleted";
+
+        /// <summary>
+        /// The server is busy.
+        /// </summary>
+        public const string ServerBusy = "ServerBusy";
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/StorageException.cs b/microsoft-azure-api/StorageClient/StorageException.cs
new file mode 100644
index 0000000000000..2a135464b0a8c
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StorageException.cs
@@ -0,0 +1,122 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageException.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageException class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Net;
+    using System.Runtime.Serialization;
+    using System.Security.Permissions;
+
+    /// <summary>
+    /// The base class for Windows Azure storage service exceptions.
+    /// </summary>
+    [Serializable]
+    public abstract class StorageException : Exception
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageException"/> class.
+        /// </summary>
+        protected StorageException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageException"/> class.
+        /// </summary>
+        /// <param name="errorCode">The storage client error code.</param>
+        /// <param name="message">The message that describes the exception.</param>
+        /// <param name="statusCode">The HTTP status code returned in the response.</param>
+        /// <param name="extendedErrorInfo">The extended error information.</param>
+        /// <param name="innerException">The <see cref="Exception"/> instance that caused the current exception.</param>
+        protected StorageException(
+            StorageErrorCode errorCode,
+            string message,
+            HttpStatusCode statusCode,
+            StorageExtendedErrorInformation extendedErrorInfo,
+            Exception innerException)
+            : base(message, innerException)
+        {
+            this.ErrorCode = errorCode;
+            this.StatusCode = statusCode;
+            this.ExtendedErrorInformation = extendedErrorInfo;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageException"/> class with
+        /// serialized data.
+        /// </summary>
+        /// <param name="info">The <see cref="SerializationInfo"/> object that contains serialized object
+        /// data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> object that contains contextual information
+        /// about the source or destionation. </param>
+        protected StorageException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+            if (null == info)
+            {
+                throw new ArgumentNullException("info");
+            }
+
+            this.StatusCode = (HttpStatusCode)info.GetValue("StatusCode", typeof(HttpStatusCode));
+            this.ErrorCode = (StorageErrorCode)info.GetValue("ErrorCode", typeof(StorageErrorCode));
+            this.ExtendedErrorInformation = (StorageExtendedErrorInformation)info.GetValue(
+                        "ExtendedErrorInformation", typeof(StorageExtendedErrorInformation));
+        }
+
+        /// <summary>
+        /// Gets the HTTP status code that was returned by the service.
+        /// </summary>
+        /// <value>The HTTP status code.</value>
+        public HttpStatusCode StatusCode { get; private set; }
+
+        /// <summary>
+        /// Gets the specific error code returned by the service.
+        /// </summary>
+        /// <value>The storage error code.</value>
+        public StorageErrorCode ErrorCode { get; private set; }
+
+        /// <summary>
+        /// Gets the extended error information returned by the service.
+        /// </summary>
+        /// <value>The extended error information.</value>
+        public StorageExtendedErrorInformation ExtendedErrorInformation { get; private set; }
+
+        /// <summary>
+        /// Sets the <see cref="SerializationInfo"/> object with additional exception information.
+        /// </summary>
+        /// <param name="info">The object that contains serialized data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> object that contains contextual information
+        /// about the source or destination.</param>
+        [SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter = true)]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            if (null == info)
+            {
+                throw new ArgumentNullException("info");
+            }
+
+            info.AddValue("StatusCode", this.StatusCode);
+            info.AddValue("ErrorCode", this.ErrorCode);
+            info.AddValue("ExtendedErrorInformation", this.ExtendedErrorInformation);
+            base.GetObjectData(info, context);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/StorageExceptionExtensions.cs b/microsoft-azure-api/StorageClient/StorageExceptionExtensions.cs
new file mode 100644
index 0000000000000..b201e0f1bb09f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StorageExceptionExtensions.cs
@@ -0,0 +1,50 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageExceptionExtensions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageExceptionExtensions.cs class.
+// </summary>
+//-----------------------------------------------------------------------
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Net;
+
+    /// <summary>
+    ///  Provides a set of extensions for translating Exceptions into StorageExceptions.
+    /// </summary>
+    public static class StorageExceptionExtensions
+    {
+        /// <summary>
+        /// Translates a WebException into the corresponding StorageException.
+        /// </summary>
+        /// <param name="exceptionRef">The exception to translate.</param>
+        /// <returns>The translated exception.</returns>
+        public static StorageException TranslateWebException(this WebException exceptionRef)
+        {
+            return Utilities.TranslateWebException(exceptionRef) as StorageException;
+        }
+
+        /// <summary>
+        ///  Translates the data service client exception.
+        /// </summary>
+        /// <param name="exceptionRef">The exception to translate.</param>
+        /// <returns>The translated exception.</returns>
+        public static StorageException TranslateDataServiceClientException(this InvalidOperationException exceptionRef)
+        {
+            return Utilities.TranslateDataServiceClientException(exceptionRef) as StorageException;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/StorageExtendedErrorInformation.cs b/microsoft-azure-api/StorageClient/StorageExtendedErrorInformation.cs
new file mode 100644
index 0000000000000..41b0f3e026e0d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StorageExtendedErrorInformation.cs
@@ -0,0 +1,50 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageExtendedErrorInformation.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageExtendedErrorInformation class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+
+    /// <summary>
+    /// Represents extended error information returned by the Windows Azure storage services.
+    /// </summary>
+    [Serializable]
+    public class StorageExtendedErrorInformation
+    {
+        /// <summary>
+        /// Gets the storage service error code.
+        /// </summary>
+        /// <value>The storage service error code.</value>
+        public string ErrorCode { get; internal set; }
+
+        /// <summary>
+        /// Gets the storage service error message.
+        /// </summary>
+        /// <value>The storage service error message.</value>
+        public string ErrorMessage { get; internal set; }
+
+        /// <summary>
+        /// Gets additional error details.
+        /// </summary>
+        /// <value>The additional error details.</value>
+        public NameValueCollection AdditionalDetails { get; internal set; }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/StorageServerException.cs b/microsoft-azure-api/StorageClient/StorageServerException.cs
new file mode 100644
index 0000000000000..acda07c2e61b0
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StorageServerException.cs
@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageServerException.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageServerException class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Net;
+    using System.Runtime.Serialization;
+
+    /// <summary>
+    /// Represents an exception thrown due to a server-side error.
+    /// </summary>
+    [SuppressMessage(
+        "Microsoft.Design",
+        "CA1032:ImplementStandardExceptionConstructors",
+        Justification = "Since this exception comes from the server, there must be an HTTP response code associated with it," +
+            "hence we exclude the default constructor taking only a string but no status code.")]
+    [Serializable]
+    public class StorageServerException : StorageException
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageServerException"/> class.
+        /// </summary>
+        public StorageServerException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageServerException"/> class.
+        /// </summary>
+        /// <param name="errorCode">The storage client error code.</param>
+        /// <param name="message">The message that describes the exception.</param>
+        /// <param name="statusCode">The HTTP status code returned in the response.</param>
+        /// <param name="innerException">The <see cref="Exception"/> instance that caused the current exception.</param>
+        internal StorageServerException(
+            StorageErrorCode errorCode,
+            string message,
+            HttpStatusCode statusCode,
+            Exception innerException)
+            : base(errorCode, message, statusCode, null, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageServerException"/> class.
+        /// </summary>
+        /// <param name="errorCode">The storage client error code.</param>
+        /// <param name="message">The message that describes the exception.</param>
+        /// <param name="statusCode">The HTTP status code returned in the response.</param>
+        /// <param name="extendedErrorInfo">The extended error information.</param>
+        /// <param name="innerException">The <see cref="Exception"/> instance that caused the current exception.</param>
+        internal StorageServerException(
+            StorageErrorCode errorCode,
+            string message,
+            HttpStatusCode statusCode,
+            StorageExtendedErrorInformation extendedErrorInfo,
+            Exception innerException)
+            : base(errorCode, message, statusCode, extendedErrorInfo, innerException)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageServerException"/> class with
+        /// serialized data.
+        /// </summary>
+        /// <param name="info">The object that contains serialized data about the exception being thrown.</param>
+        /// <param name="context">The <see cref="StreamingContext"/> object that contains contextual information
+        /// about the source or destination.</param>
+        protected StorageServerException(SerializationInfo info, StreamingContext context)
+            : base(info, context)
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/StreamUtilities.cs b/microsoft-azure-api/StorageClient/StreamUtilities.cs
new file mode 100644
index 0000000000000..ff679552dfb4f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/StreamUtilities.cs
@@ -0,0 +1,89 @@
+//-----------------------------------------------------------------------
+// <copyright file="StreamUtilities.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StreamUtilities class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Security.Cryptography;
+
+    /// <summary>
+    /// A class containing common functionality across the two blob streams.
+    /// </summary>
+    internal static class StreamUtilities
+    {
+        /// <summary>
+        /// Verifies the parameters to a read/write operation.
+        /// </summary>
+        /// <param name="buffer">An array of bytes.</param>
+        /// <param name="offset">The zero-based byte offset in <paramref name="buffer"/>.</param>
+        /// <param name="count">The maximum number of bytes to be access in <paramref name="buffer"/>.</param>        /// <exception cref="System.ArgumentException">The sum of offset and count is greater than the buffer length.</exception>
+        /// <exception cref="System.ArgumentNullException"><paramref name="buffer"/> is null.</exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">offset or count is negative.</exception>
+        internal static void CheckBufferArguments(byte[] buffer, int offset, int count)
+        {
+            if (buffer == null)
+            {
+                throw new ArgumentNullException("buffer");
+            }
+
+            if (offset < 0)
+            {
+                throw new ArgumentOutOfRangeException("offset", "Offset must be positive");
+            }
+
+            if (count < 0)
+            {
+                throw new ArgumentOutOfRangeException("count", "Count must be positive");
+            }
+
+            if ((buffer.Length - offset) < count)
+            {
+                throw new ArgumentException("Offset subtracted from the buffer length is less than count", "offset");
+            }   
+        }
+
+        /// <summary>
+        /// Calculates an ongoing hash.
+        /// </summary>
+        /// <param name="input">The data to calculate the hash on.</param>
+        /// <param name="offset">The offset in the input buffer to calculate from.</param>
+        /// <param name="count">The number of bytes to use from input.</param>
+        /// <param name="hash">The hash algorithm to use.</param>
+        internal static void ComputeHash(byte[] input, int offset, int count, HashAlgorithm hash)
+        {
+            hash.TransformBlock(input, offset, count, null, 0);
+        }
+
+        /// <summary>
+        /// Retrieves the string representation of the hash. (Completes the creation of the hash).
+        /// </summary>
+        /// <param name="hash">The hashing object.</param>
+        /// <returns>A string that is the content of the hash.</returns>
+        internal static string GetHashValue(HashAlgorithm hash)
+        {
+            // Finalize the hash
+            hash.TransformFinalBlock(new byte[0], 0, 0);
+            var bytes = hash.Hash;
+
+            // Convert hash to string
+            return Convert.ToBase64String(bytes);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/TableErrorCodeStrings.cs b/microsoft-azure-api/StorageClient/TableErrorCodeStrings.cs
new file mode 100644
index 0000000000000..e8648ea0a490c
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TableErrorCodeStrings.cs
@@ -0,0 +1,178 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableErrorCodeStrings.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableErrorCodeStrings class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    /// <summary>
+    /// Provides error code strings that are specific to the Windows Azure Table service.
+    /// </summary>
+    public static class TableErrorCodeStrings
+    {
+        /// <summary>
+        /// The request uses X-HTTP-Method with an HTTP verb other than POST.
+        /// </summary>
+        public const string XMethodNotUsingPost = "XMethodNotUsingPost";
+
+        /// <summary>
+        /// The specified X-HTTP-Method is invalid.
+        /// </summary>
+        public const string XMethodIncorrectValue = "XMethodIncorrectValue";
+
+        /// <summary>
+        /// More than one X-HTTP-Method is specified.
+        /// </summary>
+        public const string XMethodIncorrectCount = "XMethodIncorrectCount";
+
+        /// <summary>
+        /// The specified table has no properties.
+        /// </summary>
+        public const string TableHasNoProperties = "TableHasNoProperties";
+
+        /// <summary>
+        /// A property is specified more than once.
+        /// </summary>
+        public const string DuplicatePropertiesSpecified = "DuplicatePropertiesSpecified";
+
+        /// <summary>
+        /// The specified table has no such property.
+        /// </summary>
+        public const string TableHasNoSuchProperty = "TableHasNoSuchProperty";
+
+        /// <summary>
+        /// A duplicate key property was specified.
+        /// </summary>
+        public const string DuplicateKeyPropertySpecified = "DuplicateKeyPropertySpecified";
+
+        /// <summary>
+        /// The specified table already exists.
+        /// </summary>
+        public const string TableAlreadyExists = "TableAlreadyExists";
+
+        /// <summary>
+        /// The specified table was not found.
+        /// </summary>
+        public const string TableNotFound = "TableNotFound";
+
+        /// <summary>
+        /// The specified entity was not found.
+        /// </summary>
+        public const string EntityNotFound = "EntityNotFound";
+
+        /// <summary>
+        /// The specified entity already exists.
+        /// </summary>
+        public const string EntityAlreadyExists = "EntityAlreadyExists";
+
+        /// <summary>
+        /// The partition key was not specified.
+        /// </summary>
+        public const string PartitionKeyNotSpecified = "PartitionKeyNotSpecified";
+
+        /// <summary>
+        /// One or more specified operators are invalid.
+        /// </summary>
+        public const string OperatorInvalid = "OperatorInvalid";
+
+        /// <summary>
+        /// The specified update condition was not satsified.
+        /// </summary>
+        public const string UpdateConditionNotSatisfied = "UpdateConditionNotSatisfied";
+
+        /// <summary>
+        /// All properties must have values.
+        /// </summary>
+        public const string PropertiesNeedValue = "PropertiesNeedValue";
+
+        /// <summary>
+        /// The partition key property cannot be updated.
+        /// </summary>
+        public const string PartitionKeyPropertyCannotBeUpdated = "PartitionKeyPropertyCannotBeUpdated";
+
+        /// <summary>
+        /// The entity contains more properties than allowed.
+        /// </summary>
+        public const string TooManyProperties = "TooManyProperties";
+
+        /// <summary>
+        /// The entity is larger than the maximum size permitted.
+        /// </summary>
+        public const string EntityTooLarge = "EntityTooLarge";
+
+        /// <summary>
+        /// The property value is larger than the maximum size permitted.
+        /// </summary>
+        public const string PropertyValueTooLarge = "PropertyValueTooLarge";
+
+        /// <summary>
+        /// One or more value types are invalid.
+        /// </summary>
+        public const string InvalidValueType = "InvalidValueType";
+
+        /// <summary>
+        /// The specified table is being deleted.
+        /// </summary>
+        public const string TableBeingDeleted = "TableBeingDeleted";
+
+        /// <summary>
+        /// The Table service server is out of memory.
+        /// </summary>
+        public const string TableServerOutOfMemory = "TableServerOutOfMemory";
+
+        /// <summary>
+        /// The type of the primary key property is invalid.
+        /// </summary>
+        public const string PrimaryKeyPropertyIsInvalidType = "PrimaryKeyPropertyIsInvalidType";
+
+        /// <summary>
+        /// The property name exceeds the maximum allowed length.
+        /// </summary>
+        public const string PropertyNameTooLong = "PropertyNameTooLong";
+
+        /// <summary>
+        /// The property name is invalid.
+        /// </summary>
+        public const string PropertyNameInvalid = "PropertyNameInvalid";
+
+        /// <summary>
+        /// Batch operations are not supported for this operation type.
+        /// </summary>
+        public const string BatchOperationNotSupported = "BatchOperationNotSupported";
+
+        /// <summary>
+        /// JSON format is not supported.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Naming",
+            "CA1704:IdentifiersShouldBeSpelledCorrectly",
+            MessageId = "Json",
+            Justification = "The casing matches the storage constant the identifier represents.")]
+        public const string JsonFormatNotSupported = "JsonFormatNotSupported";
+
+        /// <summary>
+        /// The specified method is not allowed.
+        /// </summary>
+        public const string MethodNotAllowed = "MethodNotAllowed";
+
+        /// <summary>
+        /// The specified operation is not yet implemented.
+        /// </summary>
+        public const string NotImplemented = "NotImplemented";
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/TableServiceContext.cs b/microsoft-azure-api/StorageClient/TableServiceContext.cs
new file mode 100644
index 0000000000000..6edd5a63301aa
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TableServiceContext.cs
@@ -0,0 +1,171 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableServiceContext.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableServiceContext class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Data.Services.Client;
+    using System.Net;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Represents a <see cref="DataServiceContext"/> object for use with the Windows Azure Table service.
+    /// </summary>
+    public class TableServiceContext : DataServiceContext
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TableServiceContext"/> class.
+        /// </summary>
+        /// <param name="baseAddress">The Table service endpoint to use create the service context.</param>
+        /// <param name="credentials">The account credentials.</param>
+        public TableServiceContext(string baseAddress, StorageCredentials credentials)
+            : base(new Uri(baseAddress))
+        {
+            if (string.IsNullOrEmpty(baseAddress))
+            {
+                throw new ArgumentNullException("baseAddress");
+            }
+
+            if (credentials == null)
+            {
+                throw new ArgumentNullException("credentials");
+            }
+
+            if ((!credentials.CanSignRequest) || (!credentials.CanSignRequestLite))
+            {
+                throw new ArgumentException(SR.CredentialsCantSignRequest, "credentials");
+            }
+
+            SendingRequest += new EventHandler<SendingRequestEventArgs>(this.DataContextSendingRequest);
+
+            StorageCredentials = credentials;
+            IgnoreMissingProperties = true;
+            MergeOption = MergeOption.PreserveChanges;
+
+            RetryPolicy = RetryPolicies.RetryExponential(RetryPolicies.DefaultClientRetryCount, RetryPolicies.DefaultClientBackoff);
+            Timeout = (int)TimeSpan.FromSeconds(90).TotalSeconds;
+        }
+
+        /// <summary>
+        /// Gets or sets the retry policy requests made via the service context.
+        /// </summary>
+        /// <value>The retry policy.</value>
+        public RetryPolicy RetryPolicy { get; set; }
+
+        /// <summary>
+        /// Gets the storage account credentials used by the service context.
+        /// </summary>
+        /// <value>The account credentials.</value>
+        public StorageCredentials StorageCredentials { get; private set; }
+
+        /// <summary>
+        /// Begins an asynchronous operation to save changes, using the retry policy specified for the service context.
+        /// </summary>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSaveChangesWithRetries(AsyncCallback callback, object state)
+        {
+            return this.BeginSaveChangesWithRetries(this.SaveChangesDefaultOptions, callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous operation to save changes, using the retry policy specified for the service context.
+        /// </summary>
+        /// <param name="options">Additional options for saving changes.</param>
+        /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param>
+        /// <param name="state">A user-defined object that will be passed to the callback delegate.</param>
+        /// <returns>An <see cref="IAsyncResult"/> that references the asynchronous operation.</returns>
+        public IAsyncResult BeginSaveChangesWithRetries(SaveChangesOptions options, AsyncCallback callback, object state)
+        {
+            return TaskImplHelper.BeginImplWithRetry<DataServiceResponse>(
+                (setResult) => this.SaveChangesWithRetriesImpl(options, setResult),
+                RetryPolicy,
+                callback,
+                state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous operation to save changes.
+        /// </summary>
+        /// <param name="asyncResult">An <see cref="IAsyncResult"/> that references the pending asynchronous operation.</param>
+        /// <returns> A <see cref="DataServiceResponse"/> that represents the result of the operation.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is a member-operation")]
+        public DataServiceResponse EndSaveChangesWithRetries(IAsyncResult asyncResult)
+        {
+            return TaskImplHelper.EndImplWithRetry<DataServiceResponse>(asyncResult);
+        }
+
+        /// <summary>
+        /// Saves changes, using the retry policy specified for the service context.
+        /// </summary>
+        /// <returns>A <see cref="DataServiceResponse"/> that represents the result of the operation.</returns>
+        public DataServiceResponse SaveChangesWithRetries()
+        {
+            return this.SaveChangesWithRetries(this.SaveChangesDefaultOptions);
+        }
+
+        /// <summary>
+        /// Saves changes, using the retry policy specified for the service context.
+        /// </summary>
+        /// <param name="options">Additional options for saving changes.</param>
+        /// <returns> A <see cref="DataServiceResponse"/> that represents the result of the operation.</returns>
+        public DataServiceResponse SaveChangesWithRetries(SaveChangesOptions options)
+        {
+            return TaskImplHelper.ExecuteImplWithRetry<DataServiceResponse>(
+                (setResult) => this.SaveChangesWithRetriesImpl(options, setResult),
+                RetryPolicy);
+        }
+
+        /// <summary>
+        /// Saves the changes with retries implementation.
+        /// </summary>
+        /// <param name="options">The options for saving changes.</param>
+        /// <param name="setResult">The action to set result.</param>
+        /// <returns>A sequence of tasks to perform the operation.</returns>
+        private TaskSequence SaveChangesWithRetriesImpl(SaveChangesOptions options, Action<DataServiceResponse> setResult)
+        {
+            var task = this.SaveChangesAsync(options);
+
+            yield return task;
+
+            setResult(task.Result);
+        }
+
+        /// <summary>
+        /// Callback on DataContext object sending request.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The <see cref="System.Data.Services.Client.SendingRequestEventArgs"/> instance containing the event data.</param>
+        private void DataContextSendingRequest(object sender, SendingRequestEventArgs e)
+        {
+            HttpWebRequest request = e.Request as HttpWebRequest;
+
+            request.Headers.Add(
+                Protocol.Constants.HeaderConstants.StorageVersionHeader,
+                Protocol.Request.GetTargetVersion());
+
+            StorageCredentials.SignRequestLite(request);
+
+            CommonUtils.ApplyRequestOptimizations(request, -1);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/TableServiceEntity.cs b/microsoft-azure-api/StorageClient/TableServiceEntity.cs
new file mode 100644
index 0000000000000..037dff361fef8
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TableServiceEntity.cs
@@ -0,0 +1,81 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableServiceEntity.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableServiceEntity class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Data.Services.Common;
+
+    /// <summary>
+    /// Represents an entity in the Windows Azure Table service.
+    /// </summary>
+    [CLSCompliant(false)]
+    [DataServiceKey("PartitionKey", "RowKey")]
+    public abstract class TableServiceEntity
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TableServiceEntity"/> class.
+        /// </summary>
+        /// <param name="partitionKey">The partition key.</param>
+        /// <param name="rowKey">The row key.</param>
+        protected TableServiceEntity(string partitionKey, string rowKey)
+        {
+            this.PartitionKey = partitionKey;
+            this.RowKey = rowKey;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TableServiceEntity"/> class.
+        /// </summary>
+        protected TableServiceEntity()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the timestamp for the entity.
+        /// </summary>
+        /// <value>The entity's timestamp.</value>
+        public DateTime Timestamp
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the partition key of a table entity.
+        /// </summary>
+        /// <value>The partition key.</value>
+        public virtual string PartitionKey
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Gets or sets the row key of a table entity.
+        /// </summary>
+        /// <value>The row key.</value>
+        public virtual string RowKey
+        {
+            get;
+            set;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/TableServiceExtensionMethods.cs b/microsoft-azure-api/StorageClient/TableServiceExtensionMethods.cs
new file mode 100644
index 0000000000000..ace43e945be87
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TableServiceExtensionMethods.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableServiceExtensionMethods.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableServiceExtensionMethods class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System.Data.Services.Client;
+    using System.Linq;
+
+    /// <summary>
+    /// Provides a set of extensions for the Table service.
+    /// </summary>
+    public static class TableServiceExtensionMethods
+    {
+        /// <summary>
+        /// Converts the query into a <see cref="CloudTableQuery&lt;TElement&gt;"/> object that supports 
+        /// additional operations like retries.
+        /// </summary>
+        /// <typeparam name="TElement">The type of the element.</typeparam>
+        /// <param name="query">The query.</param>
+        /// <returns>The converted query.</returns>
+        public static CloudTableQuery<TElement> AsTableServiceQuery<TElement>(this IQueryable<TElement> query)
+        {
+            return new CloudTableQuery<TElement>(query as DataServiceQuery<TElement>);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/TableServiceTable.cs b/microsoft-azure-api/StorageClient/TableServiceTable.cs
new file mode 100644
index 0000000000000..cc0d94656d51b
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TableServiceTable.cs
@@ -0,0 +1,110 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableServiceTable.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableServiceTable class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Data.Services.Common;
+
+    /// <summary>
+    /// Internal table service entity for creating tables.
+    /// </summary>
+    [DataServiceKey("TableName")]
+    internal class TableServiceTable
+    {
+        /// <summary>
+        /// Stores the table name.
+        /// </summary>
+        private string tableName;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TableServiceTable"/> class.
+        /// </summary>
+        public TableServiceTable()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TableServiceTable"/> class with the specified name.
+        /// </summary>
+        /// <param name="name">The name of the table.</param>
+        public TableServiceTable(string name)
+        {
+            CommonUtils.CheckStringParameter(name, false, "name", Protocol.Constants.TableServiceMaxStringPropertySizeInChars);
+            this.TableName = name;
+        }
+
+        /// <summary>
+        /// Gets or sets the table name.
+        /// </summary>
+        /// <value>The name of the table.</value>
+        public string TableName
+        {
+            get
+            {
+                return this.tableName;
+            }
+
+            set
+            {
+                CommonUtils.CheckStringParameter(value, false, "TableName", Protocol.Constants.TableServiceMaxStringPropertySizeInChars);
+                this.tableName = value;
+            }
+        }
+
+        /// <summary>
+        /// Determines whether the specified <see cref="System.Object"/> is equal to this instance.
+        /// </summary>
+        /// <param name="obj">The <see cref="System.Object"/> to compare with this instance.</param>
+        /// <returns>
+        /// Returns <c>true</c> if the specified <see cref="System.Object"/> is equal to this instance; otherwise, <c>false</c>.
+        /// </returns>
+        /// <exception cref="T:System.NullReferenceException">
+        /// The <paramref name="obj"/> parameter is null.
+        /// </exception>
+        public override bool Equals(object obj)
+        {
+            if (obj == null)
+            {
+                return false;
+            }
+
+            TableServiceTable rhs = obj as TableServiceTable;
+
+            if (rhs == null)
+            {
+                return false;
+            }
+
+            return this.TableName.Equals(rhs.TableName, StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        /// <summary>
+        /// Returns a hash code for this instance.
+        /// </summary>
+        /// <returns>
+        /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
+        /// </returns>
+        public override int GetHashCode()
+        {
+            return this.TableName.GetHashCode();
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/TableServiceUtilities.cs b/microsoft-azure-api/StorageClient/TableServiceUtilities.cs
new file mode 100644
index 0000000000000..1c4c2e26c9258
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TableServiceUtilities.cs
@@ -0,0 +1,144 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableServiceUtilities.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableServiceUtilities class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Data.Services.Common;
+    using System.Diagnostics;
+    using System.Linq;
+    using System.Reflection;
+    using System.Text.RegularExpressions;
+
+    /// <summary>
+    /// Helper functions for table service.
+    /// </summary>
+    internal static class TableServiceUtilities
+    {
+        /// <summary>
+        /// Determines whether the type is an entity type.
+        /// </summary>
+        /// <param name="t">The type to check.</param>
+        /// <param name="contextType">Type of the context.</param>
+        /// <returns>
+        /// Returns <c>true</c> if the type is an entity type; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsEntityType(Type t, Type contextType)
+        {
+            // ADO.NET data services convention: a type 't' is an entity if
+            // 1) 't' has at least one key column
+            // 2) there is a top level IQueryable<T> property in the context where T is 't' or a supertype of 't'
+            // Non-primitive types that are not entity types become nested structures ("complex types" in EDM)
+            if (!t.GetProperties().Any(p => IsKeyColumn(p)))
+            {
+                return false;
+            }
+
+            foreach (PropertyInfo pi in contextType.GetProperties())
+            {
+                if (typeof(IQueryable).IsAssignableFrom(pi.PropertyType))
+                {
+                    if (pi.PropertyType.GetGenericArguments()[0].IsAssignableFrom(t))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Determines whether the specified property is a key column.
+        /// </summary>
+        /// <param name="pi">The property.</param>
+        /// <returns>
+        /// Returns <c>true</c> if the specified property is a key column; otherwise, <c>false</c>.
+        /// </returns>
+        public static bool IsKeyColumn(PropertyInfo pi)
+        {
+            // Astoria convention:
+            // 1) try the DataServiceKey attribute
+            // 2) if not attribute, try <typename>ID
+            // 3) finally, try just ID
+            object[] attribs = pi.DeclaringType.GetCustomAttributes(typeof(DataServiceKeyAttribute), true);
+            if (attribs != null && attribs.Length > 0)
+            {
+                Debug.Assert(attribs.Length == 1, "There must only be one attribute.");
+
+                return ((DataServiceKeyAttribute)attribs[0]).KeyNames.Contains(pi.Name);
+            }
+
+            if (pi.Name.Equals(pi.DeclaringType.Name + "ID", System.StringComparison.OrdinalIgnoreCase))
+            {
+                return true;
+            }
+
+            if (pi.Name == "ID")
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Enumerates the entity set properties.
+        /// </summary>
+        /// <param name="contextType">Type of the context.</param>
+        /// <returns>A list of the entity set properties.</returns>
+        public static IEnumerable<PropertyInfo> EnumerateEntitySetProperties(Type contextType)
+        {
+            foreach (PropertyInfo prop in contextType.GetProperties())
+            {
+                if (typeof(IQueryable).IsAssignableFrom(prop.PropertyType) &&
+                    prop.PropertyType.GetGenericArguments().Length > 0 &&
+                    IsEntityType(prop.PropertyType.GetGenericArguments()[0], contextType))
+                {
+                    yield return prop;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Enumerates the entity set names.
+        /// </summary>
+        /// <param name="contextType">Type of the context.</param>
+        /// <returns>A list of entity set names.</returns>
+        public static IEnumerable<string> EnumerateEntitySetNames(Type contextType)
+        {
+            return EnumerateEntitySetProperties(contextType).Select(p => p.Name);
+        }
+
+        /// <summary>
+        /// Checks the name of the table.
+        /// </summary>
+        /// <param name="tableName">The table name.</param>
+        /// <param name="argName">Name of the arg.</param>
+        public static void CheckTableName(string tableName, string argName)
+        {
+            if (string.IsNullOrEmpty(tableName))
+            {
+                throw new ArgumentException(String.Format(SR.TableNameInvalid, tableName), argName);
+            }
+        }        
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/TaskImplHelper.cs b/microsoft-azure-api/StorageClient/TaskImplHelper.cs
new file mode 100644
index 0000000000000..38f257170b497
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TaskImplHelper.cs
@@ -0,0 +1,310 @@
+//-----------------------------------------------------------------------
+// <copyright file="TaskImplHelper.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TaskImplHelper.cs class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Diagnostics;
+    using Tasks;
+    using TaskSequence = System.Collections.Generic.IEnumerable<Microsoft.WindowsAzure.StorageClient.Tasks.ITask>;
+
+    /// <summary>
+    /// Implementation helper for task sequences.
+    /// </summary>
+    internal static class TaskImplHelper
+    {
+        /// <summary>
+        /// Executes the impl.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="impl">The task implementation.</param>
+        /// <returns>The result of the task.</returns>
+        [DebuggerNonUserCode]
+        internal static T ExecuteImpl<T>(Func<Action<T>, TaskSequence> impl)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+
+            var invokerTask = new InvokeTaskSequenceTask<T>(impl);
+            return invokerTask.ExecuteAndWait();
+        }
+
+        /// <summary>
+        /// Begins the impl.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="callback">The callback.</param>
+        /// <param name="state">The state.</param>
+        /// <returns>An asynchronous result representing the operation.</returns>
+        [DebuggerNonUserCode]
+        internal static IAsyncResult BeginImpl<T>(Func<Action<T>, TaskSequence> impl, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            
+            var invokerTask = new InvokeTaskSequenceTask<T>(impl);
+            return invokerTask.ToAsyncResult(callback, state);
+        }
+
+        /// <summary>
+        /// Ends the impl.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="asyncResult">The async result.</param>
+        /// <returns>The task result.</returns>
+        [DebuggerNonUserCode]
+        internal static T EndImpl<T>(IAsyncResult asyncResult)
+        {
+            TaskAsyncResult<T> task = GetTaskFromAsyncResult<T>(asyncResult);
+            var result = task.EndInvoke();
+            task.Dispose();
+            return result;
+        }
+
+        /// <summary>
+        /// Executes the impl.
+        /// </summary>
+        /// <param name="impl">The task implemenetaion.</param>
+        [DebuggerNonUserCode]
+        internal static void ExecuteImpl(Func<TaskSequence> impl)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            
+            InvokeTaskSequenceTask invokerTask = new InvokeTaskSequenceTask(impl);
+            invokerTask.ExecuteAndWait();
+        }
+
+        /// <summary>
+        /// Begins the impl.
+        /// </summary>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="callback">The callback.</param>
+        /// <param name="state">The state.</param>
+        /// <returns>An asynchronous result representing the operation.</returns>
+        [DebuggerNonUserCode]
+        internal static IAsyncResult BeginImpl(Func<TaskSequence> impl, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            
+            var invokerTask = new InvokeTaskSequenceTask(impl);
+            return invokerTask.ToAsyncResult(callback, state);
+        }
+
+        /// <summary>
+        /// Ends the impl.
+        /// </summary>
+        /// <param name="asyncResult">The async result.</param>
+        [DebuggerNonUserCode]
+        internal static void EndImpl(IAsyncResult asyncResult)
+        {
+            TaskAsyncResult<NullTaskReturn> task = GetTaskFromAsyncResult<NullTaskReturn>(asyncResult);
+            task.EndInvoke();
+            task.Dispose();
+        }
+
+        /// <summary>
+        /// Executes the impl with retry.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="policy">The policy.</param>
+        /// <returns>The task result.</returns>
+        [DebuggerNonUserCode]
+        internal static T ExecuteImplWithRetry<T>(Func<Action<T>, TaskSequence> impl, RetryPolicy policy)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            CommonUtils.AssertNotNull("policy", policy);
+            
+            var retryableTask = GetRetryableAsyncTask(impl, policy);
+            return retryableTask.ExecuteAndWait();
+        }
+
+        /// <summary>
+        /// Begins the impl with retry.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="policy">The policy.</param>
+        /// <param name="callback">The callback.</param>
+        /// <param name="state">The state.</param>
+        /// <returns>An asynchronous result representing the operation.</returns>
+        [DebuggerNonUserCode]
+        internal static IAsyncResult BeginImplWithRetry<T>(Func<Action<T>, TaskSequence> impl, RetryPolicy policy, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            CommonUtils.AssertNotNull("policy", policy);
+            
+            var retryableTask = GetRetryableAsyncTask(impl, policy);
+            return retryableTask.ToAsyncResult(callback, state);
+        }
+
+        /// <summary>
+        /// Ends the impl with retry.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="asyncResult">The async result.</param>
+        /// <returns>The task result.</returns>
+        [DebuggerNonUserCode]
+        internal static T EndImplWithRetry<T>(IAsyncResult asyncResult)
+        {
+            return EndImpl<T>(asyncResult);
+        }
+
+        /// <summary>
+        /// Executes the impl with retry.
+        /// </summary>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="policy">The policy.</param>
+        [DebuggerNonUserCode]
+        internal static void ExecuteImplWithRetry(Func<TaskSequence> impl, RetryPolicy policy)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            CommonUtils.AssertNotNull("policy", policy);
+            
+            var retryableTask = GetRetryableAsyncTask(impl, policy);
+            retryableTask.ExecuteAndWait();
+        }
+
+        /// <summary>
+        /// Executes the impl with retry.
+        /// </summary>
+        /// <typeparam name="TResult">The result type.</typeparam>
+        /// <param name="syncTask">The task implementation.</param>
+        /// <returns>The task result.</returns>
+        [DebuggerNonUserCode]
+        internal static TResult ExecuteSyncTask<TResult>(SynchronousTask<TResult> syncTask)
+        {
+            CommonUtils.AssertNotNull("syncTask", syncTask);
+
+            return syncTask.Execute();
+        }
+
+        /// <summary>
+        /// Executes the impl with retry.
+        /// </summary>
+        /// <typeparam name="TResult">The result type.</typeparam>
+        /// <param name="syncTask">The task implementation.</param>
+        /// <param name="policy">The policy.</param>
+        /// <returns>The task result.</returns>
+        [DebuggerNonUserCode]
+        internal static TResult ExecuteSyncTaskWithRetry<TResult>(SynchronousTask<TResult> syncTask, RetryPolicy policy)
+        {
+            CommonUtils.AssertNotNull("syncTask", syncTask);
+            CommonUtils.AssertNotNull("policy", policy);
+            var oracle = policy();
+
+            return RequestWithRetry.RequestWithRetrySyncImpl<TResult>(oracle, syncTask);
+        }
+
+        /// <summary>
+        /// Begins the impl with retry.
+        /// </summary>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="policy">The policy.</param>
+        /// <param name="callback">The callback.</param>
+        /// <param name="state">The state.</param>
+        /// <returns>An asynchronous result representing the operation.</returns>
+        [DebuggerNonUserCode]
+        internal static IAsyncResult BeginImplWithRetry(Func<TaskSequence> impl, RetryPolicy policy, AsyncCallback callback, object state)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            CommonUtils.AssertNotNull("policy", policy);
+            
+            var retryableTask = GetRetryableAsyncTask(impl, policy);
+            return retryableTask.ToAsyncResult(callback, state);
+        }
+
+        /// <summary>
+        /// Ends the impl with retry.
+        /// </summary>
+        /// <param name="asyncResult">The async result.</param>
+        [DebuggerNonUserCode]
+        internal static void EndImplWithRetry(IAsyncResult asyncResult)
+        {
+            EndImpl(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets the retryable async task.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="policy">The policy.</param>
+        /// <returns>The retryable task.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<T> GetRetryableAsyncTask<T>(Func<Action<T>, TaskSequence> impl, RetryPolicy policy)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            CommonUtils.AssertNotNull("policy", policy);
+            
+            ShouldRetry oracle = policy(); 
+
+            InvokeTaskSequenceTask<T> retryableTask = new InvokeTaskSequenceTask<T>(
+                (setResult) => RequestWithRetry.RequestWithRetryImpl<T>(oracle, impl, setResult));
+
+            return retryableTask;
+        }
+
+        /// <summary>
+        /// Gets the retryable async task.
+        /// </summary>
+        /// <param name="impl">The task implementation.</param>
+        /// <param name="policy">The policy.</param>
+        /// <returns>The retryable task.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<NullTaskReturn> GetRetryableAsyncTask(Func<TaskSequence> impl, RetryPolicy policy)
+        {
+            CommonUtils.AssertNotNull("impl", impl);
+            CommonUtils.AssertNotNull("policy", policy);
+            
+            ShouldRetry oracle = policy();
+
+            InvokeTaskSequenceTask retryableTask = new InvokeTaskSequenceTask(
+                () => RequestWithRetry.RequestWithRetryImpl<NullTaskReturn>(
+                    oracle,
+                    (setResult) => impl(),
+                    (scratch) =>
+                        {
+                        }));
+
+            return retryableTask;
+        }
+
+        /// <summary>
+        /// Gets the task from async result.
+        /// </summary>
+        /// <typeparam name="T">The type of the result.</typeparam>
+        /// <param name="asyncResult">The async result.</param>
+        /// <returns>The asynchronous result.</returns>
+        [DebuggerNonUserCode]
+        private static TaskAsyncResult<T> GetTaskFromAsyncResult<T>(IAsyncResult asyncResult)
+        {
+            CommonUtils.AssertNotNull("asyncResult", asyncResult);
+
+            var task = asyncResult as TaskAsyncResult<T>;
+
+            if (task == null)
+            {
+                throw new ArgumentException("invalid asyncresult");
+            }
+
+            return task;
+        } 
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/APMTask.cs b/microsoft-azure-api/StorageClient/Tasks/APMTask.cs
new file mode 100644
index 0000000000000..b0a0aef5acbed
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/APMTask.cs
@@ -0,0 +1,175 @@
+//-----------------------------------------------------------------------
+// <copyright file="APMTask.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the APMTask and APMTask[T] classes.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+
+    /// <summary>
+    /// A task that implements the conventional BeginXX(), EndXX() pattern.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a generic class with the same name.")]
+    internal class APMTask : APMTask<NullTaskReturn>
+    {
+        /// <summary>
+        /// Initializes a new instance of the APMTask class for sequence without any return value.
+        /// </summary>
+        /// <param name="begin">The APM function to begin operation.</param>
+        /// <param name="end">The APM functon to end the operation.</param>
+        public APMTask(Func<AsyncCallback, object, IAsyncResult> begin, Action<IAsyncResult> end) :
+            base(
+                begin,
+                (asyncResult) =>
+                    {
+                        end(asyncResult);
+                        return NullTaskReturn.Value;
+                    })
+        {
+        }
+    }
+
+    /// <summary>
+    /// A task that implements the conventional BeginXX(), EndXX() pattern.
+    /// </summary>
+    /// <typeparam name="T">The return type of the task.</typeparam>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a non-generic specialization with the same name.")]
+    internal class APMTask<T> : Task<T>
+    {
+        /// <summary>
+        /// Initializes a new instance of the APMTask class for use with normal APM.
+        /// </summary>
+        /// <param name="begin">The APM function to begin operation.</param>
+        /// <param name="end">The APM functon to end the operation.</param>
+        [DebuggerNonUserCode]
+        public APMTask(Func<AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, T> end)
+        {
+            this.BeginFunc = begin;
+            this.EndFunc = end;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the APMTask class for use with normal APM.
+        /// </summary>
+        /// <param name="begin">The APM function to begin operation.</param>
+        /// <param name="end">The APM functon to end the operation.</param>
+        /// <param name="abort">The function used for aborting an operation.</param>
+        [DebuggerNonUserCode]
+        public APMTask(Func<AsyncCallback, object, IAsyncResult> begin, Func<IAsyncResult, T> end, Action abort)
+        {
+            this.BeginFunc = begin;
+            this.EndFunc = end;
+            this.AbortFunc = abort;
+        }
+
+        /// <summary>
+        /// Gets or sets the begin function.
+        /// </summary>
+        /// <value>The begin func.</value>
+        public Func<AsyncCallback, object, IAsyncResult> BeginFunc { get; set; }
+
+        /// <summary>
+        /// Gets or sets the end function.
+        /// </summary>
+        /// <value>The end func.</value>
+        public Func<IAsyncResult, T> EndFunc { get; set; }
+
+        /// <summary>
+        /// Gets or sets the abort function.
+        /// </summary>
+        /// <value>The abort func.</value>
+        public Action AbortFunc { get; set; }
+        
+        /// <summary>
+        /// Implementation of the library execution. Performs the APM operation.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "The exception is logged.")]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Anvil.<Leak!Disposable>",
+            "<1037>",
+            Justification = "IAsyncResult is not neccesarily disposable as it is retrieved from any Func<IAsyncResult>, will go out of scope.")]
+        [DebuggerNonUserCode]
+        protected override void ExecuteInternal()
+        {
+            IAsyncResult ar;
+            try
+            {
+                ar = this.BeginFunc(this.OnEnd, null);
+
+                if (ar.CompletedSynchronously)
+                {
+                    this.Complete(true);
+                }
+            }
+            catch (Exception ex)
+            {
+                this.Exception = ex;
+                this.Complete(true);
+            }
+        }
+
+        /// <summary>
+        /// Implements the abort functionality.
+        /// </summary>
+        [DebuggerNonUserCode]
+        protected override void AbortInternal()
+        {
+            if (this.AbortFunc != null)
+            {
+                this.AbortFunc();
+            }
+        }
+
+        /// <summary>
+        /// Callback for the APM function.
+        /// </summary>
+        /// <param name="ar">The async result for the APM model.</param>
+        [DebuggerNonUserCode]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "Exception is logged")]
+        private void OnEnd(IAsyncResult ar)
+        {
+            try
+            {
+                this.Result = this.EndFunc(ar);
+            }
+            catch (Exception ex)
+            {
+                this.Exception = ex;
+            }
+
+            if (!ar.CompletedSynchronously)
+            {
+                this.Complete(false);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/AsyncResultExtensions.cs b/microsoft-azure-api/StorageClient/Tasks/AsyncResultExtensions.cs
new file mode 100644
index 0000000000000..89ec65a580e65
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/AsyncResultExtensions.cs
@@ -0,0 +1,59 @@
+//-----------------------------------------------------------------------
+// <copyright file="AsyncResultExtensions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the AsyncResultExtensions class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.Threading;
+
+    /// <summary>
+    /// A class to extend a normal task.
+    /// </summary>
+    internal static class AsyncResultExtensions
+    {
+        /// <summary>
+        /// Converts a Task to an a TaskAsyncResult to allow for exposing Tasks as IAsyncResult.
+        /// </summary>
+        /// <typeparam name="T">The return type of the task.</typeparam>
+        /// <param name="async">The task to be converted.</param>
+        /// <param name="callback">The callback to be called at the end of the task.</param>
+        /// <param name="state">The callback's state.</param>
+        /// <returns>A TaskAsyncResult that implements IAsyncResult.</returns>
+        [DebuggerNonUserCode]
+        internal static IAsyncResult ToAsyncResult<T>(this Task<T> async, AsyncCallback callback, object state)
+        {
+            return new TaskAsyncResult<T>(async, callback, state);
+        }
+
+        /// <summary>
+        /// Converts a Task to an a TaskAsyncResult to allow for exposing Tasks as IAsyncResut.
+        /// </summary>
+        /// <param name="async">The task to be converted.</param>
+        /// <param name="callback">The callback to be called at the end of the task.</param>
+        /// <param name="state">The callback's state.</param>
+        /// <returns>A TaskAsyncResult that implements IAsyncResult.</returns>
+        [DebuggerNonUserCode]
+        internal static IAsyncResult ToAsyncResult(this Task<NullTaskReturn> async, AsyncCallback callback, object state)
+        {
+            return new TaskAsyncResult<NullTaskReturn>(async, callback, state);
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Tasks/DelayTask.cs b/microsoft-azure-api/StorageClient/Tasks/DelayTask.cs
new file mode 100644
index 0000000000000..3d5f4b5c30ba3
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/DelayTask.cs
@@ -0,0 +1,167 @@
+//-----------------------------------------------------------------------
+// <copyright file="DelayTask.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the DelayTask class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Threading;
+
+    /// <summary>
+    /// A task class that implements a fixed delay.
+    /// </summary>
+    internal class DelayTask : Task<NullTaskReturn>, IDisposable
+    {
+        /// <summary>
+        /// Indicates whether this object has been disposed.
+        /// </summary>
+        private bool disposed;
+
+        /// <summary>
+        /// Stores the length of the delay.
+        /// </summary>
+        private TimeSpan delayInterval;
+
+        /// <summary>
+        /// ObjectUsed to lock disposing methods and timer callbacks.
+        /// </summary>
+        private object disposingLockObject = new object();
+
+        /// <summary>
+        /// Stores the native timer used to trigger after the specified delay.
+        /// </summary>
+        private Timer timer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DelayTask"/> class.
+        /// </summary>
+        /// <param name="delayInterval">Should be between TimeSpan.Zero and TimeSpan.MaxValue.</param>
+        public DelayTask(TimeSpan delayInterval)
+        {
+            CommonUtils.AssertInBounds<TimeSpan>("delayInterval", delayInterval, TimeSpan.Zero, TimeSpan.MaxValue);
+
+            this.delayInterval = delayInterval;
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            this.Dispose(true);
+
+            // Use SupressFinalize in case a subclass
+            // of this type implements a finalizer.
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing">Set to <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!this.disposed)
+            {
+                if (disposing)
+                {
+                    lock (this.disposingLockObject)
+                    {
+                        if (this.timer != null)
+                        {
+                            this.timer.Dispose();
+                        }
+                    }
+                }
+
+                // Indicate that the instance has been disposed.
+                this.timer = null;
+                this.disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// The specific implementation of the task's step.
+        /// </summary>
+        protected override void ExecuteInternal()
+        {
+            TraceHelper.WriteLine("Executing DelayTask interval msec " + this.delayInterval);
+            if (this.delayInterval == TimeSpan.Zero)
+            {
+                // Complete synchronously
+                this.Complete(true);
+            }
+            else
+            {
+                this.BeginDelay();
+            }
+        }
+
+        /// <summary>
+        /// The task-specific abort that should be called.
+        /// </summary>
+        protected override void AbortInternal()
+        {
+            TraceHelper.WriteLine("Aborting delay " + this.delayInterval);
+
+            this.timer.Change(Timeout.Infinite, Timeout.Infinite);
+
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// Begins the delay.
+        /// </summary>
+        private void BeginDelay()
+        {
+            TraceHelper.WriteLine("Begin delay timer msec " + this.delayInterval);
+
+            this.timer = new Timer((state) => this.EndDelay());
+
+            this.timer.Change(this.delayInterval, TimeSpan.FromMilliseconds(-1));
+        }
+
+        /// <summary>
+        /// Ends the delay.
+        /// </summary>
+        private void EndDelay()
+        {
+            try
+            {
+                TraceHelper.WriteLine("End delay msec " + this.delayInterval);
+
+                lock (this.disposingLockObject)
+                {
+                    if (this.timer != null)
+                    {
+                        this.timer.Dispose();
+
+                        this.timer = null;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                this.Exception = ex;
+            }
+
+            this.Complete(false);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/ITask.cs b/microsoft-azure-api/StorageClient/Tasks/ITask.cs
new file mode 100644
index 0000000000000..a4e8910f20aaf
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/ITask.cs
@@ -0,0 +1,55 @@
+//-----------------------------------------------------------------------
+// <copyright file="ITask.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the ITask interface.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+
+    /// <summary>
+    /// An asynchronous computation.
+    /// </summary>
+    internal interface ITask
+    {
+        /// <summary>
+        /// Gets a value indicating whether the task has completed synchronously.
+        /// </summary>
+        /// <value>
+        /// Is <c>true</c> if completed synchronously; otherwise, <c>false</c>.
+        /// </value>
+        bool CompletedSynchronously { get; }
+
+        /// <summary>
+        /// Gets exception raised by this task (if any).
+        /// </summary>
+        /// <value>The exception.</value>
+        Exception Exception { get; }
+
+        /// <summary>
+        /// Perform the next async step.
+        /// </summary>
+        /// <param name="cont">The action to be performed on completion.</param>
+        void ExecuteStep(Action cont);
+
+        /// <summary>
+        /// Abort the task operation.
+        /// </summary>
+        void Abort();
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/InvokeTaskSequenceTask.cs b/microsoft-azure-api/StorageClient/Tasks/InvokeTaskSequenceTask.cs
new file mode 100644
index 0000000000000..5452de5d4fb40
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/InvokeTaskSequenceTask.cs
@@ -0,0 +1,195 @@
+//-----------------------------------------------------------------------
+// <copyright file="InvokeTaskSequenceTask.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the InvokeTaskSequenceTask and InvokeTaskSequenceTask[T] classes.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+
+    using TaskSequence = System.Collections.Generic.IEnumerable<ITask>;
+
+    /// <summary>
+    /// Invokes a sequence with no return value.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a generic class with the same name.")]
+    internal class InvokeTaskSequenceTask : InvokeTaskSequenceTask<NullTaskReturn>
+    {
+        /// <summary>
+        /// Initializes a new instance of the InvokeTaskSequenceTask class for sequence without any return value.
+        /// </summary>
+        /// <param name="sequenceFunction">The sequence of actions to be invoked.</param>
+        [DebuggerNonUserCode]
+        public InvokeTaskSequenceTask(Func<TaskSequence> sequenceFunction)
+            : base((a) => sequenceFunction())
+        {
+        }
+    }
+
+    /// <summary>
+    /// Invokes a sequence of tasks.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the operation.</typeparam>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a non-generic specialization with the same name.")]
+    internal class InvokeTaskSequenceTask<T> : Task<T>
+    {
+        /// <summary>
+        /// Contains the function that generates a squence of tasks to be invoked.
+        /// </summary>
+        private Func<Action<T>, TaskSequence> sequenceGenerator;
+
+        /// <summary>
+        /// The current task that is being invoked.
+        /// </summary>
+        private ITask currentTask;
+
+        /// <summary>
+        /// Controls whether the abort was called.
+        /// </summary>
+        private bool aborting;
+
+        /// <summary>
+        /// Initializes a new instance of the InvokeTaskSequenceTask class with a task sequence that returns a value.
+        /// </summary>
+        /// <param name="sequenceFunction">The sequence of actions to be invoked.</param>
+        [DebuggerNonUserCode]
+        public InvokeTaskSequenceTask(Func<Action<T>, TaskSequence> sequenceFunction)
+        {
+            TraceHelper.WriteLine("InvokeTaskSequenceTask, constructor");
+            this.sequenceGenerator = sequenceFunction;
+        }
+
+        /// <summary>
+        /// Implements the abort logic by aborting the current task.
+        /// </summary>
+        [DebuggerNonUserCode]
+        protected override void AbortInternal()
+        {
+            TraceHelper.WriteLine("InvokeTaskSequenceTask, AbortInternal");
+            this.aborting = true;
+            ITask task = this.currentTask;
+            if (task != null)
+            {
+                task.Abort();
+            }
+        }
+
+        /// <summary>
+        /// The starting point for executing a task sequence.
+        /// </summary>
+        [DebuggerNonUserCode]
+        protected override void ExecuteInternal()
+        {
+            TraceHelper.WriteLine("InvokeTaskSequenceTask, ExecuteInternal");
+            TaskSequence sequence = this.sequenceGenerator((res) => this.Result = res);
+            IEnumerator<ITask> en = sequence.GetEnumerator();
+            this.ExecuteTaskSequence(en, true);
+        }
+
+        /// <summary>
+        /// Executes a task sequence by iterating over all of the items and executing them.
+        /// </summary>
+        /// <param name="taskList">The sequence of tasks to execute.</param>
+        /// <param name="completedSynchronously">Whether the sequence so far has completed synchronously.</param>
+        [DebuggerNonUserCode]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "Exception is saved")]
+        private void ExecuteTaskSequence(IEnumerator<ITask> taskList, bool completedSynchronously)
+        {
+            TraceHelper.WriteLine("InvokeTaskSequenceTask, ExecuteTaskSequence");
+        Run:
+            TraceHelper.WriteLine("InvokeTaskSequenceTask, ExecuteTaskSequence Run");
+
+            // complete previous task
+            ITask task = taskList.Current;
+
+            // handle abort
+            if (this.aborting)
+            {
+                return;
+            }
+
+            // move to next task
+            bool hasTask;
+            try
+            {
+                hasTask = taskList.MoveNext();
+            }
+            catch (Exception ex)
+            {
+                this.Exception = ex;
+
+                // If this operation hasn't moved to a background thread, we should throw the exception out.
+                // This is to follow guideline #7 in  http://csdweb/sites/oslo/engsys/DesignGuidelines/Wiki%20Pages/IAsyncResult.aspx:
+                //     "The callback is called exactly once, unless BeginXxx throws, in which case it isn’t called"
+                // It also provides the user with better exception stack trace, faster error notification and saves potential WaitHandle construction
+                if (completedSynchronously)
+                {
+                    throw;
+                }
+
+                this.Complete(completedSynchronously);
+                return;
+            }
+
+            if (!hasTask)
+            {
+                // complete
+                this.Complete(completedSynchronously);
+                return;
+            }
+
+            // invoke task
+            task = taskList.Current;
+            try
+            {
+                this.currentTask = task;
+                task.ExecuteStep(() =>
+                    {
+                        if (!task.CompletedSynchronously)
+                        {
+                            this.currentTask = null; ExecuteTaskSequence(taskList, false);
+                        }
+                    });
+            }
+            catch (Exception ex)
+            {
+                this.currentTask = null;
+                this.Exception = ex;
+                this.Complete(completedSynchronously);
+                return;
+            }
+
+            if (task.CompletedSynchronously)
+            {
+                this.currentTask = null;
+                goto Run;
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/NullTaskReturn.cs b/microsoft-azure-api/StorageClient/Tasks/NullTaskReturn.cs
new file mode 100644
index 0000000000000..eec4d3277a56d
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/NullTaskReturn.cs
@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+// <copyright file="NullTaskReturn.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the NullTaskReturn class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+
+    /// <summary>
+    /// A NullTaskReturn type.
+    /// </summary>
+    internal class NullTaskReturn
+    {
+        /// <summary>
+        /// Represents a no-return from a task.
+        /// </summary>
+        public static readonly NullTaskReturn Value = new NullTaskReturn();
+
+        /// <summary>
+        /// Prevents a default instance of the <see cref="NullTaskReturn"/> class from being created.
+        /// </summary>
+        private NullTaskReturn()
+        {
+        }
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageClient/Tasks/RaceTask.cs b/microsoft-azure-api/StorageClient/Tasks/RaceTask.cs
new file mode 100644
index 0000000000000..df51e81c1837b
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/RaceTask.cs
@@ -0,0 +1,146 @@
+//-----------------------------------------------------------------------
+// <copyright file="RaceTask.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the RaceTask[T] class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System.Diagnostics;
+    using System.Threading;
+
+    /// <summary>
+    /// Facilitates a scenario where numerous simultaneous tasks are active, and only the first to complete should continue.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the operation.</typeparam>
+    internal class RaceTask<T> : Task<T>
+    {
+        /// <summary>
+        /// Stores the abort flag.
+        /// </summary>
+        private int aborting;
+
+        /// <summary>
+        /// Stores the racing tasks.
+        /// </summary>
+        private Task<T>[] tasks;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RaceTask&lt;T&gt;"/> class.
+        /// </summary>
+        /// <param name="tasks">The tasks.</param>
+        [DebuggerNonUserCode]
+        public RaceTask(params Task<T>[] tasks)
+        {
+            TraceHelper.WriteLine("Creating race task with count " + tasks.Length);
+            this.tasks = tasks;
+        }
+
+        /// <summary>
+        /// The specific implementation of the task's step.
+        /// </summary>
+        [DebuggerNonUserCode]
+        protected override void ExecuteInternal()
+        {
+            TraceHelper.WriteLine("RaceTask, ExecuteInternal");
+
+            // kick off the tasks
+            foreach (Task<T> async in this.tasks)
+            {
+                if (this.Completed)
+                {
+                    break;
+                }
+
+                Task<T> a2 = async;
+                a2.ExecuteStep(delegate { this.OnComplete(a2); });
+            }
+        }
+
+        /// <summary>
+        /// The task-specific abort that should be called.
+        /// </summary>
+        [DebuggerNonUserCode]
+        protected override void AbortInternal()
+        {
+            TraceHelper.WriteLine("RaceTask, AbortInternal");
+
+            if (this.Completed)
+            {
+                return;
+            }
+
+            // This is to avoid tasks trying to complete on a competing thread
+            int currentlyAborting = Interlocked.CompareExchange(ref this.aborting, 1, 0);
+
+            if (currentlyAborting == 1)
+            {
+                return;
+            }
+
+            // abort all inner tasks
+            foreach (Task<T> innerTask in this.tasks)
+            {
+                innerTask.Abort();
+            }
+        }
+
+        /// <summary>
+        /// Called when complete.
+        /// </summary>
+        /// <param name="winner">The winning task.</param>
+        [DebuggerNonUserCode]
+        private void OnComplete(Task<T> winner)
+        {
+            TraceHelper.WriteLine("RaceTask, OnComplete");
+            if (this.Completed)
+            {
+                return;
+                ////throw new InvalidOperationException("completion already occurred");
+            }
+
+            int currentlyAborting = Interlocked.CompareExchange(ref this.aborting, 1, 0);
+
+            if (currentlyAborting == 1)
+            {
+                // the loser tasks (ie. this) are 'completing'
+                return;
+            }
+
+            // winner reaches here
+            // abort the other tasks
+            foreach (Task<T> loser in this.tasks)
+            {
+                if (!object.ReferenceEquals(loser, winner))
+                {
+                    loser.Abort();
+                }
+            }
+
+            if (winner.Exception != null)
+            {
+                this.Exception = winner.Exception;
+            }
+            else
+            {
+                SetResult(() => winner.Result);
+            }
+
+            Complete(winner.CompletedSynchronously);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/StreamExtensions.cs b/microsoft-azure-api/StorageClient/Tasks/StreamExtensions.cs
new file mode 100644
index 0000000000000..47a03fbf37ecf
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/StreamExtensions.cs
@@ -0,0 +1,178 @@
+//-----------------------------------------------------------------------
+// <copyright file="StreamExtensions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StreamExtensions class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.IO;
+
+    using TaskSequence = System.Collections.Generic.IEnumerable<ITask>;
+
+    /// <summary>
+    /// Provides extensions for the stream object to support asynchronous operations.
+    /// </summary>
+    internal static class StreamExtensions
+    {
+        /// <summary>
+        /// Buffer size needs to be page-aligned.
+        /// </summary>
+        private const int BufferSize = 64 * 1024;
+
+        /// <summary>
+        /// Asynchronously reads data from a stream using BeginRead.
+        /// </summary>
+        /// <param name="stream">The stream on which the method is called.</param>
+        /// <param name="buffer">The buffer to read the data into.</param>
+        /// <param name="offset">Byte offset in the buffer.</param>
+        /// <param name="count">Maximum number of bytes to read.</param>
+        /// <returns>Returns non-zero if there are still some data to read.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<int> ReadAsync(this Stream stream, byte[] buffer, int offset, int count)
+        {
+            return new APMTask<int>(
+                (callback, st) => stream.BeginRead(buffer, offset, count, callback, st),
+                stream.EndRead);
+        }
+
+        /// <summary>
+        /// Reads asynchronously the entire content of the stream and returns it 
+        /// as a string using StreamReader.
+        /// </summary>
+        /// <param name="stream">The stream on which the method is called.</param>
+        /// <param name="encoding">The text encoding used for converting bytes read into string.</param>
+        /// <param name="result">The action to be performed with the resulting string.</param>
+        /// <returns>Returns a task sequence that must be performed to get result string using the 'Result' callback.</returns>
+        [DebuggerNonUserCode]
+        internal static TaskSequence ReadToString(this Stream stream, System.Text.Encoding encoding, Action<string> result)
+        {
+            using (var ms = new SmallBlockMemoryStream())
+            {
+                int read = -1;
+                while (read != 0)
+                {
+                    byte[] buffer = new byte[1024];
+                    Task<int> count = stream.ReadAsync(buffer, 0, 1024);
+                    yield return count;
+
+                    ms.Write(buffer, 0, count.Result);
+                    read = count.Result;
+                }
+
+                ms.Seek(0, SeekOrigin.Begin);
+                using (var strm = new StreamReader(ms, encoding))
+                {
+                    result(strm.ReadToEnd());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Asynchronously writes data from a stream using BeginWrite.
+        /// </summary>
+        /// <param name="stream">The stream on which the method is called.</param>
+        /// <param name="buffer">The buffer to write the data from.</param>
+        /// <param name="offset">Byte offset in the buffer.</param>
+        /// <param name="count">Maximum number of bytes to write.</param>
+        /// <returns>A task with no return value.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<NullTaskReturn> WriteAsync(this Stream stream, byte[] buffer, int offset, int count)
+        {
+            return new APMTask(
+                (callback, st) => stream.BeginWrite(buffer, offset, count, callback, st),
+                (res) => { stream.EndWrite(res); });
+        }
+
+        /// <summary>
+        /// Reads asynchronously the entire content of the stream and writes it to the given output stream.
+        /// </summary>
+        /// <param name="stream">The origin stream.</param>
+        /// <param name="toStream">The destination stream.</param>
+        /// <returns>The sequence that when invoked results in an asynchronous copy.</returns>
+        [DebuggerNonUserCode]
+        internal static TaskSequence WriteTo(this Stream stream, Stream toStream)
+        {
+            int readCount;
+            do
+            {
+                byte[] buffer = new byte[BufferSize];
+                var readTask = stream.ReadAsync(buffer, 0, buffer.Length);
+                yield return readTask;
+                readCount = readTask.Result;
+
+                var writeTask = toStream.WriteAsync(buffer, 0, readCount);
+                yield return writeTask;
+                var scratch = writeTask.Result;
+            }
+            while (readCount != 0);
+        }
+
+        /// <summary>
+        /// Reads synchronously the entire content of the stream and writes it to the given output stream.
+        /// </summary>
+        /// <param name="stream">The origin stream.</param>
+        /// <param name="toStream">The destination stream.</param>       
+        [DebuggerNonUserCode]
+        internal static void WriteToSync(this Stream stream, Stream toStream)
+        {
+            int readCount;
+            do
+            {
+                byte[] buffer = new byte[BufferSize];
+                readCount = stream.EndRead(stream.BeginRead(buffer, 0, buffer.Length, null /* Callback */, null /* State */));
+                toStream.Write(buffer, 0, readCount);
+            }
+            while (readCount != 0);
+        }
+
+        /// <summary>
+        /// Reads asynchronously the entire content of the stream and writes it to the given output stream.
+        /// Closes the output stream at the end.
+        /// </summary>
+        /// <param name="stream">The origin stream.</param>
+        /// <param name="toStream">The destination stream.</param>
+        /// <returns>The sequence that when invoked results in an asynchronous copy.</returns>
+        [DebuggerNonUserCode]
+        internal static TaskSequence WriteToAndCloseOutput(this Stream stream, Stream toStream)
+        {
+            int readCount;
+            try
+            {
+                do
+                {
+                    byte[] buffer = new byte[BufferSize];
+                    var readTask = stream.ReadAsync(buffer, 0, buffer.Length);
+                    yield return readTask;
+                    readCount = readTask.Result;
+
+                    var writeTask = toStream.WriteAsync(buffer, 0, readCount);
+                    yield return writeTask;
+                    var scratch = writeTask.Result;
+                }
+                while (readCount != 0);
+            }
+            finally
+            {
+                toStream.Close();
+                toStream.Dispose();
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/SynchronousTask.cs b/microsoft-azure-api/StorageClient/Tasks/SynchronousTask.cs
new file mode 100644
index 0000000000000..e7bc72981ed3f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/SynchronousTask.cs
@@ -0,0 +1,87 @@
+//-----------------------------------------------------------------------
+// <copyright file="SynchronousTask.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the SynchronousTask and SynchronousTask[T] classes.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+
+    /// <summary>
+    /// A task that obtains a result synchronously.
+    /// </summary>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a generic class with the same name.")]
+    internal class SynchronousTask : SynchronousTask<NullTaskReturn>
+    {
+        /// <summary>
+        /// Initializes a new instance of the SynchronousTask class.
+        /// </summary>
+        /// <param name="operation">The function to execute.</param>
+        public SynchronousTask(Action operation)
+            : base(() => { operation(); return NullTaskReturn.Value; })
+        {
+        }
+    }
+
+    /// <summary>
+    /// A task that obtains a result synchronously.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the operation.</typeparam>
+    [System.Diagnostics.CodeAnalysis.SuppressMessage(
+        "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+        "SA1402:FileMayOnlyContainASingleClass",
+        Justification = "Other class is a non-generic specialization with the same name.")]
+    internal class SynchronousTask<T> : Task<T>
+    {
+        /// <summary>
+        /// The function to be executed.
+        /// </summary>
+        private Func<T> func;
+
+        /// <summary>
+        /// Initializes a new instance of the SynchronousTask class.
+        /// </summary>
+        /// <param name="operation">The function to execute.</param>
+        public SynchronousTask(Func<T> operation)
+        {
+            this.func = operation;
+        }
+
+        /// <summary>
+        /// Performs the task and marks it as completed.
+        /// </summary>
+        [DebuggerNonUserCode]
+        protected override void ExecuteInternal()
+        {
+            this.SetResult(this.func);
+            this.Complete(true);
+        }
+
+        /// <summary>
+        /// Implements abort as NoOp.
+        /// </summary>
+        [DebuggerNonUserCode]
+        protected override void AbortInternal()
+        {
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/TableServiceExtensions.cs b/microsoft-azure-api/StorageClient/Tasks/TableServiceExtensions.cs
new file mode 100644
index 0000000000000..85bce5e4d11f5
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/TableServiceExtensions.cs
@@ -0,0 +1,136 @@
+//-----------------------------------------------------------------------
+// <copyright file="TableServiceExtensions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TableServiceExtensions class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Data.Services.Client;
+    using System.Diagnostics;
+    using TaskSequence = System.Collections.Generic.IEnumerable<ITask>;
+
+    /// <summary>
+    /// A set of extension methods for table service classes.
+    /// </summary>
+    internal static class TableServiceExtensions
+    {
+        /// <summary>
+        /// Converts a DataServiceQuery execution into an APMTask.
+        /// </summary>
+        /// <typeparam name="T">The result type of the query.</typeparam>
+        /// <param name="query">The query to convert.</param>
+        /// <returns>The wrapped task.</returns>
+        [DebuggerNonUserCode]
+        public static Task<IEnumerable<T>> ExecuteAsync<T>(this DataServiceQuery<T> query)
+        {
+            var queryTask = new APMTask<IEnumerable<T>>(query.BeginExecute, query.EndExecute);
+#if false
+            return queryTask;
+#else
+            return GetUnexpectedInternalClientErrorWrappedTask(Protocol.Constants.TableWorkaroundTimeout, queryTask);
+#endif
+        }
+
+        /// <summary>
+        /// Converts the SaveChanges method into an APMTask.
+        /// </summary>
+        /// <param name="context">The target context.</param>
+        /// <returns>The wrapped task.</returns>
+        [DebuggerNonUserCode]
+        public static Task<DataServiceResponse> SaveChangesAsync(this TableServiceContext context)
+        {
+            return context.SaveChangesAsync(SaveChangesOptions.None);
+        }
+
+        /// <summary>
+        /// Converts the SaveChanges method to an APMTask.
+        /// </summary>
+        /// <param name="context">The target context.</param>
+        /// <param name="options">The options to pass to SaveChanges.</param>
+        /// <returns>A task that saves changes asynchronously.</returns>
+        [DebuggerNonUserCode]
+        public static Task<DataServiceResponse> SaveChangesAsync(this TableServiceContext context, SaveChangesOptions options)
+        {
+            var task = new APMTask<DataServiceResponse>(
+                (callback, state) => context.BeginSaveChanges(options, callback, state),
+                (asyncResult) => context.EndSaveChanges(asyncResult));
+#if false
+            return task;
+#else
+            return GetUnexpectedInternalClientErrorWrappedTask(Protocol.Constants.TableWorkaroundTimeout, task);
+#endif
+        }
+
+        /// <summary>
+        /// Gets the unexpected internal client error wrapped task.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="originalTask">The original task.</param>
+        /// <returns>The wrapped task.</returns>
+        internal static Task<T> GetUnexpectedInternalClientErrorWrappedTask<T>(TimeSpan? timeout, Task<T> originalTask)
+        {
+            TraceHelper.WriteLine("Creating timeout wrapped task " + timeout);
+
+            if (timeout.HasValue)
+            {
+                Task<T> wrappedTimeoutTask = new InvokeTaskSequenceTask<T>((setResult) =>
+                    GetUnexpectedInternalClientErrorTaskSequence(timeout.Value, setResult));
+                return new RaceTask<T>(wrappedTimeoutTask, originalTask);
+            }
+            else
+            {
+                return originalTask;
+            }
+        }
+
+        /// <summary>
+        /// Gets the unexpected internal client error task sequence.
+        /// </summary>
+        /// <typeparam name="T">The result type.</typeparam>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> for the unexpected error.</returns>
+        private static TaskSequence GetUnexpectedInternalClientErrorTaskSequence<T>(TimeSpan timeout, Action<T> setResult)
+        {
+            // this fires to signal the the detection of a known astoria 1.0 bug.
+            TraceHelper.WriteLine("Creating unexpected internal client error task sequence " + timeout);
+            NullTaskReturn scratch;
+
+            using (DelayTask timeoutTask = new DelayTask(timeout))
+            {
+                yield return timeoutTask;
+                scratch = timeoutTask.Result;
+            }
+
+            TraceHelper.WriteLine("Unexpected internal storage client error.");
+
+            throw new StorageClientException(
+                StorageErrorCode.None,
+                "The operation has exceeded the default maximum time allowed for Windows Azure Table service operations.", 
+                System.Net.HttpStatusCode.Unused,
+                null,
+                null)
+            {
+                HelpLink = "http://go.microsoft.com/fwlink/?LinkID=182765"
+            };
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/Task.cs b/microsoft-azure-api/StorageClient/Tasks/Task.cs
new file mode 100644
index 0000000000000..bb8246a5978d1
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/Task.cs
@@ -0,0 +1,307 @@
+//-----------------------------------------------------------------------
+// <copyright file="Task.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the Task[T] class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+
+    /// <summary>
+    /// Represents an asynchronous computation that yields a result of type T.
+    /// </summary>
+    /// <typeparam name="T">The type of the result of the operation.</typeparam>
+    /// <remarks>
+    /// By this contract we:
+    ///  1) guarantee that the completion routine is performed, regardless of the outcome of ExecuteStep.
+    ///  2) insist that the completion routine does not throw an exception.
+    ///  3) insists that the abort routine does not throw an exception.
+    /// </remarks>
+    internal abstract class Task<T> : ITask
+    {
+        /// <summary>
+        /// Provides information if the task completed synchronously and therefore on the main thread.
+        /// </summary>
+        private bool completedSynchronously;
+
+        /// <summary>
+        /// Contains any exceptions raised by the task.
+        /// </summary>
+        private Exception exception;
+
+        /// <summary>
+        /// The action to call once the operation is completed.
+        /// </summary>
+        private Action completionFunction;
+
+        /// <summary>
+        /// The result of the operation.
+        /// </summary>
+        private T result;
+
+        /// <summary>
+        /// Gets or sets the result of the operation and throws any exceptions raised by the operation.
+        /// </summary>
+        [DebuggerNonUserCode]
+        public T Result
+        {
+            get
+            {
+                TraceHelper.WriteLine("Task, Result");
+                if (!this.Completed)
+                {
+                    throw new InvalidOperationException("the operation is not complete");
+                }
+
+                if (this.exception != null)
+                {
+                    throw this.exception;
+                }
+
+                return this.result;
+            }
+
+            protected set
+            {
+                this.result = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the operation was completed synchronously and therefore on main thread.
+        /// </summary>
+        [DebuggerNonUserCode]
+        public bool CompletedSynchronously
+        {
+            [DebuggerStepThrough]
+            get
+            {
+                return this.completedSynchronously;
+            }
+
+            protected set
+            {
+                this.completedSynchronously = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets any exceptions raised during execution.
+        /// </summary>
+        [DebuggerNonUserCode]
+        public Exception Exception
+        {
+            [DebuggerStepThrough]
+            get
+            {
+                return this.exception;
+            }
+
+            protected set
+            {
+                this.exception = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the task is completed.
+        /// </summary>
+        protected bool Completed { get; set; }
+
+        /// <summary>
+        /// Executes the tasks and waits for the result.
+        /// </summary>
+        /// <returns>The result of the operation.</returns>
+        public T ExecuteAndWait()
+        {
+            TraceHelper.WriteLine("Task, ExecuteAndWait");
+
+            // Potential optimization: Make sure that synchronous results are not creating events
+            using (System.Threading.ManualResetEvent evt = new System.Threading.ManualResetEvent(false))
+            {
+                this.ExecuteStep(() => { evt.Set(); });
+                evt.WaitOne();
+            }
+
+            return this.Result;
+        }
+
+        /// <summary>
+        /// Executes a task, will not wait on a sync task.
+        /// </summary>
+        /// <returns>The result of the operation.</returns>
+        public T Execute()
+        {
+            TraceHelper.WriteLine("Task, Execute");
+            if (this is SynchronousTask<T>)
+            {
+                this.ExecuteInternal();
+                return this.Result;
+            }
+            else
+            {
+                return this.ExecuteAndWait();
+            }
+        }
+
+        /// <summary>
+        /// Executes a single step of the task. (Delegates to the concrete implemetation for specific step).
+        /// </summary>
+        /// <param name="cont">The completion function to be called.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "The exception is saved.")]
+        [DebuggerNonUserCode]
+        public void ExecuteStep(Action cont)
+        {
+            TraceHelper.WriteLine("Task, ExecuteStep");
+            this.completionFunction = cont;
+            try
+            {
+                this.ExecuteInternal();
+            }
+            catch (Exception ex)
+            {
+                this.exception = ex;
+                this.Complete(true);
+            }
+        }
+
+        /// <summary>
+        /// Implements an abort routine that fulfills the contract.
+        /// </summary>
+        [DebuggerNonUserCode]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "Exception is saved or callbacks should never throw exception")]
+        public void Abort()
+        {
+            TraceHelper.WriteLine("Task, Abort");
+            lock (this)
+            {
+                if (this.Completed)
+                {
+                    // the task has already completed.
+                    return;
+                }
+
+                this.Completed = true;
+                this.CompletedSynchronously = false;
+            }
+
+            try
+            {
+                this.AbortInternal();
+            }
+            catch (Exception ex)
+            {
+                this.exception = ex;
+            }
+            finally
+            {
+                // fulfill the callback contract (is definitely async)
+                try
+                {
+                    if (this.completionFunction != null)
+                    {
+                        this.completionFunction();
+                    }
+                }
+                catch (Exception ex)
+                {
+                    // the continuation itself threw an exception.  this is a violation of the contract!
+                    Debug.Assert(false, "task: continuation threw exception: " + ex);
+                }
+            }
+        }
+
+        /// <summary>
+        /// The specific implementation of the task's step.
+        /// </summary>
+        protected abstract void ExecuteInternal();
+
+        /// <summary>
+        /// Implements a safe way to obtain the result.
+        /// </summary>
+        /// <param name="result">The function used to get the result value.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "The exception is stored.")]
+        [DebuggerNonUserCode]
+        protected void SetResult(Func<T> result)
+        {
+            try
+            {
+                this.Result = result();
+            }
+            catch (AccessViolationException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                this.exception = ex;
+            }
+        }
+
+        /// <summary>
+        /// The task-specific abort that should be called.
+        /// </summary>
+        protected abstract void AbortInternal();
+
+        /// <summary>
+        /// The completion return that needs to be called whenever operation completes.
+        /// </summary>
+        /// <param name="completedSynchronously">Whether the underlying operation completed synchrnously.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.Design",
+            "CA1031:DoNotCatchGeneralExceptionTypes",
+            Justification = "Callbacks should never throw exception")]
+        [DebuggerNonUserCode]
+        protected void Complete(bool completedSynchronously)
+        {
+            TraceHelper.WriteLine("Task, Complete completedSynchronously {0}", completedSynchronously);
+            lock (this)
+            {
+                if (this.Completed)
+                {
+                    // the task has already completed.  Perhaps it was aborted.
+                    return;
+                }
+
+                this.CompletedSynchronously = completedSynchronously;
+                this.Completed = true;
+            }
+
+            try
+            {
+                if (this.completionFunction != null)
+                {
+                    this.completionFunction();
+                }
+            }
+            catch (Exception ex)
+            {
+                // the continuation itself threw an exception.  this is a violation of the contract!
+                Debug.Assert(false, "task: continuation threw exception: " + ex);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/TaskAsyncResult.cs b/microsoft-azure-api/StorageClient/Tasks/TaskAsyncResult.cs
new file mode 100644
index 0000000000000..a39dcfdcb80b8
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/TaskAsyncResult.cs
@@ -0,0 +1,224 @@
+//-----------------------------------------------------------------------
+// <copyright file="TaskAsyncResult.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TaskAsyncResult[T] class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.Threading;
+
+    /// <summary>
+    /// An implementation of IAsyncResult that encapsulates a task.
+    /// </summary>
+    /// <typeparam name="T">The type of the resulting value.</typeparam>
+    /// <remarks>Refer to http://csdweb/sites/oslo/engsys/DesignGuidelines/Wiki%20Pages/IAsyncResult.aspx and 
+    /// http://www.bluebytesoftware.com/blog/2006/05/31/ImplementingAHighperfIAsyncResultLockfreeLazyAllocation.aspx for IAsyncResult details</remarks>
+    internal class TaskAsyncResult<T> : IAsyncResult, IDisposable
+    {
+        /// <summary>
+        /// The underlying task for the async operation.
+        /// </summary>
+        private Task<T> realTask;
+
+        /// <summary>
+        /// The callback provided by the user.
+        /// </summary>
+        private AsyncCallback userCallback;
+
+        /// <summary>
+        /// The state for the callback.
+        /// </summary>
+        private object userState;
+
+        /// <summary>
+        /// Indicates whether a task is completed.
+        /// </summary>
+        private volatile bool isCompleted;
+
+        /// <summary>
+        /// Indicates whether task completed synchronously.
+        /// </summary>
+        private bool completedSynchronously;
+
+        /// <summary>
+        /// The event for blocking on this task's completion.
+        /// </summary>
+        private ManualResetEvent asyncWaitEvent;
+
+        /// <summary>
+        /// Initializes a new instance of the TaskAsyncResult class.
+        /// </summary>
+        /// <param name="async">The task to be executed.</param>
+        /// <param name="callback">The callback method to be used on completion.</param>
+        /// <param name="state">The state for the callback.</param>
+        [DebuggerNonUserCode]
+        public TaskAsyncResult(Task<T> async, AsyncCallback callback, object state)
+        {
+            this.realTask = async;
+            this.userCallback = callback;
+            this.userState = state;
+
+            // We don't need finalization, we just implement IDisposable to let users close the event
+            GC.SuppressFinalize(this);
+
+            this.realTask.ExecuteStep(this.OnComplete);
+        }
+        
+        /// <summary>
+        /// Gets A user-defined object that contains information about the asynchronous operation.
+        /// </summary>
+        [DebuggerNonUserCode]
+        object IAsyncResult.AsyncState
+        {
+            get { return this.userState; }
+        }
+
+        /// <summary>
+        ///  Gets a System.Threading.WaitHandle that is used to wait for an asynchronous operation to complete.
+        /// </summary>
+        [DebuggerNonUserCode]
+        WaitHandle IAsyncResult.AsyncWaitHandle
+        {
+            get { return this.LazyCreateWaitHandle(); }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the asynchronous operation completed synchronously.
+        /// </summary>
+        [DebuggerNonUserCode]
+        bool IAsyncResult.CompletedSynchronously
+        {
+            get { return this.completedSynchronously; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the asynchronous operation has completed.
+        /// </summary>
+        [DebuggerNonUserCode]
+        bool IAsyncResult.IsCompleted
+        {
+            get { return this.isCompleted; }
+        }
+        
+        /// <summary>
+        /// Provides a convenient function for waiting for completion and getting the result.
+        /// </summary>
+        /// <returns>The result of the operation.</returns>
+        public T EndInvoke()
+        {
+            // We haven't completed yet, so we should wait. (Only single thread may call this)
+            if (!this.isCompleted)
+            {
+                // If the operation isn't done, wait for it
+                ((IAsyncResult)this).AsyncWaitHandle.WaitOne();
+                ((IAsyncResult)this).AsyncWaitHandle.Close();
+                this.asyncWaitEvent = null;
+            }
+
+            // Get the results - which will invoke any exceptions
+            return this.realTask.Result;
+        }
+
+        /// <summary>
+        /// We implement the dispose only to allow the explicit closing of the event.
+        /// </summary>
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="disposing">Set to <c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                if (this.asyncWaitEvent != null)
+                {
+                    this.asyncWaitEvent.Close();
+                    this.asyncWaitEvent = null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Provides the lazy initialization of the WaitHandle (based on Joe Duffy's blog).
+        /// </summary>
+        /// <returns>The WaitHandle to use for waiting on completion.</returns>
+        private WaitHandle LazyCreateWaitHandle()
+        {
+            if (this.asyncWaitEvent != null)
+            {
+                return this.asyncWaitEvent;
+            }
+
+            ManualResetEvent newHandle = new ManualResetEvent(false);
+            if (Interlocked.CompareExchange(ref this.asyncWaitEvent, newHandle, null) != null)
+            {
+                // We lost the race. Release the handle we created, it's garbage.
+                newHandle.Close();
+            }
+
+            if (this.isCompleted)
+            {
+                // If the result has already completed, we must ensure we return the
+                // handle in a signaled state. The read of this.isCompleted must never move
+                // before the read of m_waitHandle earlier; the use of an interlocked
+                // compare-exchange just above ensures that. And there's a race that could
+                // lead to multiple threads setting the event; that's no problem.
+                this.asyncWaitEvent.Set();
+            }
+
+            return this.asyncWaitEvent;
+        }
+
+        /// <summary>
+        /// Called on completion of the async operation to notify the user
+        /// (Based on Joe Duffy's lockless design).
+        /// </summary>
+        [DebuggerNonUserCode]
+        private void OnComplete()
+        {
+            // First mark completion
+            this.completedSynchronously = this.realTask.CompletedSynchronously;
+            this.isCompleted = true;
+
+            // And then, if the wait handle was created, we need to signal it. Note the
+            // use of a memory barrier. This is required to ensure the read of m_waitHandle
+            // never moves before the store of m_isCompleted; otherwise we might encounter a
+            // race that leads us to not signal the handle, leading to a deadlock. We can't
+            // just do a volatile read of m_waitHandle, because it is possible for an acquire
+            // load to move before a store release.
+            Thread.MemoryBarrier();
+            if (this.asyncWaitEvent != null)
+            {
+                this.asyncWaitEvent.Set();
+            }
+
+            if (this.userCallback != null)
+            {
+                this.userCallback(this);
+            }
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/TimeoutHelper.cs b/microsoft-azure-api/StorageClient/Tasks/TimeoutHelper.cs
new file mode 100644
index 0000000000000..3c095c2a62588
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/TimeoutHelper.cs
@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+// <copyright file="TimeoutHelper.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TimeoutHelper class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using TaskSequence = System.Collections.Generic.IEnumerable<ITask>;
+
+    /// <summary>
+    /// Encapsulates methods for wrapping tasks in timeouts.
+    /// </summary>
+    internal static class TimeoutHelper
+    {
+        /// <summary>
+        /// Gets a timeout wrapped task.
+        /// </summary>
+        /// <typeparam name="T">The type of the result.</typeparam>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="originalTask">The original task.</param>
+        /// <returns>A <see cref="Task&lt;T&gt;"/> that has been wrapped with a timeout if specified.</returns>
+        internal static Task<T> GetTimeoutWrappedTask<T>(TimeSpan? timeout, Task<T> originalTask)
+        {
+            TraceHelper.WriteLine("Creating timeout wrapped task " + timeout);
+            
+            if (timeout.HasValue)
+            {
+                Task<T> wrappedTimeoutTask = new InvokeTaskSequenceTask<T>((setResult) =>
+                    GetTimeoutTaskSequence(timeout.Value, setResult));
+                return new RaceTask<T>(wrappedTimeoutTask, originalTask);
+            }
+            else
+            {
+                return originalTask;
+            }
+        }
+
+        /// <summary>
+        /// Creates a localized timeout exception object.
+        /// </summary>
+        /// <param name="timeout">The timeout.</param>
+        /// <returns>A localized <see cref="TimeoutException"/> object.</returns>
+        internal static Exception ThrowTimeoutError(TimeSpan timeout)
+        {
+            TraceHelper.WriteLine("ThrowTimeoutError " + timeout);
+
+            string errorMessage = string.Format(
+                System.Globalization.CultureInfo.CurrentCulture,
+                SR.ClientSideTimeoutError,
+                timeout.RoundUpToSeconds());
+
+            return new TimeoutException(errorMessage);
+        }
+
+        /// <summary>
+        /// Gets a timeout task sequence.
+        /// </summary>
+        /// <typeparam name="T">The type of the result.</typeparam>
+        /// <param name="timeout">The timeout.</param>
+        /// <param name="setResult">The set result.</param>
+        /// <returns>A <see cref="TaskSequence"/> that has been wrapped with a timeout if specified.</returns>
+        private static TaskSequence GetTimeoutTaskSequence<T>(TimeSpan timeout, Action<T> setResult)
+        {
+            TraceHelper.WriteLine("Creating timeout task sequence " + timeout);
+            NullTaskReturn scratch;
+
+            using (DelayTask timeoutTask = new DelayTask(timeout))
+            {
+                yield return timeoutTask;
+                scratch = timeoutTask.Result;
+            }
+
+            throw ThrowTimeoutError(timeout);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Tasks/WebRequestExtensions.cs b/microsoft-azure-api/StorageClient/Tasks/WebRequestExtensions.cs
new file mode 100644
index 0000000000000..7c660fe668d1f
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Tasks/WebRequestExtensions.cs
@@ -0,0 +1,137 @@
+//-----------------------------------------------------------------------
+// <copyright file="WebRequestExtensions.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the WebRequestExtensions class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient.Tasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Net;
+
+    /// <summary>
+    /// A set of extension methods for a webrequest.
+    /// </summary>
+    internal static class WebRequestExtensions
+    {
+        /// <summary>
+        /// Gets an asynchronous response to a given Web request.
+        /// </summary>
+        /// <param name="req">The requested that is used for operation.</param>
+        /// <param name="service">The service.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <returns>A task that yields the response.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<WebResponse> GetResponseAsyncWithTimeout(this WebRequest req, CloudQueueClient service, TimeSpan? timeout)
+        {
+            Task<WebResponse> serverTask = req.GetResponseAsync(service);
+
+            Task<WebResponse> wrappedTask = TimeoutHelper.GetTimeoutWrappedTask(timeout, serverTask);
+            return wrappedTask;
+        }
+
+        /// <summary>
+        /// Gets an asynchronous response to a given Web request.
+        /// </summary>
+        /// <param name="req">The requested that is used for operation.</param>
+        /// <param name="service">The service.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <returns>A task that yields the response.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<WebResponse> GetResponseAsyncWithTimeout(this WebRequest req, CloudBlobClient service, TimeSpan? timeout)
+        {
+            Task<WebResponse> serverTask = req.GetResponseAsync(service);
+
+            Task<WebResponse> wrappedTask = TimeoutHelper.GetTimeoutWrappedTask(timeout, serverTask);
+            return wrappedTask;
+        }
+
+        /// <summary>
+        /// Gets an asynchronous response to a given Web request.
+        /// </summary>
+        /// <param name="req">The requested that is used for operation.</param>
+        /// <param name="service">The service.</param>
+        /// <param name="timeout">The timeout.</param>
+        /// <returns>A task that yields the response.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<WebResponse> GetResponseAsyncWithTimeout(this WebRequest req, CloudTableClient service, TimeSpan? timeout)
+        {
+            Task<WebResponse> serverTask = req.GetResponseAsync(service);
+
+            Task<WebResponse> wrappedTask = TimeoutHelper.GetTimeoutWrappedTask(timeout, serverTask);
+            return wrappedTask;
+        }
+
+        /// <summary>
+        /// Gets an asynchronous request stream for a given Web request.
+        /// </summary>
+        /// <param name="req">The requested that is used for operation.</param>
+        /// <returns>A task that yields a stream.</returns>
+        [DebuggerNonUserCode]
+        internal static Task<Stream> GetRequestStreamAsync(this WebRequest req)
+        {
+            return new APMTask<Stream>(req.BeginGetRequestStream, req.EndGetRequestStream, req.Abort);
+        }
+
+        /// <summary>
+        /// Gets an asynchronous response to a given Web request.
+        /// </summary>
+        /// <param name="req">The requested that is used for operation.</param>
+        /// <param name="service">The service.</param>
+        /// <returns>A task that yields the response.</returns>
+        [DebuggerNonUserCode]
+        private static Task<WebResponse> GetResponseAsync(this WebRequest req, CloudBlobClient service)
+        {
+            return new APMTask<WebResponse>(
+                req.BeginGetResponse,
+                (asyncresult) => service.EndGetResponse(asyncresult, req),
+                req.Abort);
+        }
+
+        /// <summary>
+        /// Gets an asynchronous response to a given Web request.
+        /// </summary>
+        /// <param name="req">The requested that is used for operation.</param>
+        /// <param name="service">The service.</param>
+        /// <returns>A task that yields the response.</returns>
+        [DebuggerNonUserCode]
+        private static Task<WebResponse> GetResponseAsync(this WebRequest req, CloudQueueClient service)
+        {
+            return new APMTask<WebResponse>(
+                req.BeginGetResponse,
+                (asyncresult) => service.EndGetResponse(asyncresult, req),
+                req.Abort);
+        }
+
+        /// <summary>
+        /// Gets an asynchronous response to a given Web request.
+        /// </summary>
+        /// <param name="req">The requested that is used for operation.</param>
+        /// <param name="service">The service.</param>
+        /// <returns>A task that yields the response.</returns>
+        [DebuggerNonUserCode]
+        private static Task<WebResponse> GetResponseAsync(this WebRequest req, CloudTableClient service)
+        {
+            return new APMTask<WebResponse>(
+                req.BeginGetResponse,
+                (asyncresult) => service.EndGetResponse(asyncresult, req),
+                req.Abort);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/TraceHelper.cs b/microsoft-azure-api/StorageClient/TraceHelper.cs
new file mode 100644
index 0000000000000..4b3842fcb6034
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/TraceHelper.cs
@@ -0,0 +1,72 @@
+//-----------------------------------------------------------------------
+// <copyright file="TraceHelper.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the TraceHelper class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Diagnostics;
+    using System.Threading;
+
+    /// <summary>
+    /// Tracing helper class.
+    /// </summary>
+    internal class TraceHelper
+    {
+        /// <summary>
+        /// Internal flag for turning on tracing.
+        /// </summary>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage(
+            "Microsoft.StyleCop.CSharp.MaintainabilityRules",
+            "SA1401:FieldsMustBePrivate",
+            Justification = "Unable to change while remaining backwards compatible.")]
+        internal static bool TracingOn = false;
+
+        /// <summary>
+        /// Internal format string for trace messages.
+        /// </summary>
+        private const string InternalFormat = "Thread {0}, Tickcount {1}, ";
+
+        /// <summary>
+        /// Writes the line.
+        /// </summary>
+        /// <param name="format">The format.</param>
+        /// <param name="arg">The arguments.</param>
+        [Conditional("DEBUG")]
+        internal static void WriteLine(string format, params object[] arg)
+        {
+            if (TracingOn)
+            {
+                WriteLineInternal(format, arg);
+            }
+        }
+
+        /// <summary>
+        /// Writes the line internal.
+        /// </summary>
+        /// <param name="format">The format.</param>
+        /// <param name="arg">The arguments.</param>
+        private static void WriteLineInternal(string format, params object[] arg)
+        {
+            string traceString = string.Format(format, arg);
+            string internalTraceString = string.Format(InternalFormat + traceString, Thread.CurrentThread.ManagedThreadId, Environment.TickCount);
+            Debug.WriteLine(internalTraceString);
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageClient/Utilities.cs b/microsoft-azure-api/StorageClient/Utilities.cs
new file mode 100644
index 0000000000000..3f7f4f93b9594
--- /dev/null
+++ b/microsoft-azure-api/StorageClient/Utilities.cs
@@ -0,0 +1,581 @@
+//-----------------------------------------------------------------------
+// <copyright file="Utilities.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the Utilities class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure.StorageClient
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.IO;
+    using System.Linq;
+    using System.Net;
+    using System.Xml;
+    using System.Xml.Linq;
+    using Protocol;
+
+    /// <summary>
+    /// General purpose utility methods.
+    /// </summary>
+    internal static class Utilities
+    {
+        /// <summary>
+        /// This is the limit where we allow for the error message returned by the server.
+        /// Messages longer than that will be truncated. 
+        /// </summary>
+        private const int ErrorTextSizeLimit = 16 * 1024;
+
+        /// <summary>
+        /// Processes the unexpected status code.
+        /// </summary>
+        /// <param name="response">The response.</param>
+        internal static void ProcessUnexpectedStatusCode(HttpWebResponse response)
+        {
+            throw new StorageServerException(
+                        StorageErrorCode.ServiceBadResponse,
+                        response.StatusDescription,
+                        response.StatusCode,
+                        null);
+        }
+
+        /// <summary>
+        /// Translates the data service client exception.
+        /// </summary>
+        /// <param name="e">The exception.</param>
+        /// <returns>The translated exception.</returns>
+        internal static Exception TranslateDataServiceClientException(InvalidOperationException e)
+        {
+            var dsce = CommonUtils.FindInnerDataServiceClientException(e);
+
+            if (dsce == null)
+            {
+                return e;
+            }
+
+            return TranslateFromHttpStatus(
+                (HttpStatusCode)dsce.StatusCode,
+                null,
+                GetExtendedErrorFromXmlMessage(dsce.Message),
+                e);
+        }
+
+        /// <summary>
+        /// Translates the web exception.
+        /// </summary>
+        /// <param name="e">The exception.</param>
+        /// <returns>The translated exception.</returns>
+        internal static Exception TranslateWebException(Exception e)
+        {
+            WebException we = e as WebException;
+            if (null == we)
+            {
+                return e;
+            }
+
+            // If the response is not null, let's first see what the status code is.
+            if (we.Response != null)
+            {
+                HttpWebResponse response = (HttpWebResponse)we.Response;
+
+                StorageExtendedErrorInformation extendedError =
+                    GetExtendedErrorDetailsFromResponse(
+                            response.GetResponseStream(),
+                            response.ContentLength);
+                Exception translatedException = null;
+                if (extendedError != null)
+                {
+                    translatedException = TranslateExtendedError(
+                                                    extendedError,
+                                                    response.StatusCode,
+                                                    response.StatusDescription,
+                                                    e);
+
+                    if (translatedException != null)
+                    {
+                        return translatedException;
+                    }
+                }
+
+                translatedException = TranslateFromHttpStatus(
+                                            response.StatusCode,
+                                            response.StatusDescription,
+                                            extendedError,
+                                            we);
+
+                if (translatedException != null)
+                {
+                    return translatedException;
+                }
+            }
+
+            switch (we.Status)
+            {
+                case WebExceptionStatus.RequestCanceled:
+                    return new StorageServerException(
+                        StorageErrorCode.ServiceTimeout,
+                        "The server request did not complete within the specified timeout",
+                        HttpStatusCode.GatewayTimeout,
+                        we);
+
+                case WebExceptionStatus.ConnectFailure:
+                    return we;
+
+                default:
+                    return new StorageServerException(
+                        StorageErrorCode.ServiceInternalError,
+                        "The server encountered an unknown failure: " + e.Message,
+                        HttpStatusCode.InternalServerError,
+                        we);
+            }
+        }
+
+        /// <summary>
+        /// Gets the extended error details from response.
+        /// </summary>
+        /// <param name="httpResponseStream">The HTTP response stream.</param>
+        /// <param name="contentLength">Length of the content.</param>
+        /// <returns>The extended error information.</returns>
+        internal static StorageExtendedErrorInformation GetExtendedErrorDetailsFromResponse(
+            Stream httpResponseStream,
+            long contentLength)
+        {
+            try
+            {
+                if (contentLength < 0)
+                {
+                    contentLength = ErrorTextSizeLimit;
+                }
+
+                int bytesToRead = (int)Math.Min((long)contentLength, (long)ErrorTextSizeLimit);
+                byte[] responseBuffer = new byte[bytesToRead];
+                int bytesRead = CopyStreamToBuffer(httpResponseStream, responseBuffer, (int)bytesToRead);
+
+                using (var ms = new MemoryStream(responseBuffer, 0, bytesRead, false))
+                {
+                    return GetErrorDetailsFromStream(ms);
+                }
+            }
+            catch (WebException)
+            {
+                // Ignore network errors when reading error details.
+                return null;
+            }
+            catch (IOException)
+            {
+                return null;
+            }
+            catch (TimeoutException)
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the extended error from XML message.
+        /// </summary>
+        /// <param name="xmlErrorMessage">The XML error message.</param>
+        /// <returns>The extended error information.</returns>
+        internal static StorageExtendedErrorInformation GetExtendedErrorFromXmlMessage(string xmlErrorMessage)
+        {
+            string message = null;
+            string errorCode = null;
+
+            XName errorCodeName = XName.Get(
+                Constants.TableErrorCodeElement,
+                Constants.DataWebMetadataNamespace);
+            XName messageName = XName.Get(
+                Constants.TableErrorMessageElement,
+                Constants.DataWebMetadataNamespace);
+
+            using (StringReader reader = new StringReader(xmlErrorMessage))
+            {
+                XDocument xDocument = null;
+
+                try
+                {
+                    xDocument = XDocument.Load(reader);
+                }
+                catch (XmlException)
+                {
+                    // The XML could not be parsed. This could happen either because the connection 
+                    // could not be made to the server, or if the response did not contain the
+                    // error details (for example, if the response status code was neither a failure
+                    // nor a success, but a 3XX code such as NotModified.
+                    return null;
+                }
+
+                XElement errorCodeElement = xDocument.Descendants(errorCodeName).FirstOrDefault();
+
+                if (errorCodeElement == null)
+                {
+                    return null;
+                }
+
+                errorCode = errorCodeElement.Value;
+
+                XElement messageElement = xDocument.Descendants(messageName).FirstOrDefault();
+
+                if (messageElement != null)
+                {
+                    message = messageElement.Value;
+                }
+            }
+
+            StorageExtendedErrorInformation errorDetails = new StorageExtendedErrorInformation();
+            errorDetails.ErrorMessage = message;
+            errorDetails.ErrorCode = errorCode;
+            return errorDetails;
+        }
+
+        /// <summary>
+        /// Copies the stream to buffer.
+        /// </summary>
+        /// <param name="sourceStream">The source stream.</param>
+        /// <param name="buffer">The buffer.</param>
+        /// <param name="bytesToRead">The bytes to read.</param>
+        /// <returns>The number of bytes copied.</returns>
+        internal static int CopyStreamToBuffer(Stream sourceStream, byte[] buffer, int bytesToRead)
+        {
+            int n = 0;
+            int amountLeft = bytesToRead;
+
+            do
+            {
+                n = sourceStream.Read(buffer, bytesToRead - amountLeft, amountLeft);
+                amountLeft -= n;
+            }
+            while (n > 0);
+
+            return bytesToRead - amountLeft;
+        }
+
+        /// <summary>
+        /// Translates from HTTP status.
+        /// </summary>
+        /// <param name="statusCode">The status code.</param>
+        /// <param name="statusDescription">The status description.</param>
+        /// <param name="details">The details.</param>
+        /// <param name="inner">The inner.</param>
+        /// <returns>The translated exception.</returns>
+        internal static Exception TranslateFromHttpStatus(
+                    HttpStatusCode statusCode,
+                    string statusDescription,
+                    StorageExtendedErrorInformation details,
+                    Exception inner)
+        {
+            switch (statusCode)
+            {
+                case HttpStatusCode.Forbidden:
+                    return new StorageClientException(
+                        StorageErrorCode.AccessDenied,
+                        statusDescription,
+                        HttpStatusCode.Forbidden,
+                        details,
+                        inner);
+
+                case HttpStatusCode.Gone:
+                case HttpStatusCode.NotFound:
+                    return new StorageClientException(
+                        StorageErrorCode.ResourceNotFound,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.BadRequest:
+                    return new StorageClientException(
+                        StorageErrorCode.BadRequest,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.PreconditionFailed:
+                case HttpStatusCode.NotModified:
+                    return new StorageClientException(
+                        StorageErrorCode.ConditionFailed,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.Conflict:
+                    return new StorageClientException(
+                        StorageErrorCode.ResourceAlreadyExists,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.GatewayTimeout:
+                    return new StorageServerException(
+                        StorageErrorCode.ServiceTimeout,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.RequestedRangeNotSatisfiable:
+                    return new StorageClientException(
+                        StorageErrorCode.BadRequest,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.InternalServerError:
+                    return new StorageServerException(
+                        StorageErrorCode.ServiceInternalError,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.NotImplemented:
+                    return new StorageServerException(
+                        StorageErrorCode.NotImplemented,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.BadGateway:
+                    return new StorageServerException(
+                        StorageErrorCode.BadGateway,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+
+                case HttpStatusCode.HttpVersionNotSupported:
+                    return new StorageServerException(
+                        StorageErrorCode.HttpVersionNotSupported,
+                        statusDescription,
+                        statusCode,
+                        details,
+                        inner);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Extracts an MD5 value from either an v1 or v2 block id.
+        /// </summary>
+        /// <param name="blockId">The block id containing an MD5.</param>
+        /// <returns>MD5 value, or null if invalid format.</returns>
+        internal static string ExtractMD5ValueFromBlockID(string blockId)
+        {
+            if (blockId == null)
+            {
+                return null;
+            }
+
+            if (blockId.Length == Constants.V2MD5blockIdExpectedLength && blockId.StartsWith(Constants.V2blockPrefix))
+            {
+                return blockId.Substring(Constants.V2MD5blockIdMD5Offset);
+            }
+            else if (blockId.Length == Constants.V1MD5blockIdExpectedLength && blockId.StartsWith(Constants.V1BlockPrefix))
+            {
+                return blockId.Substring(Constants.V1BlockPrefix.Length);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Generates an block id using the given MD5 hash value. The id must be Base64 compatible.
+        /// </summary>
+        /// <param name="hashVal">The hash value to encode in the block id.</param>
+        /// <param name="seqNo">The sequence prefix value.</param>
+        /// <returns>The block id.</returns>
+        internal static string GenerateBlockIDWithHash(string hashVal, long seqNo)
+        {
+            byte[] tempArray = new byte[6];
+
+            for (int m = 0; m < 6; m++)
+            {
+                tempArray[5 - m] = (byte)((seqNo >> (8 * m)) & 0xFF);
+            }
+
+            Convert.ToBase64String(tempArray);
+            
+            return String.Format(Protocol.Constants.V2MD5blockIdFormat, Convert.ToBase64String(tempArray), hashVal);                  
+        }
+
+        /// <summary>
+        /// Translates the extended error.
+        /// </summary>
+        /// <param name="details">The details.</param>
+        /// <param name="statusCode">The status code.</param>
+        /// <param name="statusDescription">The status description.</param>
+        /// <param name="inner">The inner exception.</param>
+        /// <returns>The translated exception.</returns>
+        private static Exception TranslateExtendedError(
+                    StorageExtendedErrorInformation details,
+                    HttpStatusCode statusCode,
+                    string statusDescription,
+                    Exception inner)
+        {
+            StorageErrorCode errorCode = default(StorageErrorCode);
+
+            switch (details.ErrorCode)
+            {
+                case StorageErrorCodeStrings.UnsupportedHttpVerb:
+                case StorageErrorCodeStrings.MissingContentLengthHeader:
+                case StorageErrorCodeStrings.MissingRequiredHeader:
+                case StorageErrorCodeStrings.UnsupportedHeader:
+                case StorageErrorCodeStrings.InvalidHeaderValue:
+                case StorageErrorCodeStrings.MissingRequiredQueryParameter:
+                case StorageErrorCodeStrings.UnsupportedQueryParameter:
+                case StorageErrorCodeStrings.InvalidQueryParameterValue:
+                case StorageErrorCodeStrings.OutOfRangeQueryParameterValue:
+                case StorageErrorCodeStrings.InvalidUri:
+                case StorageErrorCodeStrings.InvalidHttpVerb:
+                case StorageErrorCodeStrings.EmptyMetadataKey:
+                case StorageErrorCodeStrings.RequestBodyTooLarge:
+                case StorageErrorCodeStrings.InvalidXmlDocument:
+                case StorageErrorCodeStrings.InvalidXmlNodeValue:
+                case StorageErrorCodeStrings.MissingRequiredXmlNode:
+                case StorageErrorCodeStrings.InvalidMd5:
+                case StorageErrorCodeStrings.OutOfRangeInput:
+                case StorageErrorCodeStrings.InvalidInput:
+                case StorageErrorCodeStrings.InvalidMetadata:
+                case StorageErrorCodeStrings.MetadataTooLarge:
+                case StorageErrorCodeStrings.InvalidRange:
+                    errorCode = StorageErrorCode.BadRequest;
+                    break;
+                case StorageErrorCodeStrings.AuthenticationFailed:
+                    errorCode = StorageErrorCode.AuthenticationFailure;
+                    break;
+                case StorageErrorCodeStrings.ResourceNotFound:
+                    errorCode = StorageErrorCode.ResourceNotFound;
+                    break;
+                case StorageErrorCodeStrings.ConditionNotMet:
+                    errorCode = StorageErrorCode.ConditionFailed;
+                    break;
+                case StorageErrorCodeStrings.ContainerAlreadyExists:
+                    errorCode = StorageErrorCode.ContainerAlreadyExists;
+                    break;
+                case StorageErrorCodeStrings.ContainerNotFound:
+                    errorCode = StorageErrorCode.ContainerNotFound;
+                    break;
+                case BlobErrorCodeStrings.BlobNotFound:
+                    errorCode = StorageErrorCode.BlobNotFound;
+                    break;
+                case BlobErrorCodeStrings.BlobAlreadyExists:
+                    errorCode = StorageErrorCode.BlobAlreadyExists;
+                    break;
+            }
+
+            if (errorCode != default(StorageErrorCode))
+            {
+                return new StorageClientException(
+                                errorCode,
+                                statusDescription,
+                                statusCode,
+                                details,
+                                inner);
+            }
+
+            switch (details.ErrorCode)
+            {
+                case StorageErrorCodeStrings.InternalError:
+                case StorageErrorCodeStrings.ServerBusy:
+                    errorCode = StorageErrorCode.ServiceInternalError;
+                    break;
+                case StorageErrorCodeStrings.Md5Mismatch:
+                    errorCode = StorageErrorCode.ServiceIntegrityCheckFailed;
+                    break;
+                case StorageErrorCodeStrings.OperationTimedOut:
+                    errorCode = StorageErrorCode.ServiceTimeout;
+                    break;
+            }
+
+            if (errorCode != default(StorageErrorCode))
+            {
+                return new StorageServerException(
+                    errorCode,
+                    statusDescription,
+                    statusCode,
+                    details,
+                    inner);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets the error details from stream.
+        /// </summary>
+        /// <param name="inputStream">The input stream.</param>
+        /// <returns>The error details.</returns>
+        private static StorageExtendedErrorInformation GetErrorDetailsFromStream(Stream inputStream)
+        {
+            StorageExtendedErrorInformation extendedError = new StorageExtendedErrorInformation();
+
+            try
+            {
+                using (XmlReader reader = XmlReader.Create(inputStream))
+                {
+                    reader.Read();
+                    reader.ReadStartElement(Constants.ErrorRootElement);
+                    extendedError.ErrorCode = reader.ReadElementString(Constants.ErrorCode);
+                    extendedError.ErrorMessage = reader.ReadElementString(Constants.ErrorMessage);
+                    extendedError.AdditionalDetails = new NameValueCollection();
+
+                    // After error code and message we can have a number of additional details optionally followed
+                    // by ExceptionDetails element - we'll read all of these into the additionalDetails collection
+                    do
+                    {
+                        if (reader.IsStartElement())
+                        {
+                            if (string.Compare(reader.LocalName, Constants.ErrorException, StringComparison.Ordinal) == 0)
+                            {
+                                // Need to read exception details - we have message and stack trace
+                                reader.ReadStartElement(Constants.ErrorException);
+
+                                extendedError.AdditionalDetails.Add(
+                                    Constants.ErrorExceptionMessage,
+                                    reader.ReadElementString(Constants.ErrorExceptionMessage));
+                                extendedError.AdditionalDetails.Add(
+                                    Constants.ErrorExceptionStackTrace,
+                                    reader.ReadElementString(Constants.ErrorExceptionStackTrace));
+
+                                reader.ReadEndElement();
+                            }
+                            else
+                            {
+                                string elementName = reader.LocalName;
+                                extendedError.AdditionalDetails.Add(elementName, reader.ReadString());
+                            }
+                        }
+                    }
+                    while (reader.Read());
+                }
+            }
+            catch (XmlException)
+            {
+                // If there is a parsing error we cannot return extended error information
+                return null;
+            }
+
+            return extendedError;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageCredentials.cs b/microsoft-azure-api/StorageCredentials.cs
new file mode 100644
index 0000000000000..b80ba4500b8f9
--- /dev/null
+++ b/microsoft-azure-api/StorageCredentials.cs
@@ -0,0 +1,108 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageCredentials.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageCredentials class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure
+{
+    using System.Net;
+
+    /// <summary>
+    /// Represents a set of credentials used to authenticate access to a Windows Azure storage account.
+    /// </summary>
+    public abstract class StorageCredentials
+    {
+        /// <summary>
+        /// Gets the name of the storage account associated with the specified credentials.
+        /// </summary>
+        /// <value>The name of the account.</value>
+        public abstract string AccountName { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="TransformUri"/> method should be called
+        /// to transform a resource URI to a URI that includes a token for a shared access signature.
+        /// </summary>
+        /// <value><c>True</c> if the URI must be transformed; otherwise, <c>false</c>.</value>
+        public abstract bool NeedsTransformUri { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key authentication 
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value><c>True</c> if a request can be signed with these credentials; otherwise, <c>false</c>.</value>
+        public abstract bool CanSignRequest { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key Lite authentication
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value><c>True</c> if a request can be signed with these credentials; otherwise, <c>false</c>.</value>
+        public abstract bool CanSignRequestLite { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="ComputeHmac"/> method will return a valid
+        /// HMAC-encoded signature string when called using the specified credentials.
+        /// </summary>
+        /// <value><c>True</c> if these credentials will yield a valid signature string; otherwise, <c>false</c>.</value>
+        public abstract bool CanComputeHmac { get; }
+
+        /// <summary>
+        /// Transforms a resource URI into a shared access signature URI, by appending a
+        /// shared access token. 
+        /// </summary>
+        /// <param name="resourceUri">The resource URI to be transformed.</param>
+        /// <returns>The URI for a shared access signature, including the resource URI and the shared access token. </returns>
+        public abstract string TransformUri(string resourceUri);
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key authentication scheme.
+        /// </summary>
+        /// <param name="request">The web request to be signed.</param>
+        public abstract void SignRequest(HttpWebRequest request);
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key Lite authentication scheme.
+        /// </summary>
+        /// <param name="request">The web request to be signed.</param>
+        public abstract void SignRequestLite(HttpWebRequest request);
+
+        /// <summary>
+        /// Encodes a Shared Key or Shared Key Lite signature string by using the HMAC-SHA256 algorithm over a UTF-8-encoded string-to-sign.
+        /// </summary>
+        /// <param name="value">A UTF-8-encoded string-to-sign.</param>
+        /// <returns>An HMAC-encoded signature string.</returns>
+        public abstract string ComputeHmac(string value);
+
+        /// <summary>
+        /// Performs the computation of the signature based on the private key.
+        /// </summary>
+        /// <param name="value">The string to be signed.</param>
+        /// <returns>The signature for the string.</returns>
+        /// <remarks> Need for D-SAS not public.</remarks>
+        protected internal abstract string ComputeHmac512(string value);
+
+        /// <summary>
+        /// Returns a <see cref="System.String"/> that represents this instance.
+        /// </summary>
+        /// <param name="exportSecrets">If set to <c>true</c> exports secrets.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> that represents this instance.
+        /// </returns>
+        protected internal abstract string ToString(bool exportSecrets);
+    }
+}
\ No newline at end of file
diff --git a/microsoft-azure-api/StorageCredentialsAccountAndKey.cs b/microsoft-azure-api/StorageCredentialsAccountAndKey.cs
new file mode 100644
index 0000000000000..10fec0aafd439
--- /dev/null
+++ b/microsoft-azure-api/StorageCredentialsAccountAndKey.cs
@@ -0,0 +1,185 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageCredentialsAccountAndKey.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageCredentialsAccountAndKey class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure
+{
+    using System;
+    using System.Net;
+    using Microsoft.WindowsAzure.StorageClient.Protocol;
+
+    /// <summary>
+    /// Represents storage account credentials for accessing the Windows Azure storage services.
+    /// </summary>
+    public sealed class StorageCredentialsAccountAndKey : StorageCredentials
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageCredentialsAccountAndKey"/> class, using the storage account name and 
+        /// access key.
+        /// </summary>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <param name="key">The account access key, as an array of bytes.</param>
+        public StorageCredentialsAccountAndKey(string accountName, byte[] key)
+        {
+            this.Credentials = new Credentials(accountName, key);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageCredentialsAccountAndKey"/> class, using the storage account name and 
+        /// access key.
+        /// </summary>
+        /// <param name="accountName">The name of the storage account.</param>
+        /// <param name="key">The account access key, as a Base64-encoded string.</param>
+        public StorageCredentialsAccountAndKey(string accountName, string key)
+        {
+            this.Credentials = new Credentials(accountName, key);
+        }
+
+        /// <summary>
+        /// Gets a <see cref="Credentials"/> object that references the storage account name and access key.
+        /// </summary>
+        /// <value>An object containing a reference to the storage account name and access key.</value>
+        public Credentials Credentials { get; internal set; }
+
+        /// <summary>
+        /// Gets the name of the storage account associated with the specified credentials.
+        /// </summary>
+        /// <value>The name of the storage account.</value>
+        public override string AccountName
+        {
+            get { return Credentials.AccountName; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="TransformUri"/> method should be called
+        /// to transform a resource URI to a URI that includes a token for a shared access signature.
+        /// </summary>
+        /// <value><c>False</c> for objects of type <see cref="StorageCredentialsAccountAndKey"/>.</value>
+         public override bool NeedsTransformUri
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key authentication
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value><c>True</c> for objects of type <see cref="StorageCredentialsAccountAndKey"/>.</value>
+        public override bool CanSignRequest
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key Lite authentication
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value><c>True</c> for objects of type <see cref="StorageCredentialsAccountAndKey"/>.</value>
+        public override bool CanSignRequestLite
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="ComputeHmac"/> method will return a valid
+        /// HMAC-encoded signature string when called using the specified credentials.
+        /// </summary>
+        /// <value><c>True</c> for objects of type <see cref="StorageCredentialsAccountAndKey"/>.</value>
+        public override bool CanComputeHmac
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Transforms a resource URI into a shared access signature URI, by appending a
+        /// shared access token. For objects of type <see cref="StorageCredentialsAccountAndKey"/>, this operation
+        /// returns the resource URI that is passed to it..
+        /// </summary>
+        /// <param name="resourceUri">The resource URI to be transformed.</param>
+        /// <returns>The URI for a shared access signature, including the resource URI and the shared access token.</returns>
+        public override string TransformUri(string resourceUri)
+        {
+            return resourceUri;
+        }
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key authentication scheme.
+        /// </summary>
+        /// <param name="request">The web request to be signed.</param>
+        public override void SignRequest(HttpWebRequest request)
+        {
+            Request.SignRequestForBlobAndQueue(request, Credentials);
+        }
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key Lite authentication scheme.
+        /// </summary>
+        /// <param name="request">The web request to be signed.</param>
+        public override void SignRequestLite(HttpWebRequest request)
+        {
+            Request.SignRequestForTablesSharedKeyLite(request, Credentials);            
+        }
+
+        /// <summary>
+        /// Encodes a Shared Key or Shared Key Lite signature string by using the HMAC-SHA256 algorithm over a UTF-8-encoded string-to-sign.
+        /// </summary>
+        /// <param name="value">A UTF-8-encoded string-to-sign.</param>
+        /// <returns>An HMAC-encoded signature string.</returns>
+        public override string ComputeHmac(string value)
+        {
+            return StorageKey.ComputeMacSha256(Credentials.Key, value);
+        }
+
+        /// <summary>
+        /// Gets the base64 encoded key.
+        /// </summary>
+        /// <returns>The base64 encoded key.</returns>
+        internal string GetBase64EncodedKey()
+        {
+            return Credentials.Key.GetBase64EncodedKey();
+        }
+
+        /// <summary>
+        /// Performs the computation of the signature based on the private key.
+        /// </summary>
+        /// <param name="value">The string that should be signed.</param>
+        /// <returns>The signature for the string.</returns>
+        protected internal override string ComputeHmac512(string value)
+        {
+            return StorageKey.ComputeMacSha512(Credentials.Key, value);
+        }
+
+        /// <summary>
+        /// Returns a <see cref="System.String"/> that represents this instance.
+        /// </summary>
+        /// <param name="exportSecrets">If set to <c>true</c> exports secrets.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> that represents this instance.
+        /// </returns>
+        protected internal override string ToString(bool exportSecrets)
+        {
+            return String.Format(
+                "{0}={1};{2}={3}",
+                CloudStorageAccount.AccountNameName,
+                this.AccountName,
+                CloudStorageAccount.AccountKeyName,
+                exportSecrets ? this.GetBase64EncodedKey() : "[key hidden]");
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageCredentialsAnonymous.cs b/microsoft-azure-api/StorageCredentialsAnonymous.cs
new file mode 100644
index 0000000000000..cdd3119abf0aa
--- /dev/null
+++ b/microsoft-azure-api/StorageCredentialsAnonymous.cs
@@ -0,0 +1,162 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageCredentialsAnonymous.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageCredentialsAnonymous class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure
+{
+    using System;
+    using System.Net;
+
+    /// <summary>
+    /// Class that represents credentials for anonymous access. Used by internal implementaion.
+    /// </summary>
+    internal sealed class StorageCredentialsAnonymous : StorageCredentials
+    {
+        /// <summary>
+        /// Stores the singleton instance of this class.
+        /// </summary>
+        public static readonly StorageCredentials Anonymous = new StorageCredentialsAnonymous();
+
+        /// <summary>
+        /// Prevents a default instance of the <see cref="StorageCredentialsAnonymous"/> class from being created.
+        /// </summary>
+        private StorageCredentialsAnonymous()
+        {
+        }
+
+        /// <summary>
+        /// Gets account name information if available. Else returns null.
+        /// </summary>
+        public override string AccountName
+        {
+            get { return null; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="TransformUri"/> method must be called
+        /// before generating a signature string with the specified credentials.
+        /// </summary>
+        /// <value>
+        /// Is <c>true</c> if needs transform Uri; otherwise, <c>false</c>. If <c>false</c>,
+        /// calling <see cref="TransformUri"/> returns the original, unmodified Uri.
+        /// </value>
+        public override bool NeedsTransformUri
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether SignRequest will perform signing when using this credentials.
+        /// False means SignRequest will not do anything.
+        /// </summary>
+        /// <value>
+        /// Is <c>true</c> if a request can be signed with these credentials; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanSignRequest
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Returns whether SignRequestLite will perform signing when using this credentials. 
+        /// False means SignRequestLite will not do anything.
+        /// </summary>
+        public override bool CanSignRequestLite
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Returns whether ComputeHMAC will return a valid HMAC when using this credentials.
+        /// False means ComputeHmac will return null.
+        /// </summary>
+        /// <value>
+        /// Returns <c>true</c> if these credentials will yield a valid signature string; otherwise, <c>false</c>.
+        /// </value>
+        public override bool CanComputeHmac
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// A potential transformation to the Uri for signing purposes. The transformation may append to the string.
+        /// </summary>
+        /// <param name="resourceUri">The resource Uri to be transformed.</param>
+        /// <returns>The new resource Uri that includes any transformations required for signing.</returns>
+        /// <remarks>Identity operation for anonymous access.</remarks>
+        public override string TransformUri(string resourceUri)
+        {
+            return resourceUri;
+        }
+
+        /// <summary>
+        /// An operation that may add any required authentication headers based for the credential type. (SharedKey algorithm).
+        /// </summary>
+        /// <param name="request">The request that needs to be signed.</param>
+        /// <remarks>No op for anonymous access.</remarks>
+        public override void SignRequest(HttpWebRequest request)
+        { 
+            // No op 
+        }
+
+        /// <summary>
+        /// An operation that may add any required authentication headers based for the credential type. (SharedKeyLite algorithm used for LINQ for Tables).
+        /// </summary>
+        /// <param name="request">The request that needs to be signed.</param>
+        /// <remarks>No op for anonymous access.</remarks>
+        public override void SignRequestLite(HttpWebRequest request)
+        { 
+            // No op
+        }
+
+        /// <summary>
+        /// Performs the computation of the signature based on the private key.
+        /// </summary>
+        /// <param name="value">The string that should be signed.</param>
+        /// <returns>The signature for the string.</returns>
+        /// <remarks>Returns null representing no op.</remarks>
+        public override string ComputeHmac(string value)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Performs the computation of the signature based on the private key.
+        /// </summary>
+        /// <param name="value">The string to be signed.</param>
+        /// <returns>The signature for the string.</returns>
+        /// <remarks> Need for D-SAS not public.</remarks>
+        protected internal override string ComputeHmac512(string value)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="System.String"/> that represents this instance.
+        /// </summary>
+        /// <param name="exportSecrets">If set to <c>true</c> exports secrets.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> that represents this instance.
+        /// </returns>
+        protected internal override string ToString(bool exportSecrets)
+        {
+            return String.Empty;
+        }
+    }
+}
diff --git a/microsoft-azure-api/StorageCredentialsSharedAccessSignature.cs b/microsoft-azure-api/StorageCredentialsSharedAccessSignature.cs
new file mode 100644
index 0000000000000..706aed6e5ebbf
--- /dev/null
+++ b/microsoft-azure-api/StorageCredentialsSharedAccessSignature.cs
@@ -0,0 +1,190 @@
+//-----------------------------------------------------------------------
+// <copyright file="StorageCredentialsSharedAccessSignature.cs" company="Microsoft">
+//    Copyright 2011 Microsoft Corporation
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// </copyright>
+// <summary>
+//    Contains code for the StorageCredentialsSharedAccessSignature class.
+// </summary>
+//-----------------------------------------------------------------------
+
+namespace Microsoft.WindowsAzure
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Net;
+    using System.Web;
+    using Microsoft.WindowsAzure.StorageClient.Protocol;
+
+    /// <summary>
+    /// Represents storage credentials for delegated access to Blob service resources
+    /// via a shared access signature. 
+    /// </summary>
+    public class StorageCredentialsSharedAccessSignature : StorageCredentials
+    {
+        /// <summary>
+        /// Stores the shared access signature token.
+        /// </summary>
+        private string token;
+
+        /// <summary>
+        /// Stores the internal <see cref="UriQueryBuilder"/> used to transform Uris.
+        /// </summary>
+        private UriQueryBuilder builder = new UriQueryBuilder();
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StorageCredentialsSharedAccessSignature"/> class 
+        /// with the specified shared access token.
+        /// </summary>
+        /// <param name="token">A string token representing a shared access signature.</param>
+        public StorageCredentialsSharedAccessSignature(string token)
+        {
+            NameValueCollection parameters = HttpUtility.ParseQueryString(token);
+
+            for (int index = 0; index < parameters.Count; index++)
+            {
+                this.builder.Add(parameters.Keys[index], parameters[index]);
+            }
+
+            this.token = token;
+        }
+
+        /// <summary>
+        /// Gets the name of the storage account associated with the specified credentials.
+        /// </summary>
+        /// <value>The name of the account.</value>
+        public override string AccountName
+        {
+            get { return null; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="TransformUri"/> method should be called
+        /// to transform a resource URI to a URI that includes a token for a shared access signature.
+        /// </summary>
+        /// <value><c>True</c> for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.</value>
+        public override bool NeedsTransformUri
+        {
+            get { return true; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key authentication
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value><c>False</c> for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.</value>
+        public override bool CanSignRequest
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether a request can be signed under the Shared Key Lite authentication
+        /// scheme using the specified credentials.
+        /// </summary>
+        /// <value><c>False</c> for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.</value>
+        public override bool CanSignRequestLite
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether the <see cref="ComputeHmac"/> method will return a valid
+        /// HMAC-encoded signature string when called using the specified credentials.
+        /// </summary>
+        /// <value><c>False</c> for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.</value>
+        public override bool CanComputeHmac
+        {
+            get { return false; }
+        }
+
+        /// <summary>
+        /// Gets the token.
+        /// </summary>
+        /// <value>The token.</value>
+        internal string Token
+        {
+            get
+            {
+                return this.token;
+            }
+        }
+
+        /// <summary>
+        /// Transforms a resource URI into a shared access signature URI, by appending a
+        /// shared access token.
+        /// </summary>
+        /// <param name="resourceUri">The resource URI to be transformed.</param>
+        /// <returns>The URI for a shared access signature, including the resource URI and the shared access token.</returns>
+        public override string TransformUri(string resourceUri)
+        {
+            // Simply concatenating token will not work if the uri has other parameters
+            Uri transformedUri = this.builder.AddToUri(new Uri(resourceUri, UriKind.RelativeOrAbsolute));
+            return transformedUri.AbsoluteUri;            
+        }
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key authentication scheme.
+        /// This is not a valid operation for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.
+        /// </summary>
+        /// <param name="request">The web request to be signed.</param>
+        public override void SignRequest(HttpWebRequest request)
+        {
+            return; // No-op
+        }
+
+        /// <summary>
+        /// Signs a request using the specified credentials under the Shared Key Lite authentication scheme.
+        /// This is not a valid operation for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.
+        /// </summary>
+        /// <param name="request">The web request object to be signed.</param>
+        public override void SignRequestLite(HttpWebRequest request)
+        {
+            return; // No-op
+        }
+
+        /// <summary>
+        /// Encodes a Shared Key or Shared Key Lite signature string by using the HMAC-SHA256 algorithm over a UTF-8-encoded string-to-sign. 
+        /// This is not a valid operation for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.
+        /// </summary>
+        /// <param name="value">A UTF-8-encoded string-to-sign.</param>
+        /// <returns><c>Null</c> for objects of type <see cref="StorageCredentialsSharedAccessSignature"/>.</returns>
+        public override string ComputeHmac(string value)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Encodes the signature string by using the HMAC-SHA-512 algorithm over 
+        /// the UTF-8-encoded string-to-sign.
+        /// </summary>
+        /// <param name="value">The UTF-8-encoded string-to-sign.</param>
+        /// <returns>The HMAC-encoded signature string.</returns>
+        protected internal override string ComputeHmac512(string value)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="System.String"/> that represents this instance.
+        /// </summary>
+        /// <param name="exportSecrets">If set to <c>true</c> exports secrets.</param>
+        /// <returns>
+        /// A <see cref="System.String"/> that represents this instance.
+        /// </returns>
+        protected internal override string ToString(bool exportSecrets)
+        {
+            return String.Format("{0}={1}", CloudStorageAccount.SharedAccessSignatureName, exportSecrets ? this.token : "[signature hidden]");
+        }
+    }
+}
diff --git a/microsoft-azure-api/makefile b/microsoft-azure-api/makefile
new file mode 100644
index 0000000000000..677821a02b63c
--- /dev/null
+++ b/microsoft-azure-api/makefile
@@ -0,0 +1,18 @@
+#   Copyright 2011 Microsoft Corporation
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+# DO NOT EDIT THIS FILE.  Modify the project file in this directory.
+# This file allows the project to be built with MSBuild via build.exe.
+#
+!INCLUDE $(NTMAKEENV)\msbuild.def