Content-Type为null时无条件成功匹配

xljiulang · xljiulang · commit df6882294b55 · 2021-02-05T20:45:50.000+08:00
diff --git a/WebApiClientCore.Extensions.OAuths/TokenProviders/OAuth2TokenClient.cs b/WebApiClientCore.Extensions.OAuths/TokenProviders/OAuth2TokenClient.cs
@@ -83,6 +83,10 @@ public OAuth2TokenClient(IHttpClientFactory httpClientFactory, IOptionsMonitor<H
 
             var response = await this.httpClientFactory.CreateClient().PostAsync(endpoint, formContent);
             var utf8Json = await response.Content.ReadAsUtf8ByteArrayAsync();
+            if (utf8Json.Length == 0)
+            {
+                return default;
+            }
             return JsonSerializer.Deserialize<TokenResult>(utf8Json, this.httpApiOptions.JsonDeserializeOptions);
         }
     }
diff --git a/WebApiClientCore/ApiResponseContextExtensions.cs b/WebApiClientCore/ApiResponseContextExtensions.cs
@@ -20,23 +20,23 @@ public static class ApiResponseContextExtensions
         /// <returns></returns>
         public static async Task<object?> JsonDeserializeAsync(this ApiResponseContext context, Type objType)
         {
-            if (context.HttpContext.ResponseMessage == null)
-            {
-                return objType.DefaultValue();
-            }
-
-            var content = context.HttpContext.ResponseMessage.Content;
-            if (content == null)
+            var response = context.HttpContext.ResponseMessage;
+            if (response == null)
             {
                 return objType.DefaultValue();
             }
 
+            var content = response.Content;
             var encoding = content.GetEncoding();
             var options = context.HttpContext.HttpApiOptions.JsonDeserializeOptions;
 
             if (Encoding.UTF8.Equals(encoding) == false)
             {
                 var byteArray = await content.ReadAsByteArrayAsync().ConfigureAwait(false);
+                if (byteArray.Length == 0)
+                {
+                    return objType.DefaultValue();
+                }
                 var utf8Json = Encoding.Convert(encoding, Encoding.UTF8, byteArray);
                 return JsonSerializer.Deserialize(utf8Json, objType, options);
             }
@@ -49,7 +49,9 @@ public static class ApiResponseContextExtensions
             else
             {
                 var utf8Json = await content.ReadAsByteArrayAsync().ConfigureAwait(false);
-                return JsonSerializer.Deserialize(utf8Json, objType, options);
+                return utf8Json.Length == 0
+                    ? objType.DefaultValue()
+                    : JsonSerializer.Deserialize(utf8Json, objType, options);
             }
         }
 
@@ -61,13 +63,15 @@ public static class ApiResponseContextExtensions
         /// <returns></returns>
         public static async Task<object?> XmlDeserializeAsync(this ApiResponseContext context, Type objType)
         {
-            if (context.HttpContext.ResponseMessage == null)
+            var response = context.HttpContext.ResponseMessage;
+            if (response == null)
             {
                 return objType.DefaultValue();
             }
 
+            var content = response.Content;
             var options = context.HttpContext.HttpApiOptions.XmlDeserializeOptions;
-            var xml = await context.HttpContext.ResponseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
+            var xml = await content.ReadAsStringAsync().ConfigureAwait(false);
             return XmlSerializer.Deserialize(xml, objType, options);
         }
     }
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/ApiReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/ApiReturnAttribute.cs
@@ -86,13 +86,22 @@ public Task OnRequestAsync(ApiRequestContext context)
         /// <returns></returns>
         public async Task OnResponseAsync(ApiResponseContext context)
         {
-            if (context.ActionDescriptor.Return.DataType.IsRawType == true)
+            var dataType = context.ActionDescriptor.Return.DataType;
+            if (dataType.IsRawType == true)
             {
                 return;
             }
 
-            var contenType = context.HttpContext.ResponseMessage?.Content.Headers.ContentType;
-            if (this.EnsureMatchAcceptContentType && this.IsMatchAcceptContentType(contenType) == false)
+            var response = context.HttpContext.ResponseMessage;
+            if (response == null)
+            {
+                return;
+            }
+
+            var contenType = response.Content.Headers.ContentType;
+            if (contenType != null
+                && this.EnsureMatchAcceptContentType
+                && this.IsMatchAcceptContentType(contenType) == false)
             {
                 return;
             }
@@ -101,15 +110,16 @@ public async Task OnResponseAsync(ApiResponseContext context)
             await this.SetResultAsync(context).ConfigureAwait(false);
         }
 
