JSON.NET - как десериализовать сборку интерфейсных экземпляров?

Question

я хотел бы сериализации этот код через Json.NET:

public interface ITestInterface 
{ 
    string Guid {get;set;} 
} 

public class TestClassThatImplementsTestInterface1 
{ 
    public string Guid { get;set; } 
} 

public class TestClassThatImplementsTestInterface2 
{ 
    public string Guid { get;set; } 
} 


public class ClassToSerializeViaJson 
{ 
    public ClassToSerializeViaJson() 
    {    
     this.CollectionToSerialize = new List<ITestInterface>(); 
     this.CollectionToSerialize.add(new TestClassThatImplementsTestInterface2()); 
     this.CollectionToSerialize.add(new TestClassThatImplementsTestInterface2()); 
    } 
    List<ITestInterface> CollectionToSerialize { get;set; } 
} 

Я хочу сериализации/десериализации ClassToSerializeViaJson с Json.NET. Сериализация работает, но десериализация дает мне эту ошибку:

Newtonsoft.Json.JsonSerializationException: Не удалось создать экземпляр типа ITestInterface. Тип - это интерфейс или абстрактный класс и не может быть создан.

Итак, как я могу десериализовать коллекцию List?

Thanks

Answer 1

Пыльника полного рабочего примера с тем, что вы хотите сделать:

public interface ITestInterface 
{ 
    string Guid { get; set; } 
} 

public class TestClassThatImplementsTestInterface1 : ITestInterface 
{ 
    public string Guid { get; set; } 
    public string Something1 { get; set; } 
} 

public class TestClassThatImplementsTestInterface2 : ITestInterface 
{ 
    public string Guid { get; set; } 
    public string Something2 { get; set; } 
} 

public class ClassToSerializeViaJson 
{ 
    public ClassToSerializeViaJson() 
    { 
     this.CollectionToSerialize = new List<ITestInterface>(); 
    } 
    public List<ITestInterface> CollectionToSerialize { get; set; } 
} 

public class TypeNameSerializationBinder : SerializationBinder 
{ 
    public string TypeFormat { get; private set; } 

    public TypeNameSerializationBinder(string typeFormat) 
    { 
     TypeFormat = typeFormat; 
    } 

    public override void BindToName(Type serializedType, out string assemblyName, out string typeName) 
    { 
     assemblyName = null; 
     typeName = serializedType.Name; 
    } 

    public override Type BindToType(string assemblyName, string typeName) 
    { 
     var resolvedTypeName = string.Format(TypeFormat, typeName); 
     return Type.GetType(resolvedTypeName, true); 
    } 
} 

class Program 
{ 
    static void Main() 
    { 
     var binder = new TypeNameSerializationBinder("ConsoleApplication.{0}, ConsoleApplication"); 
     var toserialize = new ClassToSerializeViaJson(); 

     toserialize.CollectionToSerialize.Add(
      new TestClassThatImplementsTestInterface1() 
      { 
       Guid = Guid.NewGuid().ToString(), Something1 = "Some1" 
      }); 
     toserialize.CollectionToSerialize.Add(
      new TestClassThatImplementsTestInterface2() 
      { 
       Guid = Guid.NewGuid().ToString(), Something2 = "Some2" 
      }); 

     string json = JsonConvert.SerializeObject(toserialize, Formatting.Indented, 
      new JsonSerializerSettings 
      { 
       TypeNameHandling = TypeNameHandling.Auto, 
       Binder = binder 
      }); 
     var obj = JsonConvert.DeserializeObject<ClassToSerializeViaJson>(json, 
      new JsonSerializerSettings 
      { 
       TypeNameHandling = TypeNameHandling.Auto, 
       Binder = binder 
      }); 

     Console.ReadLine(); 
    } 
} 

Answer 2

Используя настройки по умолчанию, вы не можете. JSON.NET не знает, как десериализовать массив. Однако вы можете указать, какой тип конвертера использовать для вашего типа интерфейса. Чтобы узнать, как это сделать, см этой страницы: http://blog.greatrexpectations.com/2012/08/30/deserializing-interface-properties-using-json-net/

Вы также можете найти информацию об этой проблеме на этом С.О. вопроса: Casting interfaces for deserialization in JSON.NET

