使用newtonsoft完美序列化WebApi返回的ValueTuple

    因爲開發功能的須要,又懶得新建太多的class,因此ValueTuple是個比較好的偷懶方法,可是,因爲WebApi須要返回序列化後的json,默認的序列化只能將ValueTuple定義的各個屬性序列化成Item1...n

    可是微軟仍是良心的爲序列化留下入口,編譯器會在每一個返回ValueTuple<>的函數或者屬性上,增長一個TupleElementNamesAttribute特性,該類的TransformNames就是存着所設置的屬性的名稱(強烈須要記住:是每一個使用到ValueTuple的函數或者屬性纔會添加,而不是加在有使用ValueTuple的類上),好比 (string str1,string str2) 那麼 TransformNames=["str1","str2"],那麼如今有以下一個class

　　public class A<T1,T2>
　　{
　　　　public T1 Prop1{set;get;}
　　　　public T2 Prop2{set;get;}
　　　　public (string str5,int int2) Prop3{set;get;}
　　}

　　通過測試,以下一個函數

　　public A<(string str1,string str2),(string str3,string str4)> testApi(){}

　　這樣一個函數testApi 的會加上 TupleElementNamesAttribute 特性,,TransformNames=["str1","str2","str3","str4","str5","int2"],注意了,,這裏只會添加一個TupleElementNamesAttribute特性,而後把A裏全部的名字按定義的順序包含進去.

　　而後咱們須要定義一個JsonConverter,用來專門針對一個函數或一個屬性的返回值進行了序列化

　　public class ValueTupleConverter : JsonConverter
    {
        private string[] _tupleNames = null;
        private NamingStrategy _strategy = null;

        //也能夠直接在這裏傳入特性
        public ValueTupleConverter(TupleElementNamesAttribute tupleNames, NamingStrategy strategy = null) 
        {
            _tupleNames = tupleNames.TransformNames.ToArrayEx();
            _strategy = strategy;
        }

        //這裏在構造函數裏把須要序列化的屬性或函數返回類型的names傳進來
        public ValueTupleConverter(string[] tupleNames, NamingStrategy strategy = null)  
        {
            _tupleNames = tupleNames;
            _strategy = strategy;
        }
        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value != null && value is ITuple v)
            {
                writer.WriteStartObject();
                for (int i = 0; i < v.Length; i++)
                {
                    var pname = _tupleNames[i];

                    //根據規則,設置屬性名
                    writer.WritePropertyName(_strategy?.GetPropertyName(pname, true) ?? pname);  

                    if (v[i] == null)
                    {
                        writer.WriteNull();
                    }
                    else
                    {
                        serializer.Serialize(writer, v[i]);
                    }
                }
                writer.WriteEndObject();
            }
        }
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            //只須要實現序列化,,不須要反序列化,由於只管輸出,因此,這個寫不寫無所謂
            throw new NotImplementedException();  
        }
        public override bool CanConvert(Type objectType)
        {
            return objectType.IsValueTuple();
        }
    }

 　　接下來講說實現的原理:

 　　　　1.newtonsoft.json的組件裏,有一個ContactResolver類,用於對不一樣的類的解析,類庫中自帶的DefaultContractResolver默認定義了將類解析成各個JsonProperty,利用這個類,可用於將ValueTuple的定義的名字當作屬性,返回給序列化器

　　 　　2.asp.net core的Formatter,能夠對Action輸出的對象進行格式化,通常用於好比json的格式化器或者xml格式化器的定義,利用格式化器,在Action最後輸出的時候,配合ContractResolver進行序列化

　　下面的實現中,不少地方須要判斷是否爲ValueTuple,爲了節省代碼,所以,先寫一個Helper:

　　public static class ValueTupleHelper
    {
        private static ConcurrentDictionary<Type,bool> _cacheIsValueTuple=new ConcurrentDictionary<Type, bool>();

        public static bool IsValueTuple(this Type type)
        {
            return _cacheIsValueTuple.GetOrAdd(type, x => x.IsValueType && x.IsGenericType &&
                                                          (x.FullName.StartsWith("System.ValueTuple") || x.FullName
                                                              ?.StartsWith("System.ValueTuple`") == true)
                                                          );

        }
    }