+
         /// <summary>
         /// 指示响应的ContentType与AcceptContentType是否匹配
         /// 返回false则调用下一个ApiReturnAttribute来处理响应结果
         /// </summary>
         /// <param name="responseContentType">响应的ContentType</param>
         /// <returns></returns>
-        protected virtual bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)
+        protected virtual bool IsMatchAcceptContentType(MediaTypeHeaderValue responseContentType)
         {
-            return MediaTypeUtil.IsMatch(this.AcceptContentType.MediaType, responseContentType?.MediaType);
+            return MediaTypeUtil.IsMatch(this.AcceptContentType.MediaType, responseContentType.MediaType);
         }
 
         /// <summary>
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/CustomValueReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/CustomValueReturnAttribute.cs
@@ -0,0 +1,35 @@
+﻿namespace WebApiClientCore.Attributes
+{
+    /// <summary>
+    /// 表示将结果设置为返回类型的自定义值抽象特性
+    /// </summary> 
+    public abstract class CustomValueReturnAttribute : SpecialReturnAttribute
+    {
+        /// <summary>
+        /// 将结果设置为返回类型的自定义值抽象特性
+        /// </summary>
+        public CustomValueReturnAttribute()
+            : base()
+        {
+        }
+
+        /// <summary>
+        /// 将结果设置为返回类型的自定义值抽象特性
+        /// </summary>
+        /// <param name="acceptQuality">accept的质比</param>
+        public CustomValueReturnAttribute(double acceptQuality)
+            : base(acceptQuality)
+        {
+        }
+
+        /// <summary>
+        /// 指示是否可以设置结果
+        /// </summary>
+        /// <param name="context">上下文</param>
+        /// <returns></returns>
+        protected sealed override bool CanSetResult(ApiResponseContext context)
+        {
+            return context.ActionDescriptor.Return.DataType.IsRawType == false;
+        } 
+    }
+}
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/DefaultValueReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/DefaultValueReturnAttribute.cs
@@ -0,0 +1,51 @@
+﻿using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace WebApiClientCore.Attributes
+{
+    /// <summary>
+    /// 表示将结果设置为返回类型的默认值抽象特性
+    /// </summary> 
+    public abstract class DefaultValueReturnAttribute : CustomValueReturnAttribute
+    {
+        /// <summary>
+        /// 将结果设置为返回类型的默认值抽象特性
+        /// </summary>
+        public DefaultValueReturnAttribute()
+            : base()
+        {
+        }
+
+        /// <summary>
+        /// 将结果设置为返回类型的默认值抽象特性
+        /// </summary>
+        /// <param name="acceptQuality">accept的质比</param>
+        public DefaultValueReturnAttribute(double acceptQuality)
+            : base(acceptQuality)
+        {
+        }
+
+        /// <summary>
+        /// 如果有结果值，则设置结果值到上下文的Result属性
+        /// </summary>
+        /// <param name="context">上下文</param>
+        /// <returns></returns>
+        public sealed override Task SetResultAsync(ApiResponseContext context)
+        {
+            var response = context.HttpContext.ResponseMessage;
+            if (response != null && this.CanUseDefaultValue(response))
+            {
+                context.Result = context.ActionDescriptor.Return.DataType.Type.DefaultValue();
+            }
+
+            return Task.CompletedTask;
+        }
+
+        /// <summary>
+        /// 指示是否将结果设置为返回类型的默认值 
+        /// </summary>
+        /// <param name="responseMessage">响应消息</param>
+        /// <returns></returns>
+        protected abstract bool CanUseDefaultValue(HttpResponseMessage responseMessage);
+    }
+}
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/JsonReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/JsonReturnAttribute.cs
@@ -43,11 +43,11 @@ public JsonReturnAttribute(double acceptQuality)
         /// </summary>
         /// <param name="responseContentType">响应的ContentType</param>
         /// <returns></returns>
