न्यूटॉन्सॉफ्ट JSON के साथ XmlException को क्रमबद्ध करने के लिए कैसे (डी)?

Question

यह नमूना कोड: प्रकार 'Newtonsoft.Json.Linq.JValue' की वस्तु कास्ट करने के लिए निम्न स्टैक ट्रेस के साथ 'System.String' टाइप करने में असमर्थ:

var json = JsonConvert.SerializeObject(new XmlException("bla")); 
var exception = JsonConvert.DeserializeObject<XmlException>(json); 

Newtonsoft.Json.dll में एक InvalidCastException फेंकता :

at System.Xml.XmlException..ctor(SerializationInfo info, StreamingContext context) 
at Void .ctor(System.Runtime.Serialization.SerializationInfo, System.Runtime.Serialization.StreamingContext)(Object[]) 
at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.CreateISerializable(JsonReader reader, JsonISerializableContract contract, JsonProperty member, String id) 
at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.CreateObject(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, Object existingValue) 
at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.CreateValueInternal(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, Object existingValue) 
at Newtonsoft.Json.Serialization.JsonSerializerInternalReader.Deserialize(JsonReader reader, Type objectType, Boolean checkAdditionalContent) 
at Newtonsoft.Json.JsonSerializer.DeserializeInternal(JsonReader reader, Type objectType) 
at Newtonsoft.Json.JsonConvert.DeserializeObject(String value, Type type, JsonSerializerSettings settings) 
at Newtonsoft.Json.JsonConvert.DeserializeObject[T](String value, JsonSerializerSettings settings) 
at Newtonsoft.Json.JsonConvert.DeserializeObject[T](String value) 
at TestJson.Program.Main(String[] args) in C:\Projects\TestJson\TestJson\Program.cs:line 21 
at System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args) 
at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args) 
at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly() 
at System.Threading.ThreadHelper.ThreadStart_Context(Object state) 
at System.Threading.ExecutionContext.RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx) 
at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state, Boolean preserveSyncCtx) 
at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state) 
at System.Threading.ThreadHelper.ThreadStart() 

क्या मुझे कुछ याद आ रही है?

एक मुद्दा https://github.com/JamesNK/Newtonsoft.Json/issues/801

Answer 1

पर बनाया गया है समस्या

मूल समस्या यहां ISerializabe + SerializationInfo जो मूल रूप से BinaryFormatter साथ काम करने के लिए डिजाइन किया गया JSON के बीच एक असंगति है, जो कमजोर टाइप किया जाता है, और है जिनकी धाराओं को दृढ़ता से टाइप किया जाता है। अर्थात। ISerializable के कार्यान्वयन कभी-कभी अपेक्षा करते हैं कि सीरियलाइजेशन स्ट्रीम में क्रमशः पूर्ण प्रकार की जानकारी शामिल है। और यह पता चला है कि XmlException में ऐसा एक कार्यान्वयन है।

विनिर्देश इस प्रकार हैं। जब Json.NET को ISerializable प्रकार के लिए कॉल करने के लिए जाता है, तो यह constructs a SerializationInfo और JsonFormatterConverter पास करता है जो SerializationInfo.GetValue(String, Type) कहलाता है जब JSON डेटा से आवश्यक प्रकार में कनवर्ट करने की नौकरी को संभालना चाहिए। अब, यह विधि अपवाद फेंकता है जब नामित मान नहीं मिलता है। और, दुर्भाग्यवश, कोई SerializationInfo.TryGetValue() विधि नहीं है, जिसके लिए कक्षाओं की आवश्यकता होती है जिन्हें वैकल्पिक फ़ील्ड को GetEnumerator() के साथ मैन्युअल रूप से लूप के लिए लूप करने की आवश्यकता होती है। लेकिन इसके अलावा, कन्स्ट्रक्टर में कनवर्टर सेट को पुनर्प्राप्त करने के लिए कोई तरीका नहीं है, जिसका अर्थ यह है कि वैकल्पिक फ़ील्ड आवश्यक होने पर परिवर्तित नहीं किए जा सकते हैं, इसलिए अपेक्षित प्रकार के साथ जरूरी जरूरतों को अवश्य ही किया जाना चाहिए।