　　那麼開始來定義一個ContractResolver,實現的原理請看註釋

　　public class CustomContractResolver : DefaultContractResolver
    {
        private MethodInfo _methodInfo = null;
        private IContractResolver _parentResolver = null;

        public CustomContractResolver(MethodInfo methodInfo, IContractResolver? parentContractResolver = null)
        {
            _methodInfo = methodInfo;
            _parentResolver = parentContractResolver;
        }

        public override JsonContract ResolveContract(Type type)
        {
            if (!type.GetProperties()
                .Where(x => x.CanRead && x.PropertyType.IsValueTuple())
                .Any())  //若是Type類中不包含可讀的ValueTuple類型的屬性,則調用預約義的Resolver處理,當前Resolver只處理包含ValueTuple的類
            {
                return _parentResolver?.ResolveContract(type);
            }

            var rc = base.ResolveContract(type);

            return rc;
        }

        public MethodInfo Method => _methodInfo;

        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
        {
            //CreateProperty函數的結果,不須要額外加緩存,由於每一個Method的返回Type,只會調用一次
            JsonProperty property = base.CreateProperty(member, memberSerialization);  //先調用默認的CreateProperty函數,建立出默認JsonProperty

            var pi = member as PropertyInfo;

            if (property.PropertyType.IsValueTuple())
            {
                var attr = pi.GetCustomAttribute<TupleElementNamesAttribute>();  //獲取定義在屬性上的特性

                if (attr != null)  
                {
                    //若是該屬性是已經編譯時有添加了TupleElementNamesAttribute特性的,,則不須要從method獲取
                    //這裏主要是爲了處理 (string str1,int int2) Prop3 這種狀況
                    property.Converter = new ValueTupleConverter(attr, this.NamingStrategy);
                }
                else 
                {
                    //從輸入的method獲取,而且須要計算當前屬性所屬的泛型是在第幾個,而後計算出在TupleElementNamesAttribute.Names中的偏移
                    //這個主要是處理好比T2 Prop2 T2=ValueTuple的這種狀況
                    var mAttr = (TupleElementNamesAttribute)_methodInfo.ReturnTypeCustomAttributes.GetCustomAttributes(typeof(TupleElementNamesAttribute), true).FirstOrDefault(); //用來獲取valueTuple的各個字段名稱
                    var basePropertyClass = pi.DeclaringType.GetGenericTypeDefinition(); //屬性定義的泛型基類 如 A<T1,T2>
                    var basePropertyType = basePropertyClass.GetProperty(pi.Name)!.PropertyType; //獲取基類屬性的返回類型 就是T1 ,好比獲取在A<(string str1,string str2),(string str3,string str4)> 中 Prop1 返回的類型是對應基類中的T1仍是T2
                    var index = basePropertyType.GenericParameterPosition;//獲取屬性所在的序號,用於計算 mAttr.Names中的偏移量
                    var skipNamesCount = (pi.DeclaringType as TypeInfo).GenericTypeArguments
                                            .Take(index)
                                            .Sum(x => x.IsValueTuple() ? x.GenericTypeArguments.Length : 0); ;  //計算TupleElementNamesAttribute.TransformNames中當前類的偏移量
                    var names = mAttr.TransformNames
                        .Skip(skipNamesCount)
                        .Take(pi.PropertyType.GenericTypeArguments.Length)
                        .ToArrayEx(); //獲取當前類的全部name
                    property.Converter = new ValueTupleConverter(names, this.NamingStrategy);  //傳入converter
                }

                property.GetIsSpecified = x => true;
                property.ItemConverter = property.Converter;  //傳入converter
                property.ShouldSerialize = x => true;
                property.HasMemberAttribute = false;
            }
            return property;
        }
        protected override JsonConverter? ResolveContractConverter(Type objectType) //該函數可用於返回特定類型類型的JsonConverter
        {
            var type = base.ResolveContractConverter(objectType);

            //這裏主要是爲了忽略一些在class上定義了JsonConverter的狀況,由於有些好比 A<T1,T2> 在序列化的時候,並沒有法知道ValueTuple定義的屬性名,這裏添加忽略是爲了跳過已定義過的JsonConverter
            //若有須要,可在這裏多添加幾個
            if (type is ResultReturnConverter)
            {
                return null;
            }
            else
            {
                return type;
            }
        }
    }