-        protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)
+        protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue responseContentType)
         {
             return base.IsMatchAcceptContentType(responseContentType)
-                || MediaTypeUtil.IsMatch(textJson, responseContentType?.MediaType)
-                || MediaTypeUtil.IsMatch(problemJson, responseContentType?.MediaType);
+                || MediaTypeUtil.IsMatch(textJson, responseContentType.MediaType)
+                || MediaTypeUtil.IsMatch(problemJson, responseContentType.MediaType);
         }
 
         /// <summary>
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/NoneReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/NoneReturnAttribute.cs
@@ -1,25 +1,23 @@
 ﻿using System.Net;
 using System.Net.Http;
-using System.Threading.Tasks;
 
 namespace WebApiClientCore.Attributes
 {
     /// <summary>
-    /// 表示无内容的结果特性
-    /// 将结果设置为类型的默认值
+    /// 表示响应状态为204时将结果设置为返回类型的默认值特性
     /// </summary> 
-    public sealed class NoneReturnAttribute : SpecialReturnAttribute
+    public sealed class NoneReturnAttribute : DefaultValueReturnAttribute
     {
         /// <summary>
-        /// 无内容的结果特性
+        /// 响应状态为204时将结果设置为返回类型的默认值特性
         /// </summary>
         public NoneReturnAttribute()
             : base()
         {
         }
 
         /// <summary>
-        /// 无内容的结果特性
+        /// 响应状态为204时将结果设置为返回类型的默认值特性
         /// </summary>
         /// <param name="acceptQuality">accept的质比</param>
         public NoneReturnAttribute(double acceptQuality)
@@ -28,40 +26,19 @@ public NoneReturnAttribute(double acceptQuality)
         }
 
         /// <summary>
-        /// 设置结果值
+        /// 指示是否将结果设置为返回类型的默认值 
         /// </summary>
-        /// <param name="context">上下文</param>
+        /// <param name="responseMessage">响应消息</param>
         /// <returns></returns>
-        public override Task SetResultAsync(ApiResponseContext context)
+        protected override bool CanUseDefaultValue(HttpResponseMessage responseMessage)
         {
-            if (context.ActionDescriptor.Return.DataType.IsRawType == true)
-            {
-                return Task.CompletedTask;
-            }
-
-            var response = context.HttpContext.ResponseMessage;
-            if (response != null && IsNoContent(response))
-            {
-                context.Result = context.ActionDescriptor.Return.DataType.Type.DefaultValue();
-            }
-
-            return Task.CompletedTask;
-        }
-
-        /// <summary>
-        /// 指示是否为无内容
-        /// </summary>
-        /// <param name="response"></param>
-        /// <returns></returns>
-        private static bool IsNoContent(HttpResponseMessage response)
-        {
-            if (response.StatusCode == HttpStatusCode.NoContent)
+            if (responseMessage.StatusCode == HttpStatusCode.NoContent)
             {
                 return true;
             }
 
-            var status = (int)response.StatusCode;
-            return status >= 200 && status <= 299 && response.Content.Headers.ContentLength == 0;
+            return responseMessage.IsSuccessStatusCode
+                && responseMessage.Content.Headers.ContentLength == 0;
         }
     }
 }
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/RawReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/RawReturnAttribute.cs
@@ -1,5 +1,4 @@
-﻿using System.Net;
-using System.Threading.Tasks;
+﻿using System.Threading.Tasks;
 using WebApiClientCore.Exceptions;
 
 namespace WebApiClientCore.Attributes