आप reference source for the constructor of XmlException में देख सकते हैं:

protected XmlException(SerializationInfo info, StreamingContext context) : base(info, context) { 
     res     = (string) info.GetValue("res" , typeof(string)); 
     args    = (string[])info.GetValue("args", typeof(string[])); 
     lineNumber   = (int)  info.GetValue("lineNumber", typeof(int)); 
     linePosition  = (int)  info.GetValue("linePosition", typeof(int)); 

     // deserialize optional members 
     sourceUri = string.Empty; 
     string version = null; 
     foreach (SerializationEntry e in info) { 
      switch (e.Name) { 
       case "sourceUri": 
        sourceUri = (string)e.Value; 
        break; 
       case "version": 
        version = (string)e.Value; 
        break; 
      } 
     } 

ऐसा लगता है कि अभी भी एक e.ValueJValue नहीं इस बिंदु पर एक string है, इसलिए अक्रमांकन chokes।

Json.NET, JsonSerializerInternalReader.CreateISerializable() में फिर बाद से इस विशिष्ट समस्या को ठीक कर सकता है, जब उसके SerializationInfo निर्माण वास्तविक तार के साथ स्ट्रिंग-मान JValue टोकन की जगह, फिर से परिवर्तित JsonFormatterConverter में JValue करने के लिए यदि रूपांतरण आवश्यक है। हालांकि, यह श्रेणी समस्याओं का समाधान नहीं करेगा। उदाहरण के लिए, जब int जेसन.NET द्वारा गोल-ट्रिप किया जाता है तो यह long बन जाता है, जो बिना रूपांतरण के कलाकारों को फेंक देगा। और निश्चित रूप से DateTime फ़ील्ड रूपांतरण के बिना फेंक देगा। यह ISerializable कक्षाओं में एक तोड़ने वाला परिवर्तन भी होगा जो पहले जेसन.नेट के साथ काम करने के लिए हस्तनिर्मित किया गया था।

आप इस बारे में report an issue कर सकते हैं, लेकिन मुझे संदेह है कि यह जल्द ही तय हो जाएगा।

समस्या को हल करने के लिए एक और मजबूत दृष्टिकोण कस्टम JsonConverter बनाना होगा जो ISerializable प्रकारों के लिए पूर्ण प्रकार की जानकारी एम्बेड करता है।

समाधान 1: एम्बेड बाइनरी

पहले, सबसे आसान समाधान आपके JSON के अंदर एक BinaryFormatter धारा एम्बेड करने के लिए किया जाएगा। Exception कक्षाओं के लिए क्रमबद्धता कोड मूल रूप से BinaryFormatter के साथ संगत होना करने के लिए डिजाइन किया गया था, तो यह काफी विश्वसनीय होना चाहिए:

public class BinaryConverter<T> : JsonConverter where T : ISerializable 
{ 
    class BinaryData 
    { 
     public byte[] binaryData { get; set; } 
    } 

    public override bool CanConvert(Type objectType) 
    { 
     return typeof(T).IsAssignableFrom(objectType); 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     if (reader.TokenType == JsonToken.Null) 
      return null; 
     var data = serializer.Deserialize<BinaryData>(reader); 
     if (data == null || data.binaryData == null) 
      return null; 
     return BinaryFormatterHelper.FromByteArray<T>(data.binaryData); 

    } 

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     var data = new BinaryData { binaryData = BinaryFormatterHelper.ToByteArray(value) }; 
     serializer.Serialize(writer, data); 
    } 
} 