　　爲了能兼容用於預先定義的ContractResolver,所以,先定義一個CompositeContractResolver,用於合併多個ContractResolver,可看可不看:

/// <summary>
    /// 合併多個IContractResolver,,並只返回第一個返回非null的Contract,若是全部列表中的ContractResolver都返回null,則調用DefaultContractResolver返回默認的JsonContract
    /// </summary>
    public class CompositeContractResolver : IContractResolver, IEnumerable<IContractResolver>
    {
        private readonly IList<IContractResolver> _contractResolvers = new List<IContractResolver>();
        private static DefaultContractResolver _defaultResolver = new DefaultContractResolver();
        private ConcurrentDictionary<Type, JsonContract> _cacheContractResolvers=new ConcurrentDictionary<Type, JsonContract>();

        /// <summary>
        /// 返回列表中第一個返回非null的Contract,若是全部列表中的ContractResolver都返回null,則調用DefaultContractResolver返回默認的JsonContract
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public JsonContract ResolveContract(Type type)
        {
            return _cacheContractResolvers.GetOrAdd(type, m =>
            {
                for (int i = 0; i < _contractResolvers.Count; i++)
                {
                    var contact = _contractResolvers[i].ResolveContract(type);

                    if (contact != null)
                    {
                        return contact;
                    }
                }

                return _defaultResolver.ResolveContract(type);
            });
        }

        public void Add(IContractResolver contractResolver)
        {
            if (contractResolver == null) return;

            _contractResolvers.Add(contractResolver);
        }

        public IEnumerator<IContractResolver> GetEnumerator()
        {
            return _contractResolvers.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }

View Code

　　接下來,就該定義OutputFormatter了

　　public class ValueTupleOutFormatter : TextOutputFormatter
    {
        private static ConcurrentDictionary<Type, bool> _canHandleType = new ConcurrentDictionary<Type, bool>();  //緩存一個Type是否能處理,提升性能,不用每次都判斷
        private static ConcurrentDictionary<MethodInfo, JsonSerializerSettings> _cacheSettings = new ConcurrentDictionary<MethodInfo, JsonSerializerSettings>(); //用於緩存不一樣的函數的JsonSerializerSettings,各自定義,避免相互衝突

        private Action<CustomContractResolver> _resolverConfigFunc = null;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="resolverConfigFunc">用於在註冊Formatter的時候對ContractResolver進行配置修改,好比屬性名的大小寫之類的</param>
        public ValueTupleOutFormatter(Action<CustomContractResolver> resolverConfigFunc = null)
        {
            SupportedMediaTypes.Add("application/json");
            SupportedMediaTypes.Add("text/json");
            SupportedEncodings.Add(Encoding.UTF8);
            SupportedEncodings.Add(Encoding.Unicode);

            _resolverConfigFunc = resolverConfigFunc;
        }

        protected override bool CanWriteType(Type type)
        {
            return _canHandleType.GetOrAdd(type, t =>
            {
                return type.GetProperties()  //判斷該類是否包含有ValueTuple的屬性
                    .Where(x => x.CanRead && (x.GetCustomAttribute<TupleElementNamesAttribute>() != null || x.PropertyType.IsValueTuple()))
                    .Any();
            });
        }
        public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
        {
            var acce = (IActionContextAccessor)context.HttpContext.RequestServices.GetService(typeof(IActionContextAccessor));
            var endpoint = acce.ActionContext.HttpContext.GetEndpoint();
            var ac = endpoint.Metadata.GetMetadata<ControllerActionDescriptor>();   //用來獲取當前Action對應的函數信息

            var settings = _cacheSettings.GetOrAdd(ac.MethodInfo, m =>  //這裏主要是爲了配置settings,每一個methodinfo對應一個本身的settings,固然也就是每一個MethodInfo一個CustomContractResolver,防止相互衝突
            {
                var orgSettings = JsonConvert.DefaultSettings?.Invoke();  //獲取默認的JsonSettings
                var tmp = orgSettings != null ? cloneSettings(orgSettings) : new JsonSerializerSettings();  //若是不存在默認的,則new一個,若是已存在,則clone一個新的
                var resolver = new CustomContractResolver(m, tmp.ContractResolver is CompositeContractResolver ? null : tmp.ContractResolver); //建立自定義ContractResolver,傳入函數信息

                _resolverConfigFunc?.Invoke(resolver);  //調用配置函數

                if (tmp.ContractResolver != null)  //若是已定義過ContractResolver,則使用CompositeContractResolver進行合併
                {
                    if (tmp.ContractResolver is CompositeContractResolver c)  //若是定義的是CompositeContractResolver,則直接插入到最前
                    {
                        c.Insert(0, resolver);
                    }
                    else
                    {
                        tmp.ContractResolver = new CompositeContractResolver()
                        {
                            resolver,
                            tmp.ContractResolver
                        };
                    }
                }
                else
                {
                    tmp.ContractResolver = new CompositeContractResolver()
                    {
                        resolver
                    };
                }

                return tmp;
            });

            var json = JsonConvert.SerializeObject(context.Object, Formatting.None, settings);  //調用序列化器進行序列化
            await context.HttpContext.Response.Body.WriteAsync(selectedEncoding.GetBytes(json));
        }

        private JsonSerializerSettings cloneSettings(JsonSerializerSettings settings)
        {
            var tmp = new JsonSerializerSettings();

            var properties = settings.GetType().GetProperties();

            foreach (var property in properties)
            {
                var pvalue = property.GetValue(settings);

                if (pvalue is ICloneable p2)
                {
                    property.SetValue(tmp, p2.Clone());
                }
                else
                {
                    property.SetValue(tmp, pvalue);
                }
            }

            return tmp;
        }

    }

　　到此,該定義的類都定義完了,下面是註冊方法:在Start.cs中:

　　　　public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews(opt =>
            {
                opt.OutputFormatters.Insert(0,new ValueTupleOutFormatter(x =>
                {
                    x.NamingStrategy= new CamelCaseNamingStrategy(true,true);  //這裏主要是爲了演示對CustomContractResolver的配置,設置了全部屬性首字母小寫
                }));
            }).AddNewtonsoftJson();
        }