@@ -34,26 +33,35 @@ public RawReturnAttribute(double acceptQuality)
         {
         }
 
+        /// <summary>
+        /// 指示是否可以设置结果
+        /// </summary>
+        /// <param name="context">上下文</param>
+        /// <returns></returns>
+        protected override bool CanSetResult(ApiResponseContext context)
+        {
+            return context.ActionDescriptor.Return.DataType.IsRawType;
+        }
+
         /// <summary>
         /// 设置结果值
         /// </summary>
         /// <param name="context">上下文</param>
         /// <returns></returns>
         public async override Task SetResultAsync(ApiResponseContext context)
         {
-            var dataType = context.ActionDescriptor.Return.DataType;
             var response = context.HttpContext.ResponseMessage;
-
-            if (dataType.IsRawType == false || response == null)
+            if (response == null)
             {
                 return;
             }
 
-            if (this.EnsureSuccessStatusCode && IsSuccessStatusCode(response.StatusCode) == false)
+            if (this.EnsureSuccessStatusCode && response.IsSuccessStatusCode == false)
             {
                 throw new ApiResponseStatusException(response);
             }
 
+            var dataType = context.ActionDescriptor.Return.DataType;
             if (dataType.IsRawHttpResponseMessage == true)
             {
                 context.Result = response;
@@ -71,16 +79,5 @@ public async override Task SetResultAsync(ApiResponseContext context)
                 context.Result = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
             }
         }
-
-        /// <summary>
-        /// 指示http状态码是否为成功的状态码
-        /// </summary>
-        /// <param name="statusCode">http状态码</param>
-        /// <returns></returns>
-        private static bool IsSuccessStatusCode(HttpStatusCode statusCode)
-        {
-            var status = (int)statusCode;
-            return status >= 200 && status <= 299;
-        }
     }
 }
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/SpecialReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/SpecialReturnAttribute.cs
@@ -64,11 +64,23 @@ public Task OnRequestAsync(ApiRequestContext context)
         /// <returns></returns>
         public Task OnResponseAsync(ApiResponseContext context)
         {
-            return this.SetResultAsync(context);
+            return this.CanSetResult(context) 
+                ? this.SetResultAsync(context)
+                : Task.CompletedTask;
         }
 
         /// <summary>
-        /// 设置结果值
+        /// 指示是否可以设置结果
+        /// </summary>
+        /// <param name="context">上下文</param>
+        /// <returns></returns>
+        protected virtual bool CanSetResult(ApiResponseContext context)
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// 如果有结果值，则设置结果值到上下文的Result属性
         /// </summary>
         /// <param name="context">上下文</param>
         /// <returns></returns>
diff --git a/WebApiClientCore/Attributes/ReturnAttributes/XmlReturnAttribute.cs b/WebApiClientCore/Attributes/ReturnAttributes/XmlReturnAttribute.cs
@@ -38,10 +38,10 @@ public XmlReturnAttribute(double acceptQuality)
         /// </summary>
         /// <param name="responseContentType">响应的ContentType</param>
         /// <returns></returns>
-        protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)
+        protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue responseContentType)
         {
             return base.IsMatchAcceptContentType(responseContentType) 
-                || MediaTypeUtil.IsMatch(textXml, responseContentType?.MediaType);
+                || MediaTypeUtil.IsMatch(textXml, responseContentType.MediaType);
         }
 
         /// <summary>