public static class BinaryFormatterHelper 
{ 
    public static byte [] ToByteArray<T>(T obj) 
    { 
     using (var stream = new MemoryStream()) 
     { 
      new BinaryFormatter().Serialize(stream, obj); 
      return stream.ToArray(); 
     } 
    } 

    public static T FromByteArray<T>(byte[] data) 
    { 
     return FromByteArray<T>(data, null); 
    } 

    public static T FromByteArray<T>(byte[] data, BinaryFormatter formatter) 
    { 
     using (var stream = new MemoryStream(data)) 
     { 
      formatter = (formatter ?? new BinaryFormatter()); 
      var obj = formatter.Deserialize(stream); 
      if (obj is T) 
       return (T)obj; 
      return default(T); 
     } 
    } 
} 

और फिर निम्न सेटिंग के साथ क्रमानुसार:

var settings = new JsonSerializerSettings { Converters = new[] { new BinaryConverter<Exception>() } }; 

कमियां हैं:

1. अविश्वसनीय डेटा deserializing एक गंभीर सुरक्षा खतरे है। चूंकि प्रकार की जानकारी स्वामित्व, अपठनीय क्रमबद्धता धारा के अंदर पूरी तरह से एम्बेडेड है, इसलिए आप यह नहीं जान सकते कि आप तब तक क्या निर्माण करने जा रहे हैं जब तक आप ऐसा नहीं कर लेते।

2. JSON पूरी तरह से अपठनीय है।

3. मुझे विश्वास है कि कुछ .Net संस्करणों पर BinaryFormatter गुम है।

4. मेरा मानना ​​है कि BinaryFormatter केवल पूर्ण विश्वास में उपयोग किया जा सकता है।

लेकिन यदि आप जो भी करने की कोशिश कर रहे हैं, वह आपके नियंत्रण में प्रक्रियाओं के बीच एक अपवाद को क्रमबद्ध करना है, तो यह काफी अच्छा हो सकता है।

समाधान 2: TypeNameHandling का उपयोग कर एम्बेड प्रकार की जानकारी।

Json.NET में उचित मूल्य पर JsonSerializer.TypeNameHandling सेट करके, क्रमबद्ध धारा में गैर-आदिम प्रकारों के लिए .NET प्रकार की जानकारी को एम्बेड करने की वैकल्पिक क्षमता भी है।

public class ISerializableConverter<T> : JsonConverter where T : ISerializable 
{ 
    public override bool CanConvert(Type objectType) 
    { 
     return typeof(T).IsAssignableFrom(objectType); 
    } 

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) 
    { 
     if (reader.TokenType == JsonToken.Null) 
      return null; 
     var oldTypeNameHandling = serializer.TypeNameHandling; 
     var oldAssemblyFormat = serializer.TypeNameAssemblyFormat; 
     try 
     { 
      if (serializer.TypeNameHandling == TypeNameHandling.None) 
       serializer.TypeNameHandling = TypeNameHandling.Auto; 
      else if (serializer.TypeNameHandling == TypeNameHandling.Arrays) 
       serializer.TypeNameHandling = TypeNameHandling.All; 
      var data = serializer.Deserialize<SerializableData>(reader); 
      var type = data.ObjectType; 
      var info = new SerializationInfo(type, new FormatterConverter()); 
      foreach (var item in data.Values) 
       info.AddValue(item.Key, item.Value.ObjectValue, item.Value.ObjectType); 
      var value = Activator.CreateInstance(type, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { info, serializer.Context }, serializer.Culture); 
      if (value is IObjectReference) 
       value = ((IObjectReference)value).GetRealObject(serializer.Context); 
      return value; 
     } 
     finally 
     { 
      serializer.TypeNameHandling = oldTypeNameHandling; 
      serializer.TypeNameAssemblyFormat = oldAssemblyFormat; 
     } 
    } 

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) 
    { 
     var oldTypeNameHandling = serializer.TypeNameHandling; 
     var oldAssemblyFormat = serializer.TypeNameAssemblyFormat; 
     try 
     { 
      var serializable = (ISerializable)value; 
      var context = serializer.Context; 
      var info = new SerializationInfo(value.GetType(), new FormatterConverter()); 
      serializable.GetObjectData(info, context); 
      var data = SerializableData.CreateData(info, value.GetType()); 

      if (serializer.TypeNameHandling == TypeNameHandling.None) 
       serializer.TypeNameHandling = TypeNameHandling.Auto; 
      else if (serializer.TypeNameHandling == TypeNameHandling.Arrays) 
       serializer.TypeNameHandling = TypeNameHandling.All; 
      // The following seems to be required by https://github.com/JamesNK/Newtonsoft.Json/issues/787 
      serializer.TypeNameAssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Full; 
      serializer.Serialize(writer, data, typeof(SerializableData)); 
     } 
     finally 
     { 
      serializer.TypeNameHandling = oldTypeNameHandling; 
      serializer.TypeNameAssemblyFormat = oldAssemblyFormat; 
     } 
    } 
} 