　　註冊完成後,用下面的Action可測試:

    public class ApiTestController : ControllerBase
    {
        [FromBodyJson()]
        public IActionResult test1(List<(string productid,int qty)> details)
        {

            return Content("success");
        }

        public ResultReturn<(string str1, int int3)> Test()
        {
            return new SuccessResultReturn<(string str1, int int3)>(("2222",222));
        }

        public Test<(string Y1, string Y2), (string str1, string t2)> Test2()
        {
            return new Test< (string Y1, string Y2),(string str1, string t2)>(("111","22222"),("3333","44444") );
        }
    }

View Code

 　　

　　總結一下,上面實現的原理是: 自定義一個OutputFormatter,在WriteResponseBodyAsync中,能夠獲取到當前的Action對應的MethodInfo,而後利用編譯器在全部返回ValueTuple的地方,都加了TupleElementNamesAttribute的功能,獲取到使用時定義的ValueTuple各個Item的名字,再利用ContractResolver的CreateProperty功能,將定義的各個Item轉換爲對應的name.而後使用newtonsoft的序列化器,進行json序列化.

　　以上代碼只能處理返回時,返回的類型爲ValueTuple<T1...n>或者返回的類型中包含了ValueTuple<T1....n>的屬性,可是對於函數內,不用於返回的,則沒法處理,好比

　　public object Test2()
   {
       var s=  new Test< (string Y1, string Y2),(string str1, string t2)>(("111","22222"),("3333","44444") );
       JsonConvert.SerializeObject(s);
       return null;
   }

　　這種狀況的變量s的序列化就沒辦法了