diff --git a/WebApiClientCore/Implementations/DefaultApiReturnDescriptor.cs b/WebApiClientCore/Implementations/DefaultApiReturnDescriptor.cs
diff --git a/WebApiClientCore/Internals/MediaTypeUtil.cs b/WebApiClientCore/Internals/MediaTypeUtil.cs

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,10 @@ public OAuth2TokenClient(IHttpClientFactory httpClientFactory, IOptionsMonitor<H`
`83`	`83`
`84`	`84`	`var response = await this.httpClientFactory.CreateClient().PostAsync(endpoint, formContent);`
`85`	`85`	`var utf8Json = await response.Content.ReadAsUtf8ByteArrayAsync();`
	`86`	`+ if (utf8Json.Length == 0)`
	`87`	`+ {`
	`88`	`+ return default;`
	`89`	`+ }`
`86`	`90`	`return JsonSerializer.Deserialize<TokenResult>(utf8Json, this.httpApiOptions.JsonDeserializeOptions);`
`87`	`91`	`}`
`88`	`92`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,23 +20,23 @@ public static class ApiResponseContextExtensions`
`20`	`20`	`/// <returns></returns>`
`21`	`21`	`public static async Task<object?> JsonDeserializeAsync(this ApiResponseContext context, Type objType)`
`22`	`22`	`{`
`23`		`- if (context.HttpContext.ResponseMessage == null)`
`24`		`- {`
`25`		`- return objType.DefaultValue();`
`26`		`- }`
`27`		`-`
`28`		`- var content = context.HttpContext.ResponseMessage.Content;`
`29`		`- if (content == null)`
	`23`	`+ var response = context.HttpContext.ResponseMessage;`
	`24`	`+ if (response == null)`
`30`	`25`	`{`
`31`	`26`	`return objType.DefaultValue();`
`32`	`27`	`}`
`33`	`28`
	`29`	`+ var content = response.Content;`
`34`	`30`	`var encoding = content.GetEncoding();`
`35`	`31`	`var options = context.HttpContext.HttpApiOptions.JsonDeserializeOptions;`
`36`	`32`
`37`	`33`	`if (Encoding.UTF8.Equals(encoding) == false)`
`38`	`34`	`{`
`39`	`35`	`var byteArray = await content.ReadAsByteArrayAsync().ConfigureAwait(false);`
	`36`	`+ if (byteArray.Length == 0)`
	`37`	`+ {`
	`38`	`+ return objType.DefaultValue();`
	`39`	`+ }`
`40`	`40`	`var utf8Json = Encoding.Convert(encoding, Encoding.UTF8, byteArray);`
`41`	`41`	`return JsonSerializer.Deserialize(utf8Json, objType, options);`
`42`	`42`	`}`
`@@ -49,7 +49,9 @@ public static class ApiResponseContextExtensions`
`49`	`49`	`else`
`50`	`50`	`{`
`51`	`51`	`var utf8Json = await content.ReadAsByteArrayAsync().ConfigureAwait(false);`
`52`		`- return JsonSerializer.Deserialize(utf8Json, objType, options);`
	`52`	`+ return utf8Json.Length == 0`
	`53`	`+ ? objType.DefaultValue()`
	`54`	`+ : JsonSerializer.Deserialize(utf8Json, objType, options);`
`53`	`55`	`}`
`54`	`56`	`}`
`55`	`57`
`@@ -61,13 +63,15 @@ public static class ApiResponseContextExtensions`
`61`	`63`	`/// <returns></returns>`
`62`	`64`	`public static async Task<object?> XmlDeserializeAsync(this ApiResponseContext context, Type objType)`
`63`	`65`	`{`
`64`		`- if (context.HttpContext.ResponseMessage == null)`
	`66`	`+ var response = context.HttpContext.ResponseMessage;`
	`67`	`+ if (response == null)`
`65`	`68`	`{`
`66`	`69`	`return objType.DefaultValue();`
`67`	`70`	`}`
`68`	`71`
	`72`	`+ var content = response.Content;`