abstract class SerializableValue 
{ 
    [JsonIgnore] 
    public abstract object ObjectValue { get; } 

    [JsonIgnore] 
    public abstract Type ObjectType { get; } 

    public static SerializableValue CreateValue(SerializationEntry entry) 
    { 
     return CreateValue(entry.ObjectType, entry.Value); 
    } 

    public static SerializableValue CreateValue(Type type, object value) 
    { 
     if (value == null) 
     { 
      if (type == null) 
       throw new ArgumentException("type and value are both null"); 
      return (SerializableValue)Activator.CreateInstance(typeof(SerializableValue<>).MakeGenericType(type)); 
     } 
     else 
     { 
      type = value.GetType(); // Use most derived type 
      return (SerializableValue)Activator.CreateInstance(typeof(SerializableValue<>).MakeGenericType(type), value); 
     } 
    } 
} 

sealed class SerializableValue<T> : SerializableValue 
{ 
    public SerializableValue() : base() { } 

    public SerializableValue(T value) 
     : base() 
    { 
     this.Value = value; 
    } 

    public override object ObjectValue { get { return Value; } } 

    public override Type ObjectType { get { return typeof(T); } } 

    [JsonProperty("value", NullValueHandling = NullValueHandling.Ignore)] 
    public T Value { get; private set; } 
} 

abstract class SerializableData 
{ 
    public SerializableData() 
    { 
     this.Values = new Dictionary<string, SerializableValue>(); 
    } 

    public SerializableData(IEnumerable<SerializationEntry> values) 
    { 
     this.Values = values.ToDictionary(v => v.Name, v => SerializableValue.CreateValue(v)); 
    } 

    [JsonProperty("values", ItemTypeNameHandling = TypeNameHandling.Auto)] 
    public Dictionary<string, SerializableValue> Values { get; private set; } 

    [JsonIgnore] 
    public abstract Type ObjectType { get; } 

    public static SerializableData CreateData(SerializationInfo info, Type initialType) 
    { 
     if (info == null) 
      throw new ArgumentNullException("info"); 
     var type = info.GetSavedType(initialType); 
     if (type == null) 
      throw new InvalidOperationException("type == null"); 
     return (SerializableData)Activator.CreateInstance(typeof(SerializableData<>).MakeGenericType(type), info.AsEnumerable()); 
    } 
} 

sealed class SerializableData<T> : SerializableData 
{ 
    public SerializableData() : base() { } 

    public SerializableData(IEnumerable<SerializationEntry> values) : base(values) { } 

    public override Type ObjectType { get { return typeof(T); } } 
} 

public static class SerializationInfoExtensions 
{ 
    public static IEnumerable<SerializationEntry> AsEnumerable(this SerializationInfo info) 
    { 
     if (info == null) 
      throw new NullReferenceException(); 
     var enumerator = info.GetEnumerator(); 
     while (enumerator.MoveNext()) 
     { 
      yield return enumerator.Current; 
     } 
    } 

