diff --git a/sdk/storage/inc/blobs/protocol/blob_rest_client.hpp b/sdk/storage/inc/blobs/protocol/blob_rest_client.hpp
index aa55cb13a..0d8702452 100644
--- a/sdk/storage/inc/blobs/protocol/blob_rest_client.hpp
+++ b/sdk/storage/inc/blobs/protocol/blob_rest_client.hpp
@@ -13,7 +13,6 @@
 #include "response.hpp"
 
 #include <cstring>
-#include <functional>
 #include <limits>
 #include <map>
 #include <set>
@@ -24,10 +23,6 @@
 
 namespace Azure { namespace Storage { namespace Blobs {
 
-  using BodyStreamPointer = std::unique_ptr<
-      Azure::Core::Http::BodyStream,
-      std::function<void(Azure::Core::Http::BodyStream*)>>;
-
   constexpr static const char* c_APIVersion = "2019-12-12";
 
   struct AbortCopyBlobInfo
@@ -1001,12 +996,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         ListBlobContainersIncludeOption IncludeMetadata = ListBlobContainersIncludeOption::None;
       }; // struct ListBlobContainersOptions
 
-      static Azure::Core::Http::Request ListBlobContainersConstructRequest(
+      static Azure::Core::Response<ListContainersSegment> ListBlobContainers(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const ListBlobContainersOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -1032,14 +1027,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddQueryParameter("include", list_blob_containers_include_option);
         }
-        return request;
-      }
-
-      static Azure::Core::Response<ListContainersSegment> ListBlobContainersParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         ListContainersSegment response;
         auto http_status_code
@@ -1047,41 +1035,18 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         {
-          auto bodyStream = httpResponse.GetBodyStream();
-          std::vector<uint8_t> bodyContent;
-          if (bodyStream->Length() == -1)
-          {
-            bodyContent = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
-          }
-          else
-          {
-            bodyContent.resize(static_cast<std::size_t>(bodyStream->Length()));
-            Azure::Core::Http::BodyStream::ReadToCount(
-                context, *bodyStream, &bodyContent[0], bodyStream->Length());
-          }
-          XmlReader reader(reinterpret_cast<const char*>(bodyContent.data()), bodyContent.size());
+          const auto& httpResponseBody = httpResponse.GetBody();
+          XmlReader reader(
+              reinterpret_cast<const char*>(httpResponseBody.data()), httpResponseBody.size());
           response = ListContainersSegmentFromXml(reader);
         }
         return Azure::Core::Response<ListContainersSegment>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<ListContainersSegment> ListBlobContainers(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const ListBlobContainersOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = ListBlobContainersConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return ListBlobContainersParseResponse(context, std::move(pResponse));
-      }
-
       struct GetUserDelegationKeyOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -1089,9 +1054,10 @@ namespace Azure { namespace Storage { namespace Blobs {
         std::string ExpiresOn;
       }; // struct GetUserDelegationKeyOptions
 
-      static Azure::Core::Http::Request GetUserDelegationKeyConstructRequest(
+      static Azure::Core::Response<UserDelegationKey> GetUserDelegationKey(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const GetUserDelegationKeyOptions& options)
       {
         std::string xml_body;
@@ -1100,15 +1066,11 @@ namespace Azure { namespace Storage { namespace Blobs {
           GetUserDelegationKeyOptionsToXml(writer, options);
           xml_body = writer.GetDocument();
         }
-        std::shared_ptr<std::string> xml_body_ptr
-            = std::make_shared<std::string>(std::move(xml_body));
-        body = BodyStreamPointer(
-            new Azure::Core::Http::MemoryBodyStream(
-                reinterpret_cast<const uint8_t*>(xml_body_ptr->data()), xml_body_ptr->length()),
-            [xml_body_ptr](Azure::Core::Http::BodyStream* bodyStream) { delete bodyStream; });
-        auto request
-            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Post, url, body.get());
-        request.AddHeader("Content-Length", std::to_string(body->Length()));
+        Azure::Core::Http::MemoryBodyStream xml_body_stream(
+            reinterpret_cast<const uint8_t*>(xml_body.data()), xml_body.length());
+        auto request = Azure::Core::Http::Request(
+            Azure::Core::Http::HttpMethod::Post, url, &xml_body_stream);
+        request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length()));
         request.AddQueryParameter("restype", "service");
         request.AddQueryParameter("comp", "userdelegationkey");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -1116,14 +1078,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddQueryParameter("timeout", std::to_string(options.Timeout.GetValue()));
         }
-        return request;
-      }
-
-      static Azure::Core::Response<UserDelegationKey> GetUserDelegationKeyParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         UserDelegationKey response;
         auto http_status_code
@@ -1131,41 +1086,18 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         {
-          auto bodyStream = httpResponse.GetBodyStream();
-          std::vector<uint8_t> bodyContent;
-          if (bodyStream->Length() == -1)
-          {
-            bodyContent = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
-          }
-          else
-          {
-            bodyContent.resize(static_cast<std::size_t>(bodyStream->Length()));
-            Azure::Core::Http::BodyStream::ReadToCount(
-                context, *bodyStream, &bodyContent[0], bodyStream->Length());
-          }
-          XmlReader reader(reinterpret_cast<const char*>(bodyContent.data()), bodyContent.size());
+          const auto& httpResponseBody = httpResponse.GetBody();
+          XmlReader reader(
+              reinterpret_cast<const char*>(httpResponseBody.data()), httpResponseBody.size());
           response = UserDelegationKeyFromXml(reader);
         }
         return Azure::Core::Response<UserDelegationKey>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<UserDelegationKey> GetUserDelegationKey(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const GetUserDelegationKeyOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = GetUserDelegationKeyConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return GetUserDelegationKeyParseResponse(context, std::move(pResponse));
-      }
-
     private:
       static ListContainersSegment ListContainersSegmentFromXml(XmlReader& reader)
       {
@@ -1601,12 +1533,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         std::map<std::string, std::string> Metadata;
       }; // struct CreateOptions
 
-      static Azure::Core::Http::Request CreateConstructRequest(
+      static Azure::Core::Response<BlobContainerInfo> Create(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const CreateOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("restype", "container");
@@ -1634,14 +1566,7 @@ namespace Azure { namespace Storage { namespace Blobs {
           request.AddHeader(
               "x-ms-blob-public-access", PublicAccessTypeToString(options.AccessType.GetValue()));
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobContainerInfo> CreateParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobContainerInfo response;
         auto http_status_code
@@ -1649,7 +1574,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -1657,19 +1582,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobContainerInfo> Create(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const CreateOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = CreateConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return CreateParseResponse(context, std::move(pResponse));
-      }
-
       struct DeleteOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -1678,12 +1590,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfUnmodifiedSince;
       }; // struct DeleteOptions
 
-      static Azure::Core::Http::Request DeleteConstructRequest(
+      static Azure::Core::Response<DeleteContainerInfo> Delete(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const DeleteOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url);
         request.AddQueryParameter("restype", "container");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -1703,14 +1615,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-Unmodified-Since", options.IfUnmodifiedSince.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<DeleteContainerInfo> DeleteParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         DeleteContainerInfo response;
         auto http_status_code
@@ -1718,25 +1623,12 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 202))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         return Azure::Core::Response<DeleteContainerInfo>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<DeleteContainerInfo> Delete(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const DeleteOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = DeleteConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return DeleteParseResponse(context, std::move(pResponse));
-      }
-
       struct GetPropertiesOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -1746,12 +1638,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> LeaseId;
       }; // struct GetPropertiesOptions
 
-      static Azure::Core::Http::Request GetPropertiesConstructRequest(
+      static Azure::Core::Response<BlobContainerProperties> GetProperties(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const GetPropertiesOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
         request.AddQueryParameter("restype", "container");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -1775,14 +1667,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobContainerProperties> GetPropertiesParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobContainerProperties response;
         auto http_status_code
@@ -1790,7 +1675,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -1823,19 +1708,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobContainerProperties> GetProperties(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const GetPropertiesOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = GetPropertiesConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return GetPropertiesParseResponse(context, std::move(pResponse));
-      }
-
       struct SetMetadataOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -1844,12 +1716,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfModifiedSince;
       }; // struct SetMetadataOptions
 
-      static Azure::Core::Http::Request SetMetadataConstructRequest(
+      static Azure::Core::Response<BlobContainerInfo> SetMetadata(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const SetMetadataOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("restype", "container");
@@ -1881,14 +1753,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-Modified-Since", options.IfModifiedSince.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobContainerInfo> SetMetadataParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobContainerInfo response;
         auto http_status_code
@@ -1896,7 +1761,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -1904,19 +1769,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobContainerInfo> SetMetadata(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const SetMetadataOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = SetMetadataConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return SetMetadataParseResponse(context, std::move(pResponse));
-      }
-
       struct ListBlobsFlatOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -1926,12 +1778,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         ListBlobsIncludeItem Include = ListBlobsIncludeItem::None;
       }; // struct ListBlobsFlatOptions
 
-      static Azure::Core::Http::Request ListBlobsFlatConstructRequest(
+      static Azure::Core::Response<BlobsFlatSegment> ListBlobsFlat(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const ListBlobsFlatOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -1957,14 +1809,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddQueryParameter("include", list_blobs_include_item);
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobsFlatSegment> ListBlobsFlatParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobsFlatSegment response;
         auto http_status_code
@@ -1972,41 +1817,18 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         {
-          auto bodyStream = httpResponse.GetBodyStream();
-          std::vector<uint8_t> bodyContent;
-          if (bodyStream->Length() == -1)
-          {
-            bodyContent = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
-          }
-          else
-          {
-            bodyContent.resize(static_cast<std::size_t>(bodyStream->Length()));
-            Azure::Core::Http::BodyStream::ReadToCount(
-                context, *bodyStream, &bodyContent[0], bodyStream->Length());
-          }
-          XmlReader reader(reinterpret_cast<const char*>(bodyContent.data()), bodyContent.size());
+          const auto& httpResponseBody = httpResponse.GetBody();
+          XmlReader reader(
+              reinterpret_cast<const char*>(httpResponseBody.data()), httpResponseBody.size());
           response = BlobsFlatSegmentFromXml(reader);
         }
         return Azure::Core::Response<BlobsFlatSegment>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobsFlatSegment> ListBlobsFlat(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const ListBlobsFlatOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = ListBlobsFlatConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return ListBlobsFlatParseResponse(context, std::move(pResponse));
-      }
-
       struct ListBlobsByHierarchyOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -2017,12 +1839,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         ListBlobsIncludeItem Include = ListBlobsIncludeItem::None;
       }; // struct ListBlobsByHierarchyOptions
 
-      static Azure::Core::Http::Request ListBlobsByHierarchyConstructRequest(
+      static Azure::Core::Response<BlobsHierarchySegment> ListBlobsByHierarchy(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const ListBlobsByHierarchyOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -2052,14 +1874,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddQueryParameter("include", list_blobs_include_item);
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobsHierarchySegment> ListBlobsByHierarchyParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobsHierarchySegment response;
         auto http_status_code
@@ -2067,41 +1882,18 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         {
-          auto bodyStream = httpResponse.GetBodyStream();
-          std::vector<uint8_t> bodyContent;
-          if (bodyStream->Length() == -1)
-          {
-            bodyContent = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
-          }
-          else
-          {
-            bodyContent.resize(static_cast<std::size_t>(bodyStream->Length()));
-            Azure::Core::Http::BodyStream::ReadToCount(
-                context, *bodyStream, &bodyContent[0], bodyStream->Length());
-          }
-          XmlReader reader(reinterpret_cast<const char*>(bodyContent.data()), bodyContent.size());
+          const auto& httpResponseBody = httpResponse.GetBody();
+          XmlReader reader(
+              reinterpret_cast<const char*>(httpResponseBody.data()), httpResponseBody.size());
           response = BlobsHierarchySegmentFromXml(reader);
         }
         return Azure::Core::Response<BlobsHierarchySegment>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobsHierarchySegment> ListBlobsByHierarchy(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const ListBlobsByHierarchyOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = ListBlobsByHierarchyConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return ListBlobsByHierarchyParseResponse(context, std::move(pResponse));
-      }
-
     private:
       static BlobsFlatSegment BlobsFlatSegmentFromXml(XmlReader& reader)
       {
@@ -2721,13 +2513,13 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct DownloadOptions
 
-      static Azure::Core::Http::Request DownloadConstructRequest(
+      static Azure::Core::Response<BlobDownloadResponse> Download(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const DownloadOptions& options)
       {
-        unused(body);
-        auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
+        auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url, true);
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
         {
@@ -2780,14 +2572,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobDownloadResponse> DownloadParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobDownloadResponse response;
         auto http_status_code
@@ -2795,7 +2580,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200 || http_status_code == 206))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -2906,19 +2691,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobDownloadResponse> Download(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const DownloadOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = DownloadConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return DownloadParseResponse(context, std::move(pResponse));
-      }
-
       struct DeleteOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -2930,12 +2702,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct DeleteOptions
 
-      static Azure::Core::Http::Request DeleteConstructRequest(
+      static Azure::Core::Response<DeleteBlobInfo> Delete(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const DeleteOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Delete, url);
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -2968,14 +2740,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<DeleteBlobInfo> DeleteParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         DeleteBlobInfo response;
         auto http_status_code
@@ -2983,35 +2748,22 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 202))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         return Azure::Core::Response<DeleteBlobInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<DeleteBlobInfo> Delete(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const DeleteOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = DeleteConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return DeleteParseResponse(context, std::move(pResponse));
-      }
-
       struct UndeleteOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
       }; // struct UndeleteOptions
 
-      static Azure::Core::Http::Request UndeleteConstructRequest(
+      static Azure::Core::Response<UndeleteBlobInfo> Undelete(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const UndeleteOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -3020,14 +2772,7 @@ namespace Azure { namespace Storage { namespace Blobs {
           request.AddQueryParameter("timeout", std::to_string(options.Timeout.GetValue()));
         }
         request.AddQueryParameter("comp", "undelete");
-        return request;
-      }
-
-      static Azure::Core::Response<UndeleteBlobInfo> UndeleteParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         UndeleteBlobInfo response;
         auto http_status_code
@@ -3035,25 +2780,12 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         return Azure::Core::Response<UndeleteBlobInfo>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<UndeleteBlobInfo> Undelete(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const UndeleteOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = UndeleteConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return UndeleteParseResponse(context, std::move(pResponse));
-      }
-
       struct GetPropertiesOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -3064,12 +2796,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct GetPropertiesOptions
 
-      static Azure::Core::Http::Request GetPropertiesConstructRequest(
+      static Azure::Core::Response<BlobProperties> GetProperties(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const GetPropertiesOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Head, url);
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -3096,14 +2828,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobProperties> GetPropertiesParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobProperties response;
         auto http_status_code
@@ -3111,7 +2836,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -3256,19 +2981,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlobProperties>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobProperties> GetProperties(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const GetPropertiesOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = GetPropertiesConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return GetPropertiesParseResponse(context, std::move(pResponse));
-      }
-
       struct SetHttpHeadersOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -3283,12 +2995,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct SetHttpHeadersOptions
 
-      static Azure::Core::Http::Request SetHttpHeadersConstructRequest(
+      static Azure::Core::Response<BlobInfo> SetHttpHeaders(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const SetHttpHeadersOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "properties");
@@ -3354,14 +3066,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobInfo> SetHttpHeadersParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobInfo response;
         auto http_status_code
@@ -3369,7 +3074,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -3382,19 +3087,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlobInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobInfo> SetHttpHeaders(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const SetHttpHeadersOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = SetHttpHeadersConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return SetHttpHeadersParseResponse(context, std::move(pResponse));
-      }
-
       struct SetMetadataOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -3409,12 +3101,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct SetMetadataOptions
 
-      static Azure::Core::Http::Request SetMetadataConstructRequest(
+      static Azure::Core::Response<BlobInfo> SetMetadata(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const SetMetadataOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "metadata");
@@ -3469,14 +3161,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobInfo> SetMetadataParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobInfo response;
         auto http_status_code
@@ -3484,26 +3169,13 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
         return Azure::Core::Response<BlobInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobInfo> SetMetadata(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const SetMetadataOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = SetMetadataConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return SetMetadataParseResponse(context, std::move(pResponse));
-      }
-
       struct SetAccessTierOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -3511,12 +3183,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<Blobs::RehydratePriority> RehydratePriority;
       }; // struct SetAccessTierOptions
 
-      static Azure::Core::Http::Request SetAccessTierConstructRequest(
+      static Azure::Core::Response<SetBlobAccessTierInfo> SetAccessTier(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const SetAccessTierOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "tier");
@@ -3532,14 +3204,7 @@ namespace Azure { namespace Storage { namespace Blobs {
               "x-ms-rehydrate-priority",
               RehydratePriorityToString(options.RehydratePriority.GetValue()));
         }
-        return request;
-      }
-
-      static Azure::Core::Response<SetBlobAccessTierInfo> SetAccessTierParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         SetBlobAccessTierInfo response;
         auto http_status_code
@@ -3547,25 +3212,12 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200 || http_status_code == 202))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         return Azure::Core::Response<SetBlobAccessTierInfo>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<SetBlobAccessTierInfo> SetAccessTier(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const SetAccessTierOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = SetAccessTierConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return SetAccessTierParseResponse(context, std::move(pResponse));
-      }
-
       struct StartCopyFromUriOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -3585,12 +3237,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> SourceIfNoneMatch;
       }; // struct StartCopyFromUriOptions
 
-      static Azure::Core::Http::Request StartCopyFromUriConstructRequest(
+      static Azure::Core::Response<BlobCopyInfo> StartCopyFromUri(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const StartCopyFromUriOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -3665,14 +3317,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("x-ms-source-if-none-match", options.SourceIfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobCopyInfo> StartCopyFromUriParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobCopyInfo response;
         auto http_status_code
@@ -3680,7 +3325,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 202))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -3690,19 +3335,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlobCopyInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobCopyInfo> StartCopyFromUri(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const StartCopyFromUriOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = StartCopyFromUriConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return StartCopyFromUriParseResponse(context, std::move(pResponse));
-      }
-
       struct AbortCopyFromUriOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -3710,12 +3342,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> LeaseId;
       }; // struct AbortCopyFromUriOptions
 
-      static Azure::Core::Http::Request AbortCopyFromUriConstructRequest(
+      static Azure::Core::Response<AbortCopyBlobInfo> AbortCopyFromUri(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const AbortCopyFromUriOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -3730,14 +3362,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<AbortCopyBlobInfo> AbortCopyFromUriParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         AbortCopyBlobInfo response;
         auto http_status_code
@@ -3745,25 +3370,12 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 204))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         return Azure::Core::Response<AbortCopyBlobInfo>(
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<AbortCopyBlobInfo> AbortCopyFromUri(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const AbortCopyFromUriOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = AbortCopyFromUriConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return AbortCopyFromUriParseResponse(context, std::move(pResponse));
-      }
-
       struct CreateSnapshotOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -3778,12 +3390,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct CreateSnapshotOptions
 
-      static Azure::Core::Http::Request CreateSnapshotConstructRequest(
+      static Azure::Core::Response<BlobSnapshotInfo> CreateSnapshot(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const CreateSnapshotOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "snapshot");
@@ -3838,14 +3450,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobSnapshotInfo> CreateSnapshotParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobSnapshotInfo response;
         auto http_status_code
@@ -3853,7 +3458,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -3874,19 +3479,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobSnapshotInfo> CreateSnapshot(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const CreateSnapshotOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = CreateSnapshotConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return CreateSnapshotParseResponse(context, std::move(pResponse));
-      }
-
     private:
     }; // class Blob
 
@@ -3910,14 +3502,16 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct UploadOptions
 
-      static Azure::Core::Http::Request UploadConstructRequest(
+      static Azure::Core::Response<BlobContentInfo> Upload(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
+          Azure::Core::Http::BodyStream* requestBody,
           const UploadOptions& options)
       {
         auto request
-            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, body.get());
-        request.AddHeader("Content-Length", std::to_string(body->Length()));
+            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody);
+        request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
         {
@@ -4007,14 +3601,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobContentInfo> UploadParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobContentInfo response;
         auto http_status_code
@@ -4022,7 +3609,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -4052,21 +3639,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobContentInfo> Upload(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          Azure::Core::Http::BodyStream& requestBody,
-          const UploadOptions& options)
-      {
-        BodyStreamPointer pRequestBody(
-            &requestBody, [](Azure::Core::Http::BodyStream* /* requestBody */) {});
-        auto request = UploadConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return UploadParseResponse(context, std::move(pResponse));
-      }
-
       struct StageBlockOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -4079,14 +3651,16 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> EncryptionAlgorithm;
       }; // struct StageBlockOptions
 
-      static Azure::Core::Http::Request StageBlockConstructRequest(
+      static Azure::Core::Response<BlockInfo> StageBlock(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
+          Azure::Core::Http::BodyStream* requestBody,
           const StageBlockOptions& options)
       {
         auto request
-            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, body.get());
-        request.AddHeader("Content-Length", std::to_string(body->Length()));
+            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody);
+        request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
         request.AddQueryParameter("comp", "block");
         request.AddQueryParameter("blockid", options.BlockId);
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -4118,14 +3692,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("x-ms-encryption-algorithm", options.EncryptionAlgorithm.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlockInfo> StageBlockParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlockInfo response;
         auto http_status_code
@@ -4133,7 +3700,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         auto response_content_md5_iterator = httpResponse.GetHeaders().find("content-md5");
         if (response_content_md5_iterator != httpResponse.GetHeaders().end())
@@ -4160,21 +3727,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlockInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlockInfo> StageBlock(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          Azure::Core::Http::BodyStream& requestBody,
-          const StageBlockOptions& options)
-      {
-        BodyStreamPointer pRequestBody(
-            &requestBody, [](Azure::Core::Http::BodyStream* /* requestBody */) {});
-        auto request = StageBlockConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return StageBlockParseResponse(context, std::move(pResponse));
-      }
-
       struct StageBlockFromUriOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -4193,12 +3745,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> SourceIfNoneMatch;
       }; // struct StageBlockFromUriOptions
 
-      static Azure::Core::Http::Request StageBlockFromUriConstructRequest(
+      static Azure::Core::Response<BlockInfo> StageBlockFromUri(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const StageBlockFromUriOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "block");
@@ -4266,14 +3818,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("x-ms-source-if-none-match", options.SourceIfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlockInfo> StageBlockFromUriParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlockInfo response;
         auto http_status_code
@@ -4281,7 +3826,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         auto response_content_md5_iterator = httpResponse.GetHeaders().find("content-md5");
         if (response_content_md5_iterator != httpResponse.GetHeaders().end())
@@ -4308,19 +3853,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlockInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlockInfo> StageBlockFromUri(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const StageBlockFromUriOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = StageBlockFromUriConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return StageBlockFromUriParseResponse(context, std::move(pResponse));
-      }
-
       struct CommitBlockListOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -4338,9 +3870,10 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<AccessTier> Tier;
       }; // struct CommitBlockListOptions
 
-      static Azure::Core::Http::Request CommitBlockListConstructRequest(
+      static Azure::Core::Response<BlobContentInfo> CommitBlockList(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const CommitBlockListOptions& options)
       {
         std::string xml_body;
@@ -4349,15 +3882,11 @@ namespace Azure { namespace Storage { namespace Blobs {
           CommitBlockListOptionsToXml(writer, options);
           xml_body = writer.GetDocument();
         }
-        std::shared_ptr<std::string> xml_body_ptr
-            = std::make_shared<std::string>(std::move(xml_body));
-        body = BodyStreamPointer(
-            new Azure::Core::Http::MemoryBodyStream(
-                reinterpret_cast<const uint8_t*>(xml_body_ptr->data()), xml_body_ptr->length()),
-            [xml_body_ptr](Azure::Core::Http::BodyStream* bodyStream) { delete bodyStream; });
+        Azure::Core::Http::MemoryBodyStream xml_body_stream(
+            reinterpret_cast<const uint8_t*>(xml_body.data()), xml_body.length());
         auto request
-            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, body.get());
-        request.AddHeader("Content-Length", std::to_string(body->Length()));
+            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, &xml_body_stream);
+        request.AddHeader("Content-Length", std::to_string(xml_body_stream.Length()));
         request.AddQueryParameter("comp", "blocklist");
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -4439,14 +3968,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobContentInfo> CommitBlockListParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobContentInfo response;
         auto http_status_code
@@ -4454,7 +3976,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -4474,19 +3996,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobContentInfo> CommitBlockList(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const CommitBlockListOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = CommitBlockListConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return CommitBlockListParseResponse(context, std::move(pResponse));
-      }
-
       struct GetBlockListOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -4494,12 +4003,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> LeaseId;
       }; // struct GetBlockListOptions
 
-      static Azure::Core::Http::Request GetBlockListConstructRequest(
+      static Azure::Core::Response<BlobBlockListInfo> GetBlockList(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const GetBlockListOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
         request.AddQueryParameter("comp", "blocklist");
         if (options.ListType.HasValue())
@@ -4517,14 +4026,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("x-ms-lease-id", options.LeaseId.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobBlockListInfo> GetBlockListParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobBlockListInfo response;
         auto http_status_code
@@ -4532,22 +4034,12 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         {
-          auto bodyStream = httpResponse.GetBodyStream();
-          std::vector<uint8_t> bodyContent;
-          if (bodyStream->Length() == -1)
-          {
-            bodyContent = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
-          }
-          else
-          {
-            bodyContent.resize(static_cast<std::size_t>(bodyStream->Length()));
-            Azure::Core::Http::BodyStream::ReadToCount(
-                context, *bodyStream, &bodyContent[0], bodyStream->Length());
-          }
-          XmlReader reader(reinterpret_cast<const char*>(bodyContent.data()), bodyContent.size());
+          const auto& httpResponseBody = httpResponse.GetBody();
+          XmlReader reader(
+              reinterpret_cast<const char*>(httpResponseBody.data()), httpResponseBody.size());
           response = BlobBlockListInfoFromXml(reader);
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
@@ -4559,19 +4051,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobBlockListInfo> GetBlockList(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const GetBlockListOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = GetBlockListConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return GetBlockListParseResponse(context, std::move(pResponse));
-      }
-
     private:
       static BlobBlockListInfo BlobBlockListInfoFromXml(XmlReader& reader)
       {
@@ -4740,12 +4219,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct CreateOptions
 
-      static Azure::Core::Http::Request CreateConstructRequest(
+      static Azure::Core::Response<BlobContentInfo> Create(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const CreateOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -4835,14 +4314,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobContentInfo> CreateParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobContentInfo response;
         auto http_status_code
@@ -4850,7 +4322,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -4880,19 +4352,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobContentInfo> Create(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const CreateOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = CreateConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return CreateParseResponse(context, std::move(pResponse));
-      }
-
       struct UploadPagesOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -4912,14 +4371,16 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct UploadPagesOptions
 
-      static Azure::Core::Http::Request UploadPagesConstructRequest(
+      static Azure::Core::Response<PageInfo> UploadPages(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
+          Azure::Core::Http::BodyStream* requestBody,
           const UploadPagesOptions& options)
       {
         auto request
-            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, body.get());
-        request.AddHeader("Content-Length", std::to_string(body->Length()));
+            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody);
+        request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
         request.AddQueryParameter("comp", "page");
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -4989,14 +4450,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<PageInfo> UploadPagesParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         PageInfo response;
         auto http_status_code
@@ -5004,7 +4458,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -5035,21 +4489,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<PageInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<PageInfo> UploadPages(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          Azure::Core::Http::BodyStream& requestBody,
-          const UploadPagesOptions& options)
-      {
-        BodyStreamPointer pRequestBody(
-            &requestBody, [](Azure::Core::Http::BodyStream* /* requestBody */) {});
-        auto request = UploadPagesConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return UploadPagesParseResponse(context, std::move(pResponse));
-      }
-
       struct UploadPagesFromUriOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -5071,12 +4510,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct UploadPagesFromUriOptions
 
-      static Azure::Core::Http::Request UploadPagesFromUriConstructRequest(
+      static Azure::Core::Response<PageInfo> UploadPagesFromUri(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const UploadPagesFromUriOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "page");
@@ -5153,14 +4592,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<PageInfo> UploadPagesFromUriParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         PageInfo response;
         auto http_status_code
@@ -5168,7 +4600,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -5199,19 +4631,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<PageInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<PageInfo> UploadPagesFromUri(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const UploadPagesFromUriOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = UploadPagesFromUriConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return UploadPagesFromUriParseResponse(context, std::move(pResponse));
-      }
-
       struct ClearPagesOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -5229,12 +4648,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct ClearPagesOptions
 
-      static Azure::Core::Http::Request ClearPagesConstructRequest(
+      static Azure::Core::Response<PageInfo> ClearPages(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const ClearPagesOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "page");
@@ -5298,14 +4717,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<PageInfo> ClearPagesParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         PageInfo response;
         auto http_status_code
@@ -5313,7 +4725,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -5334,19 +4746,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<PageInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<PageInfo> ClearPages(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const ClearPagesOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = ClearPagesConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return ClearPagesParseResponse(context, std::move(pResponse));
-      }
-
       struct ResizeOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -5364,12 +4763,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct ResizeOptions
 
-      static Azure::Core::Http::Request ResizeConstructRequest(
+      static Azure::Core::Response<PageBlobInfo> Resize(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const ResizeOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "properties");
@@ -5429,14 +4828,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<PageBlobInfo> ResizeParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         PageBlobInfo response;
         auto http_status_code
@@ -5444,7 +4836,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -5453,19 +4845,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<PageBlobInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<PageBlobInfo> Resize(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const ResizeOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = ResizeConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return ResizeParseResponse(context, std::move(pResponse));
-      }
-
       struct GetPageRangesOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -5479,12 +4858,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct GetPageRangesOptions
 
-      static Azure::Core::Http::Request GetPageRangesConstructRequest(
+      static Azure::Core::Response<PageRangesInfoInternal> GetPageRanges(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const GetPageRangesOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Get, url);
         request.AddQueryParameter("comp", "pagelist");
         if (options.PreviousSnapshot.HasValue())
@@ -5535,14 +4914,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<PageRangesInfoInternal> GetPageRangesParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         PageRangesInfoInternal response;
         auto http_status_code
@@ -5550,22 +4922,12 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 200))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         {
-          auto bodyStream = httpResponse.GetBodyStream();
-          std::vector<uint8_t> bodyContent;
-          if (bodyStream->Length() == -1)
-          {
-            bodyContent = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
-          }
-          else
-          {
-            bodyContent.resize(static_cast<std::size_t>(bodyStream->Length()));
-            Azure::Core::Http::BodyStream::ReadToCount(
-                context, *bodyStream, &bodyContent[0], bodyStream->Length());
-          }
-          XmlReader reader(reinterpret_cast<const char*>(bodyContent.data()), bodyContent.size());
+          const auto& httpResponseBody = httpResponse.GetBody();
+          XmlReader reader(
+              reinterpret_cast<const char*>(httpResponseBody.data()), httpResponseBody.size());
           response = PageRangesInfoInternalFromXml(reader);
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
@@ -5576,19 +4938,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<PageRangesInfoInternal> GetPageRanges(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const GetPageRangesOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = GetPageRangesConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return GetPageRangesParseResponse(context, std::move(pResponse));
-      }
-
       struct CopyIncrementalOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -5599,12 +4948,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct CopyIncrementalOptions
 
-      static Azure::Core::Http::Request CopyIncrementalConstructRequest(
+      static Azure::Core::Response<BlobCopyInfo> CopyIncremental(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const CopyIncrementalOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "incrementalcopy");
@@ -5630,14 +4979,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobCopyInfo> CopyIncrementalParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobCopyInfo response;
         auto http_status_code
@@ -5645,7 +4987,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 202))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -5655,19 +4997,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlobCopyInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobCopyInfo> CopyIncremental(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const CopyIncrementalOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = CopyIncrementalConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return CopyIncrementalParseResponse(context, std::move(pResponse));
-      }
-
     private:
       static PageRangesInfoInternal PageRangesInfoInternalFromXml(XmlReader& reader)
       {
@@ -5852,12 +5181,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct CreateOptions
 
-      static Azure::Core::Http::Request CreateConstructRequest(
+      static Azure::Core::Response<BlobContentInfo> Create(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const CreateOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddHeader("x-ms-version", c_APIVersion);
@@ -5937,14 +5266,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobContentInfo> CreateParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobContentInfo response;
         auto http_status_code
@@ -5952,7 +5274,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -5982,19 +5304,6 @@ namespace Azure { namespace Storage { namespace Blobs {
             std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobContentInfo> Create(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const CreateOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = CreateConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return CreateParseResponse(context, std::move(pResponse));
-      }
-
       struct AppendBlockOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -6012,14 +5321,16 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct AppendBlockOptions
 
-      static Azure::Core::Http::Request AppendBlockConstructRequest(
+      static Azure::Core::Response<BlobAppendInfo> AppendBlock(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
+          Azure::Core::Http::BodyStream* requestBody,
           const AppendBlockOptions& options)
       {
         auto request
-            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, body.get());
-        request.AddHeader("Content-Length", std::to_string(body->Length()));
+            = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url, requestBody);
+        request.AddHeader("Content-Length", std::to_string(requestBody->Length()));
         request.AddQueryParameter("comp", "appendblock");
         request.AddHeader("x-ms-version", c_APIVersion);
         if (options.Timeout.HasValue())
@@ -6076,14 +5387,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobAppendInfo> AppendBlockParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobAppendInfo response;
         auto http_status_code
@@ -6091,7 +5395,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -6123,21 +5427,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlobAppendInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobAppendInfo> AppendBlock(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          Azure::Core::Http::BodyStream& requestBody,
-          const AppendBlockOptions& options)
-      {
-        BodyStreamPointer pRequestBody(
-            &requestBody, [](Azure::Core::Http::BodyStream* /* requestBody */) {});
-        auto request = AppendBlockConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return AppendBlockParseResponse(context, std::move(pResponse));
-      }
-
       struct AppendBlockFromUriOptions
       {
         Azure::Core::Nullable<int32_t> Timeout;
@@ -6157,12 +5446,12 @@ namespace Azure { namespace Storage { namespace Blobs {
         Azure::Core::Nullable<std::string> IfNoneMatch;
       }; // struct AppendBlockFromUriOptions
 
-      static Azure::Core::Http::Request AppendBlockFromUriConstructRequest(
+      static Azure::Core::Response<BlobAppendInfo> AppendBlockFromUri(
+          Azure::Core::Context context,
+          Azure::Core::Http::HttpPipeline& pipeline,
           const std::string& url,
-          BodyStreamPointer& body,
           const AppendBlockFromUriOptions& options)
       {
-        unused(body);
         auto request = Azure::Core::Http::Request(Azure::Core::Http::HttpMethod::Put, url);
         request.AddHeader("Content-Length", "0");
         request.AddQueryParameter("comp", "appendblock");
@@ -6237,14 +5526,7 @@ namespace Azure { namespace Storage { namespace Blobs {
         {
           request.AddHeader("If-None-Match", options.IfNoneMatch.GetValue());
         }
-        return request;
-      }
-
-      static Azure::Core::Response<BlobAppendInfo> AppendBlockFromUriParseResponse(
-          Azure::Core::Context context,
-          std::unique_ptr<Azure::Core::Http::RawResponse> pHttpResponse)
-      {
-        unused(context);
+        auto pHttpResponse = pipeline.Send(context, request);
         Azure::Core::Http::RawResponse& httpResponse = *pHttpResponse;
         BlobAppendInfo response;
         auto http_status_code
@@ -6252,7 +5534,7 @@ namespace Azure { namespace Storage { namespace Blobs {
                 httpResponse.GetStatusCode());
         if (!(http_status_code == 201))
         {
-          throw StorageError::CreateFromResponse(std::move(pHttpResponse));
+          throw StorageError::CreateFromResponse(context, std::move(pHttpResponse));
         }
         response.ETag = httpResponse.GetHeaders().at("etag");
         response.LastModified = httpResponse.GetHeaders().at("last-modified");
@@ -6284,19 +5566,6 @@ namespace Azure { namespace Storage { namespace Blobs {
         return Azure::Core::Response<BlobAppendInfo>(std::move(response), std::move(pHttpResponse));
       }
 
-      static Azure::Core::Response<BlobAppendInfo> AppendBlockFromUri(
-          Azure::Core::Context context,
-          Azure::Core::Http::HttpPipeline& pipeline,
-          const std::string& url,
-          const AppendBlockFromUriOptions& options)
-      {
-        BodyStreamPointer pRequestBody;
-        auto request = AppendBlockFromUriConstructRequest(url, pRequestBody, options);
-        auto pResponse = pipeline.Send(context, request);
-        pRequestBody.reset();
-        return AppendBlockFromUriParseResponse(context, std::move(pResponse));
-      }
-
     private:
     }; // class AppendBlob
 
diff --git a/sdk/storage/inc/common/storage_error.hpp b/sdk/storage/inc/common/storage_error.hpp
index b21fc788f..bfefade2b 100644
--- a/sdk/storage/inc/common/storage_error.hpp
+++ b/sdk/storage/inc/common/storage_error.hpp
@@ -24,6 +24,7 @@ namespace Azure { namespace Storage {
     std::unique_ptr<Azure::Core::Http::RawResponse> RawResponse;
 
     static StorageError CreateFromResponse(
+        Azure::Core::Context context,
         std::unique_ptr<Azure::Core::Http::RawResponse> response);
   };
 }} // namespace Azure::Storage
diff --git a/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp b/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
index 1f475ebec..7a6f7fd35 100644
--- a/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
+++ b/sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
@@ -857,20 +857,19 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         request.AddHeader(
             Details::c_HeaderApiVersionParameter, listFileSystemsOptions.ApiVersionParameter);
-        return ListFileSystemsParseResponse(pipeline.Send(context, request));
+        return ListFileSystemsParseResponse(context, pipeline.Send(context, request));
       }
 
     private:
       static Azure::Core::Response<ServiceListFileSystemsResponse> ListFileSystemsParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
         if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
         {
           // OK
-          auto context = Azure::Core::Context();
-          auto bodyBuffer
-              = Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
+          const auto& bodyBuffer = response.GetBody();
           ServiceListFileSystemsResponse result = bodyBuffer.empty()
               ? ServiceListFileSystemsResponse()
               : ServiceListFileSystemsResponse::ServiceListFileSystemsResponseFromFileSystemList(
@@ -885,7 +884,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
     };
@@ -941,7 +940,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         {
           request.AddHeader(Details::c_HeaderProperties, createOptions.Properties.GetValue());
         }
-        return CreateParseResponse(pipeline.Send(context, request));
+        return CreateParseResponse(context, pipeline.Send(context, request));
       }
 
       struct SetPropertiesOptions
@@ -1011,7 +1010,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
               Details::c_HeaderIfUnmodifiedSince,
               setPropertiesOptions.IfUnmodifiedSince.GetValue());
         }
-        return SetPropertiesParseResponse(pipeline.Send(context, request));
+        return SetPropertiesParseResponse(context, pipeline.Send(context, request));
       }
 
       struct GetPropertiesOptions
@@ -1049,7 +1048,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         request.AddHeader(
             Details::c_HeaderApiVersionParameter, getPropertiesOptions.ApiVersionParameter);
-        return GetPropertiesParseResponse(pipeline.Send(context, request));
+        return GetPropertiesParseResponse(context, pipeline.Send(context, request));
       }
 
       struct DeleteOptions
@@ -1102,7 +1101,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           request.AddHeader(
               Details::c_HeaderIfUnmodifiedSince, deleteOptions.IfUnmodifiedSince.GetValue());
         }
-        return DeleteParseResponse(pipeline.Send(context, request));
+        return DeleteParseResponse(context, pipeline.Send(context, request));
       }
 
       struct ListPathsOptions
@@ -1186,11 +1185,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           request.AddQueryParameter(
               Details::c_QueryUpn, (listPathsOptions.Upn.GetValue() ? "true" : "false"));
         }
-        return ListPathsParseResponse(pipeline.Send(context, request));
+        return ListPathsParseResponse(context, pipeline.Send(context, request));
       }
 
     private:
       static Azure::Core::Response<FileSystemCreateResponse> CreateParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1206,11 +1206,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<FileSystemSetPropertiesResponse> SetPropertiesParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1225,11 +1226,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<FileSystemGetPropertiesResponse> GetPropertiesParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1246,11 +1248,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<FileSystemDeleteResponse> DeleteParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -1263,20 +1266,19 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<FileSystemListPathsResponse> ListPathsParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
         if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
         {
           // Ok
-          auto context = Azure::Core::Context();
-          auto bodyBuffer
-              = Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
+          const auto& bodyBuffer = response.GetBody();
           FileSystemListPathsResponse result = bodyBuffer.empty()
               ? FileSystemListPathsResponse()
               : FileSystemListPathsResponse::FileSystemListPathsResponseFromPathList(
@@ -1291,7 +1293,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
     };
@@ -1523,7 +1525,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
               Details::c_HeaderSourceIfUnmodifiedSince,
               createOptions.SourceIfUnmodifiedSince.GetValue());
         }
-        return CreateParseResponse(pipeline.Send(context, request));
+        return CreateParseResponse(context, pipeline.Send(context, request));
       }
 
       struct UpdateOptions
@@ -1783,7 +1785,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           request.AddHeader(
               Details::c_HeaderIfUnmodifiedSince, updateOptions.IfUnmodifiedSince.GetValue());
         }
-        return UpdateParseResponse(pipeline.Send(context, request));
+        return UpdateParseResponse(context, pipeline.Send(context, request));
       }
 
       struct LeaseOptions
@@ -1903,7 +1905,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           request.AddHeader(
               Details::c_HeaderIfUnmodifiedSince, leaseOptions.IfUnmodifiedSince.GetValue());
         }
-        return LeaseParseResponse(pipeline.Send(context, request));
+        return LeaseParseResponse(context, pipeline.Send(context, request));
       }
 
       struct ReadOptions
@@ -1951,7 +1953,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           Azure::Core::Context context,
           const ReadOptions& readOptions)
       {
-        Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
+        Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url, true);
         if (readOptions.ClientRequestId.HasValue())
         {
           request.AddHeader(
@@ -1996,7 +1998,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           request.AddHeader(
               Details::c_HeaderIfUnmodifiedSince, readOptions.IfUnmodifiedSince.GetValue());
         }
-        return ReadParseResponse(pipeline.Send(context, request));
+        return ReadParseResponse(context, pipeline.Send(context, request));
       }
 
       struct GetPropertiesOptions
@@ -2095,7 +2097,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
               Details::c_HeaderIfUnmodifiedSince,
               getPropertiesOptions.IfUnmodifiedSince.GetValue());
         }
-        return GetPropertiesParseResponse(pipeline.Send(context, request));
+        return GetPropertiesParseResponse(context, pipeline.Send(context, request));
       }
 
       struct DeleteOptions
@@ -2186,7 +2188,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
           request.AddHeader(
               Details::c_HeaderIfUnmodifiedSince, deleteOptions.IfUnmodifiedSince.GetValue());
         }
-        return DeleteParseResponse(pipeline.Send(context, request));
+        return DeleteParseResponse(context, pipeline.Send(context, request));
       }
 
       struct SetAccessControlOptions
@@ -2293,7 +2295,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         request.AddHeader(
             Details::c_HeaderApiVersionParameter, setAccessControlOptions.ApiVersionParameter);
-        return SetAccessControlParseResponse(pipeline.Send(context, request));
+        return SetAccessControlParseResponse(context, pipeline.Send(context, request));
       }
 
       struct SetAccessControlRecursiveOptions
@@ -2374,7 +2376,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         request.AddHeader(
             Details::c_HeaderApiVersionParameter,
             setAccessControlRecursiveOptions.ApiVersionParameter);
-        return SetAccessControlRecursiveParseResponse(pipeline.Send(context, request));
+        return SetAccessControlRecursiveParseResponse(context, pipeline.Send(context, request));
       }
 
       struct FlushDataOptions
@@ -2549,7 +2551,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         request.AddHeader(
             Details::c_HeaderApiVersionParameter, flushDataOptions.ApiVersionParameter);
-        return FlushDataParseResponse(pipeline.Send(context, request));
+        return FlushDataParseResponse(context, pipeline.Send(context, request));
       }
 
       struct AppendDataOptions
@@ -2631,11 +2633,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         request.AddHeader(
             Details::c_HeaderApiVersionParameter, appendDataOptions.ApiVersionParameter);
-        return AppendDataParseResponse(pipeline.Send(context, request));
+        return AppendDataParseResponse(context, pipeline.Send(context, request));
       }
 
     private:
       static Azure::Core::Response<PathCreateResponse> CreateParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2668,11 +2671,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathUpdateResponse> UpdateParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2680,9 +2684,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         {
           // The data was flushed (written) to the file or the properties were set successfully.
           // Response body is optional and is valid only for "SetAccessControlRecursive"
-          auto context = Azure::Core::Context();
-          auto bodyBuffer
-              = Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
+          const auto& bodyBuffer = response.GetBody();
           PathUpdateResponse result = bodyBuffer.empty()
               ? PathUpdateResponse()
               : PathUpdateResponse::PathUpdateResponseFromSetAccessControlRecursiveResponse(
@@ -2756,11 +2758,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathLeaseResponse> LeaseParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2804,11 +2807,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathReadResponse> ReadParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -2947,11 +2951,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathGetPropertiesResponse> GetPropertiesParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3050,11 +3055,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathDeleteResponse> DeleteParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3072,11 +3078,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathSetAccessControlResponse> SetAccessControlParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3091,21 +3098,20 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathSetAccessControlRecursiveResponse>
       SetAccessControlRecursiveParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
         if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
         {
           // Set directory access control recursive response.
-          auto context = Azure::Core::Context();
-          auto bodyBuffer
-              = Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
+          const auto& bodyBuffer = response.GetBody();
           PathSetAccessControlRecursiveResponse result = bodyBuffer.empty()
               ? PathSetAccessControlRecursiveResponse()
               : PathSetAccessControlRecursiveResponse::
@@ -3122,11 +3128,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathFlushDataResponse> FlushDataParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3147,11 +3154,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
 
       static Azure::Core::Response<PathAppendDataResponse> AppendDataParseResponse(
+          Azure::Core::Context context,
           std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
       {
         /* const */ auto& response = *responsePtr;
@@ -3164,7 +3172,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
         }
         else
         {
-          throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
+          throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
         }
       }
     };
diff --git a/sdk/storage/src/blobs/append_blob_client.cpp b/sdk/storage/src/blobs/append_blob_client.cpp
index aeced6588..f881f0e40 100644
--- a/sdk/storage/src/blobs/append_blob_client.cpp
+++ b/sdk/storage/src/blobs/append_blob_client.cpp
@@ -88,7 +88,7 @@ namespace Azure { namespace Storage { namespace Blobs {
     protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch;
     protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch;
     return BlobRestClient::AppendBlob::AppendBlock(
-        options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
+        options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
   }
 
   Azure::Core::Response<BlobAppendInfo> AppendBlobClient::AppendBlockFromUri(
diff --git a/sdk/storage/src/blobs/block_blob_client.cpp b/sdk/storage/src/blobs/block_blob_client.cpp
index ed70b1976..e8b689c73 100644
--- a/sdk/storage/src/blobs/block_blob_client.cpp
+++ b/sdk/storage/src/blobs/block_blob_client.cpp
@@ -77,7 +77,7 @@ namespace Azure { namespace Storage { namespace Blobs {
     protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch;
     protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch;
     return BlobRestClient::BlockBlob::Upload(
-        options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
+        options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
   }
 
   Azure::Core::Response<BlobContentInfo> BlockBlobClient::UploadFromBuffer(
@@ -210,7 +210,7 @@ namespace Azure { namespace Storage { namespace Blobs {
     protocolLayerOptions.ContentCRC64 = options.ContentCRC64;
     protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId;
     return BlobRestClient::BlockBlob::StageBlock(
-        options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
+        options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
   }
 
   Azure::Core::Response<BlockInfo> BlockBlobClient::StageBlockFromUri(
diff --git a/sdk/storage/src/blobs/page_blob_client.cpp b/sdk/storage/src/blobs/page_blob_client.cpp
index 8f5f1c24b..95d547e45 100644
--- a/sdk/storage/src/blobs/page_blob_client.cpp
+++ b/sdk/storage/src/blobs/page_blob_client.cpp
@@ -90,7 +90,7 @@ namespace Azure { namespace Storage { namespace Blobs {
     protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch;
     protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch;
     return BlobRestClient::PageBlob::UploadPages(
-        options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
+        options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
   }
 
   Azure::Core::Response<PageInfo> PageBlobClient::UploadPagesFromUri(
diff --git a/sdk/storage/src/common/storage_error.cpp b/sdk/storage/src/common/storage_error.cpp
index daa167e6a..46998cbce 100644
--- a/sdk/storage/src/common/storage_error.cpp
+++ b/sdk/storage/src/common/storage_error.cpp
@@ -5,22 +5,26 @@
 
 #include "common/constants.hpp"
 #include "common/xml_wrapper.hpp"
+#include "http/policy.hpp"
 #include "json.hpp"
 
 #include <type_traits>
 
 namespace Azure { namespace Storage {
   StorageError StorageError::CreateFromResponse(
+      Azure::Core::Context context,
       std::unique_ptr<Azure::Core::Http::RawResponse> response)
   {
-    auto bodyStream = response->GetBodyStream();
     std::vector<uint8_t> bodyBuffer;
-    if (bodyStream != nullptr)
+    auto bodyStream = response->GetBodyStream();
+    if (bodyStream)
     {
-      // TODO: get the real context somewhere
-      Azure::Core::Context context;
       bodyBuffer = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
     }
+    else
+    {
+      bodyBuffer = std::move(response->GetBody());
+    }
 
     auto httpStatusCode = response->GetStatusCode();
     std::string reasonPhrase = response->GetReasonPhrase();
diff --git a/sdk/storage/test/blobs/append_blob_client_test.cpp b/sdk/storage/test/blobs/append_blob_client_test.cpp
index c683b474b..dfc3cf123 100644
--- a/sdk/storage/test/blobs/append_blob_client_test.cpp
+++ b/sdk/storage/test/blobs/append_blob_client_test.cpp
@@ -59,7 +59,7 @@ namespace Azure { namespace Storage { namespace Test {
     Azure::Storage::Blobs::AppendBlockOptions options;
     options.AccessConditions.AppendPosition = 1_MB;
     blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
-    EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), std::runtime_error);
+    EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), StorageError);
     options.AccessConditions.AppendPosition = properties.ContentLength;
     blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
     appendBlobClient.AppendBlock(&blockContent, options);
@@ -68,7 +68,7 @@ namespace Azure { namespace Storage { namespace Test {
     options = Azure::Storage::Blobs::AppendBlockOptions();
     options.AccessConditions.MaxSize = properties.ContentLength + m_blobContent.size() - 1;
     blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
-    EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), std::runtime_error);
+    EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), StorageError);
     options.AccessConditions.MaxSize = properties.ContentLength + m_blobContent.size();
     blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
     appendBlobClient.AppendBlock(&blockContent, options);
@@ -76,7 +76,7 @@ namespace Azure { namespace Storage { namespace Test {
     // TODO: AppendBlockFromUri must be authorized with SAS, but we don't have SAS for now.
 
     appendBlobClient.Delete();
-    EXPECT_THROW(appendBlobClient.Delete(), std::runtime_error);
+    EXPECT_THROW(appendBlobClient.Delete(), StorageError);
   }
 
 }}} // namespace Azure::Storage::Test
diff --git a/sdk/storage/test/blobs/blob_container_client_test.cpp b/sdk/storage/test/blobs/blob_container_client_test.cpp
index 2040864ba..733aa3fdd 100644
--- a/sdk/storage/test/blobs/blob_container_client_test.cpp
+++ b/sdk/storage/test/blobs/blob_container_client_test.cpp
@@ -37,7 +37,7 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
     EXPECT_FALSE(res->ETag.empty());
     EXPECT_FALSE(res->LastModified.empty());
-    EXPECT_THROW(container_client.Create(), std::runtime_error);
+    EXPECT_THROW(container_client.Create(), StorageError);
 
     auto res2 = container_client.Delete();
     EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());
diff --git a/sdk/storage/test/blobs/blob_sas_test.cpp b/sdk/storage/test/blobs/blob_sas_test.cpp
index a05c99461..1981599c0 100644
--- a/sdk/storage/test/blobs/blob_sas_test.cpp
+++ b/sdk/storage/test/blobs/blob_sas_test.cpp
@@ -211,7 +211,7 @@ namespace Azure { namespace Storage { namespace Test {
       builder2.StartsOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(5));
       builder2.ExpiresOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(1));
       auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
-      EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
+      EXPECT_THROW(verify_blob_create(sasToken), StorageError);
     }
 
     // Without start time
@@ -230,7 +230,7 @@ namespace Azure { namespace Storage { namespace Test {
       builder2.IPRange = "1.1.1.1";
       auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
       auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
-      EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
+      EXPECT_THROW(verify_blob_create(sasToken), StorageError);
       builder2.IPRange = "0.0.0.0-255.255.255.255";
       sasToken = builder2.ToSasQueryParameters(*keyCredential);
       blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
@@ -244,7 +244,7 @@ namespace Azure { namespace Storage { namespace Test {
       builder2.Services = AccountSasServices::Files;
       auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
       auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
-      EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
+      EXPECT_THROW(verify_blob_create(sasToken), StorageError);
 
       builder2.Services = AccountSasServices::All;
       sasToken = builder2.ToSasQueryParameters(*keyCredential);
@@ -259,7 +259,7 @@ namespace Azure { namespace Storage { namespace Test {
       builder2.ResourceTypes = AccountSasResource::Service;
       auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
       auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
-      EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
+      EXPECT_THROW(verify_blob_create(sasToken), StorageError);
 
       auto serviceClient = Blobs::BlobServiceClient(serviceUri + sasToken);
       EXPECT_NO_THROW(serviceClient.ListBlobContainersSegment());
@@ -321,7 +321,7 @@ namespace Azure { namespace Storage { namespace Test {
       builder2.StartsOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(5));
       builder2.ExpiresOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(1));
       auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
-      EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
+      EXPECT_THROW(verify_blob_create(sasToken), StorageError);
     }
 
     // IP
@@ -330,7 +330,7 @@ namespace Azure { namespace Storage { namespace Test {
       builder2.IPRange = "0.0.0.0-0.0.0.1";
       auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
       auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
-      EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
+      EXPECT_THROW(verify_blob_create(sasToken), StorageError);
       builder2.IPRange = "0.0.0.0-255.255.255.255";
       sasToken = builder2.ToSasQueryParameters(*keyCredential);
       blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
diff --git a/sdk/storage/test/blobs/block_blob_client_test.cpp b/sdk/storage/test/blobs/block_blob_client_test.cpp
index 330ce319d..1a666124a 100644
--- a/sdk/storage/test/blobs/block_blob_client_test.cpp
+++ b/sdk/storage/test/blobs/block_blob_client_test.cpp
@@ -67,10 +67,10 @@ namespace Azure { namespace Storage { namespace Test {
     blockBlobClient.Upload(&blobContent, m_blobUploadOptions);
 
     blockBlobClient.Delete();
-    EXPECT_THROW(blockBlobClient.Delete(), std::runtime_error);
+    EXPECT_THROW(blockBlobClient.Delete(), StorageError);
     blockBlobClient.Undelete();
     blockBlobClient.Delete();
-    EXPECT_THROW(blockBlobClient.Delete(), std::runtime_error);
+    EXPECT_THROW(blockBlobClient.Delete(), StorageError);
   }
 
   TEST_F(BlockBlobClientTest, UploadDownload)
@@ -122,9 +122,9 @@ namespace Azure { namespace Storage { namespace Test {
 
     Azure::Storage::Blobs::DownloadBlobOptions options;
     options.Offset = 0;
-    EXPECT_THROW(blockBlobClient.Download(options), std::runtime_error);
+    EXPECT_THROW(blockBlobClient.Download(options), StorageError);
     options.Length = 1;
-    EXPECT_THROW(blockBlobClient.Download(options), std::runtime_error);
+    EXPECT_THROW(blockBlobClient.Download(options), StorageError);
   }
 
   TEST_F(BlockBlobClientTest, CopyFromUri)
@@ -167,13 +167,12 @@ namespace Azure { namespace Storage { namespace Test {
     EXPECT_EQ(ReadBodyStream(snapshotClient.Download()->BodyStream), m_blobContent);
     EXPECT_EQ(snapshotClient.GetProperties()->Metadata, m_blobUploadOptions.Metadata);
     auto emptyContent = Azure::Core::Http::MemoryBodyStream(nullptr, 0);
-    EXPECT_THROW(snapshotClient.Upload(&emptyContent), std::runtime_error);
-    EXPECT_THROW(snapshotClient.SetMetadata({}), std::runtime_error);
+    EXPECT_THROW(snapshotClient.Upload(&emptyContent), StorageError);
+    EXPECT_THROW(snapshotClient.SetMetadata({}), StorageError);
     EXPECT_THROW(
-        snapshotClient.SetAccessTier(Azure::Storage::Blobs::AccessTier::Cool), std::runtime_error);
+        snapshotClient.SetAccessTier(Azure::Storage::Blobs::AccessTier::Cool), StorageError);
     EXPECT_THROW(
-        snapshotClient.SetHttpHeaders(Azure::Storage::Blobs::BlobHttpHeaders()),
-        std::runtime_error);
+        snapshotClient.SetHttpHeaders(Azure::Storage::Blobs::BlobHttpHeaders()), StorageError);
 
     Azure::Storage::Blobs::CreateSnapshotOptions options;
     options.Metadata = {{"snapshotkey1", "snapshotvalue1"}, {"snapshotkey2", "SNAPSHOTVALUE2"}};
@@ -352,9 +351,8 @@ namespace Azure { namespace Storage { namespace Test {
         {
           EXPECT_THROW(
               m_blockBlobClient->DownloadToBuffer(nullptr, 8 * 1024 * 1024, optionsCopy),
-              std::runtime_error);
-          EXPECT_THROW(
-              m_blockBlobClient->DownloadToFile(tempFilename, optionsCopy), std::runtime_error);
+              StorageError);
+          EXPECT_THROW(m_blockBlobClient->DownloadToFile(tempFilename, optionsCopy), StorageError);
           DeleteFile(tempFilename);
         }
       };
@@ -476,31 +474,31 @@ namespace Azure { namespace Storage { namespace Test {
       EXPECT_THROW(
           blockBlobClient.DownloadToBuffer(
               emptyContent.data(), static_cast<std::size_t>(8_MB), options),
-          std::runtime_error);
-      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
+          StorageError);
+      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
 
       options.Offset = 1;
       EXPECT_THROW(
           blockBlobClient.DownloadToBuffer(
               emptyContent.data(), static_cast<std::size_t>(8_MB), options),
-          std::runtime_error);
-      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
+          StorageError);
+      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
 
       options.Offset = 0;
       options.Length = 1;
       EXPECT_THROW(
           blockBlobClient.DownloadToBuffer(
               emptyContent.data(), static_cast<std::size_t>(8_MB), options),
-          std::runtime_error);
-      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
+          StorageError);
+      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
 
       options.Offset = 100;
       options.Length = 100;
       EXPECT_THROW(
           blockBlobClient.DownloadToBuffer(
               emptyContent.data(), static_cast<std::size_t>(8_MB), options),
-          std::runtime_error);
-      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
+          StorageError);
+      EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
       DeleteFile(tempFilename);
     }
   }
@@ -576,4 +574,26 @@ namespace Azure { namespace Storage { namespace Test {
     DeleteFile(tempFilename);
   }
 
+  TEST_F(BlockBlobClientTest, DownloadError)
+  {
+    auto blockBlobClient = Azure::Storage::Blobs::BlockBlobClient::CreateFromConnectionString(
+        StandardStorageConnectionString(), m_containerName, RandomString());
+    bool exceptionCaught = false;
+    try
+    {
+      blockBlobClient.Download();
+    }
+    catch (StorageError& e)
+    {
+      exceptionCaught = true;
+      EXPECT_EQ(e.StatusCode, Azure::Core::Http::HttpStatusCode::NotFound);
+      EXPECT_FALSE(e.ReasonPhrase.empty());
+      EXPECT_FALSE(e.RequestId.empty());
+      EXPECT_FALSE(e.ErrorCode.empty());
+      EXPECT_FALSE(e.Message.empty());
+      EXPECT_TRUE(e.RawResponse);
+    }
+    EXPECT_TRUE(exceptionCaught);
+  }
+
 }}} // namespace Azure::Storage::Test
diff --git a/sdk/storage/test/blobs/page_blob_client_test.cpp b/sdk/storage/test/blobs/page_blob_client_test.cpp
index e0c1dd4ab..75d941613 100644
--- a/sdk/storage/test/blobs/page_blob_client_test.cpp
+++ b/sdk/storage/test/blobs/page_blob_client_test.cpp
@@ -45,7 +45,7 @@ namespace Azure { namespace Storage { namespace Test {
     pageBlobClient.Create(0, m_blobUploadOptions);
 
     pageBlobClient.Delete();
-    EXPECT_THROW(pageBlobClient.Delete(), std::runtime_error);
+    EXPECT_THROW(pageBlobClient.Delete(), StorageError);
   }
 
   TEST_F(PageBlobClientTest, Resize)
diff --git a/sdk/storage/test/datalake/directory_client_test.cpp b/sdk/storage/test/datalake/directory_client_test.cpp
index 6af4122b6..ef0063b3b 100644
--- a/sdk/storage/test/datalake/directory_client_test.cpp
+++ b/sdk/storage/test/datalake/directory_client_test.cpp
@@ -269,7 +269,6 @@ namespace Azure { namespace Storage { namespace Test {
 
       auto properties3 = m_directoryClient->GetProperties();
       EXPECT_NE(properties1->ETag, properties3->ETag);
-      EXPECT_NE(properties1->LastModified, properties3->LastModified);
     }
 
     {
diff --git a/sdk/storage/test/datalake/file_client_test.cpp b/sdk/storage/test/datalake/file_client_test.cpp
index c8bedd332..66f718528 100644
--- a/sdk/storage/test/datalake/file_client_test.cpp
+++ b/sdk/storage/test/datalake/file_client_test.cpp
@@ -250,7 +250,6 @@ namespace Azure { namespace Storage { namespace Test {
 
       auto properties3 = m_fileClient->GetProperties();
       EXPECT_NE(properties1->ETag, properties3->ETag);
-      EXPECT_NE(properties1->LastModified, properties3->LastModified);
     }
 
     {
diff --git a/sdk/storage/test/datalake/file_system_client_test.cpp b/sdk/storage/test/datalake/file_system_client_test.cpp
index c295940e5..c46c8b72a 100644
--- a/sdk/storage/test/datalake/file_system_client_test.cpp
+++ b/sdk/storage/test/datalake/file_system_client_test.cpp
@@ -187,7 +187,6 @@ namespace Azure { namespace Storage { namespace Test {
 
       auto properties3 = m_fileSystemClient->GetProperties();
       EXPECT_NE(properties1->ETag, properties3->ETag);
-      EXPECT_NE(properties1->LastModified, properties3->LastModified);
     }
   }
 
diff --git a/sdk/storage/test/datalake/path_client_test.cpp b/sdk/storage/test/datalake/path_client_test.cpp
index a3b9e68d4..e6b376c00 100644
--- a/sdk/storage/test/datalake/path_client_test.cpp
+++ b/sdk/storage/test/datalake/path_client_test.cpp
@@ -112,7 +112,6 @@ namespace Azure { namespace Storage { namespace Test {
 
       auto properties3 = m_pathClient->GetProperties();
       EXPECT_NE(properties1->ETag, properties3->ETag);
-      EXPECT_NE(properties1->LastModified, properties3->LastModified);
     }
   }