`69`	`73`	`var options = context.HttpContext.HttpApiOptions.XmlDeserializeOptions;`
`70`		`- var xml = await context.HttpContext.ResponseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);`
	`74`	`+ var xml = await content.ReadAsStringAsync().ConfigureAwait(false);`
`71`	`75`	`return XmlSerializer.Deserialize(xml, objType, options);`
`72`	`76`	`}`
`73`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -86,13 +86,22 @@ public Task OnRequestAsync(ApiRequestContext context)`
`86`	`86`	`/// <returns></returns>`
`87`	`87`	`public async Task OnResponseAsync(ApiResponseContext context)`
`88`	`88`	`{`
`89`		`- if (context.ActionDescriptor.Return.DataType.IsRawType == true)`
	`89`	`+ var dataType = context.ActionDescriptor.Return.DataType;`
	`90`	`+ if (dataType.IsRawType == true)`
`90`	`91`	`{`
`91`	`92`	`return;`
`92`	`93`	`}`
`93`	`94`
`94`		`- var contenType = context.HttpContext.ResponseMessage?.Content.Headers.ContentType;`
`95`		`- if (this.EnsureMatchAcceptContentType && this.IsMatchAcceptContentType(contenType) == false)`
	`95`	`+ var response = context.HttpContext.ResponseMessage;`
	`96`	`+ if (response == null)`
	`97`	`+ {`
	`98`	`+ return;`
	`99`	`+ }`
	`100`	`+`
	`101`	`+ var contenType = response.Content.Headers.ContentType;`
	`102`	`+ if (contenType != null`
	`103`	`+ && this.EnsureMatchAcceptContentType`
	`104`	`+ && this.IsMatchAcceptContentType(contenType) == false)`
`96`	`105`	`{`
`97`	`106`	`return;`
`98`	`107`	`}`
`@@ -101,15 +110,16 @@ public async Task OnResponseAsync(ApiResponseContext context)`
`101`	`110`	`await this.SetResultAsync(context).ConfigureAwait(false);`
`102`	`111`	`}`
`103`	`112`
	`113`	`+`
`104`	`114`	`/// <summary>`
`105`	`115`	`/// 指示响应的ContentType与AcceptContentType是否匹配`
`106`	`116`	`/// 返回false则调用下一个ApiReturnAttribute来处理响应结果`
`107`	`117`	`/// </summary>`
`108`	`118`	`/// <param name="responseContentType">响应的ContentType</param>`
`109`	`119`	`/// <returns></returns>`
`110`		`- protected virtual bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)`
	`120`	`+ protected virtual bool IsMatchAcceptContentType(MediaTypeHeaderValue responseContentType)`
`111`	`121`	`{`
`112`		`- return MediaTypeUtil.IsMatch(this.AcceptContentType.MediaType, responseContentType?.MediaType);`
	`122`	`+ return MediaTypeUtil.IsMatch(this.AcceptContentType.MediaType, responseContentType.MediaType);`
`113`	`123`	`}`
`114`	`124`
`115`	`125`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -43,11 +43,11 @@ public JsonReturnAttribute(double acceptQuality)`
`43`	`43`	`/// </summary>`
`44`	`44`	`/// <param name="responseContentType">响应的ContentType</param>`
`45`	`45`	`/// <returns></returns>`
`46`		`- protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)`
	`46`	`+ protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue responseContentType)`
