有没有办法在 JSON 文件的值中获取键名

Question

I want to populate a property based on the name of the name of the key. Eg The AddressType for the physicalAddress would be physicalAddress. Currently Im using Newtonsoft.Json. This information will be stored in a database using EntityFramework.

Thanks

This is an example part of the JSON file:

"person": [
  {
    "physicalAddress": [
      {
        "address": "123 Street Name",
        "postCode": 1122
      }
    ],
    "postalAddress": [
      {
        "address": "123 Street Name",
        "postCode": 1122
      }
    ],
    "registeredAddress": [
      {
        "address": "123 Street Name",
        "postCode": 1122
      }
    ]
  }

This is an example part of the class:

    [JsonProperty("address")]
    public string Address { get; set; }

    [JsonProperty("postCode")]
    public string PostCode { get; set; }

    public string AddressType { get; set; }

Answer 1

Assuming you don't want or can't change the client side, one possible approach is to create a request model that matches the format of the request body, ie

  [JsonProperty("physicalAddress")]
  public List<AddressRequestModel> PhysicalAddress { get; set; }

  [JsonProperty("postalAddress")]
  public List<AddressRequestModel> PostalAddress{ get; set; }

  [JsonProperty("registeredAddress")]
  public List<AddressRequestModel> RegisteredAddress{ get; set; }

Where AddressRequestModel would be the class containing the properties Address and PostCode . Then when the request is received, map the request model to the model needed by your application. In the mapper you can assign the appropriate address type, ie

public class AddressMapper
{
   public List<AddressRequestModel> Map(RequestModel model)
   {
      var addresses = new List<AddressRequestModel>();
      model.PhysicalAddress.ForEach(address => addresses.Add(Map(address, "physicalAddress"));
      model.PostalAddress.ForEach(address => addresses.Add(Map(address, "postalAddress"));
      model.RegisteredAddress.ForEach(address => addresses.Add(Map(address, "registeredAddress"));
      return addresses;
   }

   private AddressRequestModel Map(AddressRequestModel model, string addressType) =>
   new AddressRequestModel
   {
       Address = model.Address,
       PostCode = model.PostCode,
       AddressType = addressType,
   }
}

Answer 2

I create a bit complex case to parse this json by JsonConverter. And it works for your requirements.

The major function uses JProperty to dynamic get the address key name (physicalAddress, postalAddress, or other) and Children() to get sub nodes.

class Program
{

    static void Main(string[] args)
    {
         string json = @"
{""person"": [
  {
    ""physicalAddress"": [
      {
        ""address"": ""123 Street Name"",
        ""postCode"": 1122
      },
      {
        ""address"": ""456 Street Name"",
        ""postCode"": 7788
      }
    ],
    ""postalAddress"": [
      {
        ""address"": ""123 Street Name"",
        ""postCode"": 1122
      },
      {
        ""address"": ""9999 Street Name"",
        ""postCode"": 77886666
      }
    ],
    ""registeredAddress"": [
      {
        ""address"": ""123 Street Name"",
        ""postCode"": 1122
      },
      {
        ""address"": ""fwerg Street Name"",
        ""postCode"": 9999999
      }

    ]
  }
  
  ]
}
";

         Person person = JsonConvert.DeserializeObject<Person>(json, new MyTypeConverter());
     }
}

public class Person
{
    public List<AddressDetail> Addresses { get; set; }
}

public class AddressDetail
{
    public string Address { get; set; }

    public string PostCode { get; set; }

    public string AddressType { get; set; }
}

public class MyTypeConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(Person).GetTypeInfo().IsAssignableFrom(objectType.GetTypeInfo());
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        if (reader.TokenType == JsonToken.StartObject)
        {
            JObject item = JObject.Load(reader);
            if (item["person"] != null)
            {
                var pseron = new Person()
                {
                    Addresses = new List<AddressDetail>()
                };
                var largeAddressArr = item["person"].Children();
                foreach (var largeAddress in largeAddressArr)
                {
                    foreach (var keyAddress in largeAddress.Children())
                    {
                        string keyName = (keyAddress as JProperty).Name;
                        List<JToken> tokens = keyAddress.Children().ToList();
                        foreach (var address in tokens)
                        {
                            var addresses = address.ToObject<List<AddressDetail>>();
                            addresses.ForEach(x => x.AddressType = keyName);
                            pseron.Addresses.AddRange(addresses);
                        }
                    }
                }

                return pseron;
            }
        }
        return null;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}