c# – 使用泛型处理可空类型与非可空类型

我创建了一个LookupConverter：JsonConverter类来执行ILookup对象的 JSON序列化和反序列化.正如您可能想象的那样,它有一些复杂性,必须处理泛型,并且由于缺少公共具体的Lookup类.为了提高性能,它将特定于类型的反射工作缓存在静态泛型类中.它完美无缺！

好吧,几乎完美.我今天才意识到它无法处理包含空键的ILookup的序列化.经过一番思考并意识到在JSON中,没有简单的方法来表示对象中的空键(因为每个键都被转换为字符串),我想我只是让输出对象变大一点.

如果前一个输出是例如{“key1”：[1,2,3]},那么我认为新输出看起来像{Groupings：{“key1”：[1,NullKeyValue ：[4,5,6]}.这很尴尬,但到目前为止还不错.或者它可以是[{“key”：“key1”,“values”：[1,{“key”：null,“values”：[4,6]}].无论如何都没什么大不了的

为此添加序列化很简单.

但是,当反序列化的时候,我遇到了问题.我以前的反序列化程序非常简单(这里有一些复杂的缓存,尝试过去看看,我只看到我的函数接受一个jObject和一个序列化程序并返回一个正确类型的对象,它就像lookupmaker一样使用(JObject.Load) (读者),序列化器);

public static Func<JObject,JsonSerializer,object> GetLookupMaker() =>
   (jObject,serializer) => ((IEnumerable<KeyValuePair<string,JToken>>) jObject)
      .SelectMany(
         kvp => kvp.Value.ToObject<List<TValue>>(),(kvp,value) => new KeyValuePair<TKey,TValue>(Convert<TKey>(kvp.Key),value)
      )
      .ToLookup(kvp => kvp.Key,kvp => kvp.Value);

好的,所以现在我想,我只是创建一个KeyValuePairs列表,如果有一个null键则添加一个额外的值,然后就像上面那样抛出一个ToLookup：

var list = new List<KeyValuePair<TKey,List<TValue>>>();
var nullKeyValue = jObject["NullKeyValue"];
if (nullKeyValue != null) {
   list.Add(new KeyValuePair<TKey,List<TValue>>(null,nullKeyValue.ToObject<List<TValue>>()));
} //                                             ^^^^ this null
// Then here append the items from jObject["Groupings"],and finally ToLookup.

但是现在我在上面的Add中得到一个错误：

Argument type ‘null’ is not assignable to parameter type ‘TKey’.

嗯,当然不是.它无法保证TKey不是非可空值类型.大.我只是抛出一个约束,其中TKey：class在我的静态类GenericMethodCache< TKey,TValue> …只有,当我想要一个：struct版本时,我遇到了麻烦,因为GenericMethodCache的重点是防止使用对象的序列化程序代码必须处理泛型部分.我无法获得自动分辨率,因为分辨率不能使用类型约束来区分方法组.突然间,这种情况的复杂性爆发了,我不确定继续深入丛林试图让它工作有意义,所以我正在寻求指导！

由于这是一个非常复杂的场景,这里是完整的代码,它不处理null键(接下来是FunctionResultCache上的更多内容)：

public sealed class LookupConverter : JsonConverter {
   // ReSharper disable once CollectionNeverUpdated.Local
   private static readonly FunctionResultCache<Type,bool> s_typeCanConvertDictionary =
      new FunctionResultCache<Type,bool>(type =>
         new [] { type }
            .Concat(type.GetInterfaces())
            .Any(iface => iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(ILookup<,>))
      );
   public override bool CanConvert(Type objectType) => s_typeCanConvertDictionary[objectType];

   public override bool CanWrite => true;
   public override void WriteJson(JsonWriter writer,object value,JsonSerializer serializer) {
      writer.WriteStartObject();
      var groupings = (IEnumerable) value;
      var getKey = _keyFetcherForType[value.GetType()];
      foreach (dynamic grouping in groupings) {
         writer.WritePropertyName(getKey(grouping).ToString());
         serializer.Serialize(writer,(IEnumerable) grouping);
      }
      writer.WriteEndObject();
   }

   public override object ReadJson(JsonReader reader,Type objectType,object existingValue,JsonSerializer serializer) =>
      // ReSharper disable once AccessToStaticMemberViaDerivedType
      _deserializerForType[objectType](JObject.Load(reader),serializer);

   private static class GenericMethodCache<TKey,TValue> {
      public static Func<JObject,object> GetLookupMaker() =>
         (jObject,JToken>>) jObject)
            .SelectMany(
               kvp => kvp.Value.ToObject<List<TValue>>(),value)
            )
            .ToLookup(kvp => kvp.Key,kvp => kvp.Value);

      public static Func<object,object> GetKeyFetcher() =>
         grouping => ((IGrouping<TKey,TValue>) grouping)
            .Key;

      private static T Convert<T>(string input) {
         try {
            return (T) TypeDescriptor.GetConverter(typeof(T)).ConvertFromString(input);
         }
         catch (NotSupportedException) {
            return default(T);
         }
      }
   }

   // ReSharper disable once CollectionNeverUpdated.Local
   private readonly FunctionResultCache<Type,Func<JObject,object>> _deserializerForType =
      new FunctionResultCache<Type,object>>(type => {
         var genericMethodCache = typeof(GenericMethodCache<,>).MakeGenericType(type.GetGenericArguments());
         return (Func<JObject,object>) genericMethodCache.GetMethod(nameof(GenericMethodCache<int,int>.GetLookupMaker)).Invoke(null,new object[0]);
      }
   );

   // ReSharper disable once CollectionNeverUpdated.Local
   private readonly FunctionResultCache<Type,Func<object,object>> _keyFetcherForType =
      new FunctionResultCache<Type,>).MakeGenericType(type.GetGenericArguments());
         return (Func<object,int>.GetKeyFetcher)).Invoke(null,new object[0]);
      }
   );
}

FunctionResultCache基本上只是一个具有特殊属性的Dictionary,当你索引一个不存在的键时,它运行一个函数(在构造函数中传递)来获取值,然后存储&缓存值plus并将其返回给您,因此下次索引相同的键时,它将返回缓存的值.

对于这个问题的长度和代码我很抱歉.这是一个有点复杂的场景,为了得到有用的反馈,我必须展示一些有关正在发生的事情的细节.

附：关于此的一点注意事项：genericMethodCache.GetMethod(nameof(GenericMethodCache< int,int> .GetKeyFetcher)). nameof不喜欢泛型类型定义,例如GenericMethodCache<,>.它只喜欢泛型类型GenericMethodCache< int,int>.但是,从长远来看,int,int被忽略,并返回名称GenericMethodCache.