`47`	`47`	`{`
`48`	`48`	`return base.IsMatchAcceptContentType(responseContentType)`
`49`		`- \|\| MediaTypeUtil.IsMatch(textJson, responseContentType?.MediaType)`
`50`		`- \|\| MediaTypeUtil.IsMatch(problemJson, responseContentType?.MediaType);`
	`49`	`+ \|\| MediaTypeUtil.IsMatch(textJson, responseContentType.MediaType)`
	`50`	`+ \|\| MediaTypeUtil.IsMatch(problemJson, responseContentType.MediaType);`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,4 @@`
`1`		`-using System.Net;`
`2`		`-using System.Threading.Tasks;`
	`1`	`+using System.Threading.Tasks;`
`3`	`2`	`using WebApiClientCore.Exceptions;`
`4`	`3`
`5`	`4`	`namespace WebApiClientCore.Attributes`
`@@ -34,26 +33,35 @@ public RawReturnAttribute(double acceptQuality)`
`34`	`33`	`{`
`35`	`34`	`}`
`36`	`35`
	`36`	`+ /// <summary>`
	`37`	`+ /// 指示是否可以设置结果`
	`38`	`+ /// </summary>`
	`39`	`+ /// <param name="context">上下文</param>`
	`40`	`+ /// <returns></returns>`
	`41`	`+ protected override bool CanSetResult(ApiResponseContext context)`
	`42`	`+ {`
	`43`	`+ return context.ActionDescriptor.Return.DataType.IsRawType;`
	`44`	`+ }`
	`45`	`+`
`37`	`46`	`/// <summary>`
`38`	`47`	`/// 设置结果值`
`39`	`48`	`/// </summary>`
`40`	`49`	`/// <param name="context">上下文</param>`
`41`	`50`	`/// <returns></returns>`
`42`	`51`	`public async override Task SetResultAsync(ApiResponseContext context)`
`43`	`52`	`{`
`44`		`- var dataType = context.ActionDescriptor.Return.DataType;`
`45`	`53`	`var response = context.HttpContext.ResponseMessage;`
`46`		`-`
`47`		`- if (dataType.IsRawType == false \|\| response == null)`
	`54`	`+ if (response == null)`
`48`	`55`	`{`
`49`	`56`	`return;`
`50`	`57`	`}`
`51`	`58`
`52`		`- if (this.EnsureSuccessStatusCode && IsSuccessStatusCode(response.StatusCode) == false)`
	`59`	`+ if (this.EnsureSuccessStatusCode && response.IsSuccessStatusCode == false)`
`53`	`60`	`{`
`54`	`61`	`throw new ApiResponseStatusException(response);`
`55`	`62`	`}`
`56`	`63`
	`64`	`+ var dataType = context.ActionDescriptor.Return.DataType;`
`57`	`65`	`if (dataType.IsRawHttpResponseMessage == true)`
`58`	`66`	`{`
`59`	`67`	`context.Result = response;`
`@@ -71,16 +79,5 @@ public async override Task SetResultAsync(ApiResponseContext context)`
`71`	`79`	`context.Result = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);`
`72`	`80`	`}`
`73`	`81`	`}`
`74`		`-`
`75`		`- /// <summary>`
`76`		`- /// 指示http状态码是否为成功的状态码`
`77`		`- /// </summary>`
`78`		`- /// <param name="statusCode">http状态码</param>`
`79`		`- /// <returns></returns>`
`80`		`- private static bool IsSuccessStatusCode(HttpStatusCode statusCode)`
`81`		`- {`
`82`		`- var status = (int)statusCode;`
`83`		`- return status >= 200 && status <= 299;`
`84`		`- }`
`85`	`82`	`}`
`86`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,10 +38,10 @@ public XmlReturnAttribute(double acceptQuality)`
`38`	`38`	`/// </summary>`
`39`	`39`	`/// <param name="responseContentType">响应的ContentType</param>`
`40`	`40`	`/// <returns></returns>`
`41`		`- protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)`
	`41`	`+ protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue responseContentType)`
`42`	`42`	`{`
`43`	`43`	`return base.IsMatchAcceptContentType(responseContentType)`
`44`		`- \|\| MediaTypeUtil.IsMatch(textXml, responseContentType?.MediaType);`
	`44`	`+ \|\| MediaTypeUtil.IsMatch(textXml, responseContentType.MediaType);`
`45`	`45`	`}`
`46`	`46`
`47`	`47`	`/// <summary>`