JSON-Array von Objekten, um Modell in WebAPI mit FromBody

In Situationen, In denen der Deserialisierung wird auf mysteriöse Weise versagt, ich finde es hilfreich zu serialisieren ein test-Objekt, und vergleichen Sie das tatsächliche output mit dem gewünschten Eingang. Wenn die Ausgabe unterscheidet sich von der gewünschten input -, das ist wahrscheinlich die Ursache für den Fehler. In deinem Fall, wenn ich Deserialisieren des XML-und re-serialisieren zu JSON habe ich bekommen:

{
  "Products": [
    {
      "ProductName": "Seahorse Necklace"
    },
    {
      "ProductName": "Ping Pong Necklace"
    }
  ]
}

Wie Sie sehen können, gibt es zwei zusätzliche Ebenen der Dereferenzierung in Ihrer JSON im Vergleich zu den reserialized XML: es gibt ein Wurzel-Objekt-Namen, die nicht vorhanden sein sollten im JSON-Format, und es gibt Sammlung element-Typ-Namen, die auch nicht vorhanden sein sollte. (Diese beiden sind jedoch Allgemeine Funktionen in XML.)

Ist es möglich, ändern Sie Ihre JSON, so dass Sie nicht haben, diese extra-Level, wenn Dereferenzierung? (E. g. war dieses JSON konvertiert aus XML per Skript zu Testzwecken, und somit nicht der tatsächlichen Anforderungen?) Wenn dem so ist, dann ist dein problem ist gelöst.

Wenn nicht, dann sind hier einige Optionen, die für das Deserialisieren es:

1. Lesen & schreiben Sie ein root-name-Objekt mit dem Sie JSON, finden Sie die Lösungen hier oder hier

   Oder, Rollen Sie Ihre eigenen proxy-wrapper:

   public sealed class ProductAddWrapper
   {
       public ProductAddWrapper()
       {
       }
   
       public ProductAddWrapper(ProductAdd product)
       {
           this.ProductAdd = product;
       }
   
       public ProductAdd ProductAdd { get; set; }
   
       public static implicit operator ProductAdd(ProductAddWrapper wrapper) { return wrapper.ProductAdd; }
   
       public static implicit operator ProductAddWrapper(ProductAdd product) { return new ProductAddWrapper(product); }
   }

2. Injektion die zusätzliche Dereferenzierungsebene in Ihren Listen ist ein bisschen schwieriger. Was Sie tun müssen, ist die Umstrukturierung der JSON-on-the-fly, wie Sie Lesen und schreiben, hinzufügen oder entfernen von zusätzlichen künstlichen Ebene der Verschachtelung. Diese kann getan werden, mit einem JsonConverter:

   class CollectionWithNamedElementsConverter : JsonConverter
   {
       static Type GetEnumerableType(Type type)
       {
           foreach (Type intType in type.GetInterfaces())
           {
               if (intType.IsGenericType
                   && intType.GetGenericTypeDefinition() == typeof(IEnumerable<>))
               {
                   return intType.GetGenericArguments()[0];
               }
           }
           return null;
       }
   
       public override bool CanConvert(Type objectType)
       {
           return typeof(IEnumerable).IsAssignableFrom(objectType)
               && !typeof(string).IsAssignableFrom(objectType)
               && GetEnumerableType(objectType) != null;
       }
   
       public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
       {
           JArray originalArray = JArray.Load(reader);
           if (originalArray == null)
               return null;
           JArray array = new JArray();
           foreach (var item in originalArray)
           {
               var child = item.Children<JProperty>().FirstOrDefault();
               if (child != null)
               {
                   var value = child.Value;
                   array.Add(child.Value);
               }
           }
           return serializer.Deserialize(new StringReader(array.ToString()), objectType);
       }
   
       public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
       {
           var objectType = value.GetType();
           var itemType = GetEnumerableType(objectType);
   
           IEnumerable collection = value as IEnumerable;
   
           writer.WriteStartArray();
   
           foreach (object item in collection)
           {
               writer.WriteStartObject();
               writer.WritePropertyName(itemType.Name);
               serializer.Serialize(writer, item);
               writer.WriteEndObject();
           }
   
           writer.WriteEndArray();
       }
   }

Dann verwenden Sie es durch die Anwendung einer [JsonConverter(typeof(CollectionWithNamedElementsConverter))] Attribut Sammlungen mit Elementtyp-Namen:

    public class ProductAdd
    {
        [JsonConverter(typeof(CollectionWithNamedElementsConverter))]
        public List<ProductInformation> Products { get; set; }
    }