Answer 3

Я нашел этот вопрос, пытаясь сделать это сам. После того, как я реализовал Garath's answer, я был поражен тем, насколько просто он казался. Если бы я просто выполнял метод, который уже передавался, точный тип (как строка), который я хотел создать, почему библиотека не привязывала его автоматически?

Я действительно обнаружил, что мне не нужны какие-либо пользовательские связующие, Json.Net смог сделать именно то, что мне было нужно, если бы я сказал, что это то, что я делаю.

При сериализации:

string serializedJson = JsonConvert.SerializeObject(objectToSerialize, Formatting.Indented, new JsonSerializerSettings 
{ 
    TypeNameHandling = TypeNameHandling.Objects, 
    TypeNameAssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple 
}); 

Когда десериализацией:

var deserializedObject = JsonConvert.DeserializeObject<ClassToSerializeViaJson>(serializedJson, new JsonSerializerSettings 
{ 
    TypeNameHandling = TypeNameHandling.Objects 
}); 

Соответствующая документация: Serialization Settings for Json.NET и TypeNameHandling setting

Answer 4

Я также был удивлен простотой в Garath, а также пришли к вывод о том, что библиотека Json может делать это автоматически. Но я также подумал, что это даже проще, чем ответ Бен Дженкинсона (хотя я вижу, что он был модифицирован разработчиком самой библиотеки json). Из моих тестирование, все, что вам нужно сделать, это установить TypeNameHandling Авто, как это:

var objectToSerialize = new List<IFoo>(); 
// TODO: Add objects to list 
var jsonString = JsonConvert.SerializeObject(objectToSerialize, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto }); 
var deserializedObject = JsonConvert.DeserializeObject<List<IFoo>>(jsonString, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto }); 

Answer 5

Near-дубликат ответа Inrego, но это заслуживает дальнейшего объяснения:

Если вы используете TypeNameHandling.Auto только тогда он включает имя типа/сборки, когда нуждается в (т.е. интерфейсах и базовых/производных классах). Итак, ваш JSON чище, меньше, более конкретный.

Что не является одним из основных пунктов его продажи над XML/SOAP?

Answer 6

Это старый вопрос, но думал, я бы добавить более глубокий ответ (в виде статьи, которую я написал): http://skrift.io/articles/archive/bulletproof-interface-deserialization-in-jsonnet/

TLDR: Вместо того, чтобы настроить Json.NET для встраивания типа в сериализованном JSON, вы можете использовать JSON-конвертер, чтобы выяснить, какой класс следует десериализовать для использования любой настраиваемой логики.

Это имеет то преимущество, что вы можете реорганизовать свои типы, не беспокоясь о разрыве десериализации.

Answer 7

Я хотел десериализовать JSON, который не был сериализован моим приложением, поэтому мне нужно было указать конкретную реализацию вручную. Я расширил ответ Николая.

Допустим, мы имеем

public class Person 
{ 
    public ILocation Location { get;set; } 
} 

и конкретный экземпляр

public class Location: ILocation 
{ 
    public string Address1 { get; set; } 
    // etc 
} 

Добавить в этом классе

public class ConfigConverter<I, T> : JsonConverter 
{ 
    public override bool CanWrite => false; 
    public override bool CanRead => true; 
    public override bool CanConvert(Type objectType) 
    { 
     return objectType == typeof(I); 
    } 
    public override void WriteJson(JsonWriter writer, 
     object value, JsonSerializer serializer) 
    { 
     throw new InvalidOperationException("Use default serialization."); 
    } 

    public override object ReadJson(JsonReader reader, 
     Type objectType, object existingValue, 
     JsonSerializer serializer) 
    { 
     var jsonObject = JObject.Load(reader); 
     var deserialized = (T)Activator.CreateInstance(typeof(T)); 
     serializer.Populate(jsonObject.CreateReader(), deserialized); 
     return deserialized; 
    } 
} 

Затем определите ваши интерфейсы с JsonConverter атрибут

public class Person 
{ 
    [JsonConverter(typeof(ConfigConverter<ILocation, Location>))] 
    public ILocation Location { get;set; } 
}