原始类型返回声明，accpet头设置为默认为空；

完善MediaType的匹配计算；
默认的accpet的q值设置为0.001的最小值；

Author: xljiulang

App/App.csproj

@@ -2,7 +2,7 @@
 
 	<PropertyGroup>
 		<OutputType>Exe</OutputType>
-		<TargetFramework>netcoreapp3.1</TargetFramework>
+		<TargetFramework>net5.0</TargetFramework>
 	</PropertyGroup>
 
 	<ItemGroup>

App/Clients/IUserApi.cs

@@ -15,7 +15,6 @@ namespace App.Clients
     [LoggingFilter]
     [OAuthToken]
     [HttpHost("http://localhost:6000/")]
-    [JsonNetReturn]
     public interface IUserApi : IHttpApi
     {
         [HttpGet("api/users/{account}")]
@@ -31,7 +30,7 @@ public interface IUserApi : IHttpApi
 
 
         [HttpGet("api/users/{account}")]
-        [XmlReturn]
+        [XmlReturn] 
         ITask<string> GetExpectXmlAsync([Required] string account, CancellationToken token = default);
 
 

WebApiClientCore.Test/BuildinUtils/MediaTypeTest.cs

@@ -0,0 +1,29 @@
+using Xunit;
+
+namespace WebApiClientCore.Test.ResponseCaches
+{
+    public class MediaTypeTest
+    {
+        [Fact]
+        public void IsMatchTest()
+        {
+            Assert.True(MediaType.IsMatch("a/a", "a/a"));
+            Assert.True(MediaType.IsMatch("a/a", "a/a"));
+            Assert.True(MediaType.IsMatch("a/a", "A/a"));
+            Assert.True(MediaType.IsMatch("a/a", "A/A"));
+
+            Assert.True(MediaType.IsMatch("a/*", "A/A"));
+            Assert.True(MediaType.IsMatch("*/*", "A/A"));
+
+            Assert.False(MediaType.IsMatch("a/b", "a/a"));
+            Assert.False(MediaType.IsMatch("a/B", "A/a"));
+            Assert.False(MediaType.IsMatch("a/b", "A/A"));
+
+            Assert.False(MediaType.IsMatch("a/*", "b/A"));
+            Assert.False(MediaType.IsMatch("a/*", null));
+            Assert.False(MediaType.IsMatch("a/*", ""));
+            Assert.False(MediaType.IsMatch("a", "a/a"));
+        }
+
+    }
+}

WebApiClientCore/ApiReturnDescriptor.cs

@@ -79,15 +79,13 @@ public ApiReturnDescriptor(MethodInfo method, Type interfaceType)
         /// <returns></returns>
         private static IEnumerable<IApiReturnAttribute> GetDefaultAttributes(ApiDataTypeDescriptor dataType)
         {
-            const double acceptQuality = 0.01d;
+            const double acceptQuality = 0.001;
             if (dataType.IsRawType == true)
             {
                 yield return new RawReturnAttribute(acceptQuality);
-                yield return new JsonReturnAttribute(acceptQuality);
-                yield return new XmlReturnAttribute(acceptQuality);
             }
             else
-            {
+            { 
                 yield return new JsonReturnAttribute(acceptQuality);
                 yield return new XmlReturnAttribute(acceptQuality);
                 yield return new NoneReturnAttribute(acceptQuality);

WebApiClientCore/Attributes/ReturnAttributes/ApiReturnAttribute.cs

@@ -105,7 +105,7 @@ public async Task OnResponseAsync(ApiResponseContext context)
         /// <returns></returns>
         protected virtual bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)
         {
-            return string.Equals(this.AcceptContentType.MediaType, responseContentType?.MediaType, StringComparison.OrdinalIgnoreCase);
+            return MediaType.IsMatch(this.AcceptContentType.MediaType, responseContentType?.MediaType);
         }
 
         /// <summary>

WebApiClientCore/Attributes/ReturnAttributes/JsonReturnAttribute.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Net.Http.Headers;
+using System.Net.Http.Headers;
 using System.Threading.Tasks;
 using WebApiClientCore.HttpContents;
 
@@ -13,7 +12,7 @@ public class JsonReturnAttribute : ApiReturnAttribute
         /// <summary>
         /// text/json
         /// </summary>
-        private static readonly string  textJson ="text/json";
+        private static readonly string textJson = "text/json";
 
         /// <summary>
         /// json内容的结果特性
@@ -40,8 +39,7 @@ public JsonReturnAttribute(double acceptQuality)
         /// <returns></returns>
         protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)
         {
-            return base.IsMatchAcceptContentType(responseContentType) ||
-                 string.Equals(textJson, responseContentType?.MediaType, StringComparison.OrdinalIgnoreCase); 
+            return base.IsMatchAcceptContentType(responseContentType) || MediaType.IsMatch(textJson, responseContentType?.MediaType);
         }
 
         /// <summary>

WebApiClientCore/Attributes/ReturnAttributes/XmlReturnAttribute.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Net.Http.Headers;
+using System.Net.Http.Headers;
 using System.Threading.Tasks;
 using WebApiClientCore.HttpContents;
 
@@ -40,8 +39,7 @@ public XmlReturnAttribute(double acceptQuality)
         /// <returns></returns>
         protected override bool IsMatchAcceptContentType(MediaTypeHeaderValue? responseContentType)
         {
-            return base.IsMatchAcceptContentType(responseContentType) || 
-                string.Equals(textXml, responseContentType?.MediaType, StringComparison.OrdinalIgnoreCase);
+            return base.IsMatchAcceptContentType(responseContentType) || MediaType.IsMatch(textXml, responseContentType?.MediaType);
         }
 
         /// <summary>

WebApiClientCore/BuildinUtils/MediaType.cs

@@ -0,0 +1,85 @@
+using System;
+
+namespace WebApiClientCore
+{
+    /// <summary>
+    /// 提供媒体类型比较
+    /// </summary>
+    static class MediaType
+    {
+        /// <summary>
+        /// 是否与目标匹配
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="target"></param>
+        /// <returns></returns>
+        public static bool IsMatch(string? source, string? target)
+        {
+            return IsMatch(source.AsSpan(), target.AsSpan());
+        }
+
+        /// <summary>
+        /// 是否与目标匹配
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="target"></param>
+        /// <returns></returns>
+        private static bool IsMatch(ReadOnlySpan<char> source, ReadOnlySpan<char> target)
+        {
+            var index = source.IndexOf('/');
+            var sourceMain = index >= 0 ? source.Slice(0, index) : source;
+            var sourceSub = index >= 0 ? source.Slice(index + 1) : ReadOnlySpan<char>.Empty;
+
+            index = target.IndexOf('/');
+            var targetMain = index >= 0 ? target.Slice(0, index) : target;
+            var targetSub = index >= 0 ? target.Slice(index + 1) : ReadOnlySpan<char>.Empty;
+
+            return MediaTypeMatch(sourceMain, targetMain) && MediaTypeMatch(sourceSub, targetSub);
+        }
+
+
+        /// <summary>
+        /// MediaType是否匹配
+        /// </summary>
+        /// <param name="source"></param>
+        /// <param name="target"></param>
+        /// <returns></returns>
+        private static bool MediaTypeMatch(ReadOnlySpan<char> source, ReadOnlySpan<char> target)
+        {
+            if (source.Length == 1 && source[0] == '*')
+            {
+                return true;
+            }
+
+            if (target.Length == 1 && target[0] == '*')
+            {
+                return true;
+            }
+
+            if (source.Length != target.Length)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < source.Length; i++)
+            {
+                var s = source[i];
+                var t = target[i];
+                if (char.IsUpper(s))
+                {
+                    s = char.ToLowerInvariant(s);
+                }
+                if (char.IsUpper(t))
+                {
+                    t = char.ToLowerInvariant(t);
+                }
+
+                if (s.Equals(t) == false)
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

WebApiClientCore/BuildinUtils/MultiplableComparer.cs

@@ -21,7 +21,11 @@ sealed class MultiplableComparer<TAttributeMultiplable> : IEqualityComparer<TAtt
         public bool Equals(TAttributeMultiplable x, TAttributeMultiplable y)
         {
             // 如果其中一个不允许重复，返回true将y过滤
-            return x.AllowMultiple == false || y.AllowMultiple == false;
+            if (x.GetType() == y.GetType())
+            {
+                return x.AllowMultiple == false || y.AllowMultiple == false;
+            }
+            return false;
         }
 
         /// <summary>