    public static Type GetSavedType(this SerializationInfo info, Type initialType) 
    { 
     if (initialType != null) 
     { 
      if (info.FullTypeName == initialType.FullName 
       && info.AssemblyName == initialType.Module.Assembly.FullName) 
       return initialType; 
     } 
     var assembly = Assembly.Load(info.AssemblyName); 
     if (assembly != null) 
     { 
      var type = assembly.GetType(info.FullTypeName); 
      if (type != null) 
       return type; 
     } 
     return initialType; 
    } 
} 

और फिर निम्न सेटिंग का उपयोग:

यह अर्द्ध पैदा करता आदिम प्रकार के लिए रैपर के साथ-साथ इस क्षमता का उपयोग करना, यह एक JsonConverter कि SerializationInfo और SerializationEntry समाहित और सभी ज्ञात प्रकार में जानकारी शामिल है बनाने के लिए संभव है निम्नलिखित की तरह पठनीय JSON:

{ 
    "$type": "Question35015357.SerializableData`1[[System.Xml.XmlException, System.Xml, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
    "values": { 
    "ClassName": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": "System.Xml.XmlException" 
    }, 
    "Message": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": "bla" 
    }, 
    "Data": { 
     "$type": "Question35015357.SerializableValue`1[[System.Collections.IDictionary, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "InnerException": { 
     "$type": "Question35015357.SerializableValue`1[[System.Exception, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "HelpURL": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "StackTraceString": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "RemoteStackTraceString": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "RemoteStackIndex": { 
     "$type": "Question35015357.SerializableValue`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": 0 
    }, 
    "ExceptionMethod": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "HResult": { 
     "$type": "Question35015357.SerializableValue`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": -2146232000 
    }, 
    "Source": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "res": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": "Xml_UserException" 
    }, 
    "args": { 
     "$type": "Question35015357.SerializableValue`1[[System.String[], mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": [ 
     "bla" 
     ] 
    }, 
    "lineNumber": { 
     "$type": "Question35015357.SerializableValue`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": 0 
    }, 
    "linePosition": { 
     "$type": "Question35015357.SerializableValue`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": 0 
    }, 
    "sourceUri": { 
     "$type": "Question35015357.SerializableValue`1[[System.Object, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" 
    }, 
    "version": { 
     "$type": "Question35015357.SerializableValue`1[[System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], Tile, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null", 
     "value": "2.0" 
    } 
    } 
} 

जैसा कि आप देख सकते हैं, सुरक्षा खतरे जेएसओएन की पठनीयता से कुछ हद तक कम हो गई है। सुरक्षा खतरे को केवल अपेक्षित प्रकारों को लोड करने के लिए आप custom SerializationBinder भी बना सकते हैं।

मुझे यकीन नहीं है कि आंशिक विश्वास स्थितियों में क्या किया जाना चाहिए। JsonSerializerInternalReader.CreateISerializable() आंशिक विश्वास में फेंकता है:

private object CreateISerializable(JsonReader reader, JsonISerializableContract contract, JsonProperty member, string id) 
    { 
     Type objectType = contract.UnderlyingType; 

     if (!JsonTypeReflector.FullyTrusted) 
     { 
      string message = @"Type '{0}' implements ISerializable but cannot be deserialized using the ISerializable interface because the current application is not fully trusted and ISerializable can expose secure data." + Environment.NewLine + 
          @"To fix this error either change the environment to be fully trusted, change the application to not deserialize the type, add JsonObjectAttribute to the type or change the JsonSerializer setting ContractResolver to use a new DefaultContractResolver with IgnoreSerializableInterface set to true." + Environment.NewLine; 
      message = message.FormatWith(CultureInfo.InvariantCulture, objectType); 

      throw JsonSerializationException.Create(reader, message); 
     } 

तो शायद कनवर्टर के रूप में अच्छी तरह से करना चाहिए।