c# - 使用泛型处理可空类型与不可空类型

Question

我创建了一个 LookupConverter : JsonConverter 类来执行 ILookup 对象的 JSON 序列化和反序列化。正如您可能想象的那样，它有一些复杂性，必须处理泛型并且由于缺少公共(public)具体 Lookup 类。为了提高性能，它将特定于类型的反射工作缓存在静态泛型类中。效果很好!

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

如果之前的输出是 {"key1":[1,2,3]} ，那么我认为新的输出可能看起来像 {Groupings:{"key1":[1,2,3]},NullKeyValue:[4,5,6]} 。这很尴尬，但到目前为止还不错。或者它可以是 [{"key":"key1","values":[1,2,3]},{"key":null,"values":[4,5,6]}] 。无论哪种方式都没什么大不了的。

为此添加序列化是小菜一碟。

但是，到了反序列化的时候，我遇到了问题。我以前的反序列化器真的很简单(这里有一些复杂的缓存，也试着看过去，看看我的函数接受一个 jObject 和一个 serializer 并返回一个正确类型的对象，它像 lookupmaker(JObject.Load(reader), serializer); 一样使用

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);

好吧，现在我在想，我将创建一个 List s 的 KeyValuePair，如果有一个空键，则添加一个额外的值，然后像上面一样在其上抛出一个 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 不是不可为 null 的值类型。伟大的。我只会在我的静态类 where TKey : class 上添加一个约束 GenericMethodCache<TKey, TValue> ...只是，当我想要一个 : struct 版本时，我遇到了麻烦，因为 GenericMethodCache 的全部意义在于防止使用 object 的序列化程序代码具有处理泛型部分。我无法获得自动解析，因为解析不能使用类型约束来区分方法组。突然间，这个问题的复杂性爆发了，我不确定继续深入丛林试图让它发挥作用是否有意义，所以我正在寻求指导!

由于这是一个相当复杂的场景，这里是不处理空键的完整代码(接下来将详细介绍 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, 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);

      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, JsonSerializer, object>> _deserializerForType =
      new FunctionResultCache<Type, Func<JObject, JsonSerializer, object>>(type => {
         var genericMethodCache = typeof(GenericMethodCache<,>).MakeGenericType(type.GetGenericArguments());
         return (Func<JObject, JsonSerializer, 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, Func<object, object>>(type => {
         var genericMethodCache = typeof(GenericMethodCache<,>).MakeGenericType(type.GetGenericArguments());
         return (Func<object, object>) genericMethodCache.GetMethod(nameof(GenericMethodCache<int, int>.GetKeyFetcher)).Invoke(null, new object[0]);
      }
   );
}

FunctionResultCache 基本上只是一个具有特殊属性的 Dictionary，当您索引到一个不存在的键时，它会运行一个函数(在构造函数中传递)来获取值，然后存储并缓存该值并返回它给你，所以下次你索引到同一个键时，它会返回缓存的值。

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

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

Answer 1

你可以用 (TKey)(object)null 代替 (TKey)null。当然，如果 TKey 是不可为 null 的值类型，这将抛出一个 NullReferenceException，但这似乎是有道理的，因为所讨论的 JSON 不会被反序列化为ILookup 与指定类型的 TKey。