.NET NewtonSoft JSON десеріалізує карту до іншого імені властивості


294

У мене є наступний рядок JSON, який отримано від зовнішньої сторони.

{
   "team":[
      {
         "v1":"",
         "attributes":{
            "eighty_min_score":"",
            "home_or_away":"home",
            "score":"22",
            "team_id":"500"
         }
      },
      {
         "v1":"",
         "attributes":{
            "eighty_min_score":"",
            "home_or_away":"away",
            "score":"30",
            "team_id":"600"
         }
      }
   ]
}

Мої класи картографування:

public class Attributes
{
    public string eighty_min_score { get; set; }
    public string home_or_away { get; set; }
    public string score { get; set; }
    public string team_id { get; set; }
}

public class Team
{
    public string v1 { get; set; }
    public Attributes attributes { get; set; }
}

public class RootObject
{
    public List<Team> team { get; set; }
}

Питання в тому, що мені не подобається Attributes назва класу та attributes назви полів у Teamкласі. Натомість я хочу, щоб це було названо, TeamScoreа також видалити _з полів імена та дати власні імена.

JsonConvert.DeserializeObject<RootObject>(jsonText);

Я можу перейменувати Attributesв TeamScore, але якщо змінити ім'я поля ( attributesв Teamкласі), він не буде десеріалізациі правильно і дає мені null. Як я можу це подолати?


Відповіді:


572

Json.NET має атрибут , JsonPropertyAttributeщо дозволяє вказувати ім'я властивості JSON, тому ваш код повинен бути:

public class TeamScore
{
    [JsonProperty("eighty_min_score")]
    public string EightyMinScore { get; set; }
    [JsonProperty("home_or_away")]
    public string HomeOrAway { get; set; }
    [JsonProperty("score ")]
    public string Score { get; set; }
    [JsonProperty("team_id")]
    public string TeamId { get; set; }
}

public class Team
{
    public string v1 { get; set; }
    [JsonProperty("attributes")]
    public TeamScore TeamScores { get; set; }
}

public class RootObject
{
    public List<Team> Team { get; set; }
}

Документація: атрибути серіалізації


2
Чи можу я використовувати два JsonProperty для однієї поданої?
Алі Юсефі

1
@AliYousefie Не думай так. Але гарне питання буде, що ви очікуєте від цього отримати?
outcoldman

5
у мене є інтерфейс, цей клас використовується двома класами, але дані сервера мають два імені властивості для двох класів, я хочу використовувати два JsonProperty для одного властивості в моїх інтерфейсах.
Алі Юсефі

як ми можемо переконатися, що відповідь [десерилізований об’єкт] має значення для EightyMinScore, а не вісімдесят_min_score
Gaurravs

У моєму випадку я надсилаю RootObject як остаточну відповідь, але коли я читаю його як json з остаточної відповіді, вісімдесят_мінькорів показується зі значенням, а не з EightyMinScore
Gaurravs

115

Якщо ви хочете використовувати динамічне відображення і не хочете захаращувати свою модель атрибутами, цей підхід працював для мене

Використання:

var settings = new JsonSerializerSettings();
settings.DateFormatString = "YYYY-MM-DD";
settings.ContractResolver = new CustomContractResolver();
this.DataContext = JsonConvert.DeserializeObject<CountResponse>(jsonString, settings);

Логіка:

public class CustomContractResolver : DefaultContractResolver
{
    private Dictionary<string, string> PropertyMappings { get; set; }

    public CustomContractResolver()
    {
        this.PropertyMappings = new Dictionary<string, string> 
        {
            {"Meta", "meta"},
            {"LastUpdated", "last_updated"},
            {"Disclaimer", "disclaimer"},
            {"License", "license"},
            {"CountResults", "results"},
            {"Term", "term"},
            {"Count", "count"},
        };
    }

    protected override string ResolvePropertyName(string propertyName)
    {
        string resolvedName = null;
        var resolved = this.PropertyMappings.TryGetValue(propertyName, out resolvedName);
        return (resolved) ? resolvedName : base.ResolvePropertyName(propertyName);
    }
}

1
Я трохи спростив це для моєї мети, але це краще рішення, тоді «захаращуйте вашу модель / домен»;)
Андреас

4
Ого. Це епос; набагато більш архітектурно обґрунтована манера робити це.
Девід Бетц

1
Можливо (якщо ви створите більше одного з них) варто перенести словник, знайти код до базового класу для всіх відображень властивостей і дозволити їм додавати властивості, але ігнорувати деталі того, як відбувається відображення. Можливо, варто лише додати це до самої Json.Net.
Джеймс Вайт

Це має бути прийнятною відповіддю, оскільки, як сказав @DavidBetz, це найкращий дизайн.
im1dermike

Чи працює це рішення і з вкладеними властивостями? Я спробував десаріалізувати об’єкт з вкладеними властивостями, і він не працює.
Аві К.

8

Додавання до розчину Джека. Мені потрібно десеріалізувати за допомогою JsonProperty та Serialize, ігноруючи JsonProperty (або навпаки). ReflectionHelper та Attribute Helper - це лише допоміжні класи, які отримують список властивостей або атрибутів властивості. Я можу включити, якщо когось насправді байдуже. Використовуючи нижченаведений приклад, ви можете серіалізувати модуль перегляду та отримати "Суму", навіть якщо JsonProperty є "RecurringPrice".

    /// <summary>
    /// Ignore the Json Property attribute. This is usefule when you want to serialize or deserialize differently and not 
    /// let the JsonProperty control everything.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class IgnoreJsonPropertyResolver<T> : DefaultContractResolver
    {
        private Dictionary<string, string> PropertyMappings { get; set; }

        public IgnoreJsonPropertyResolver()
        {
            this.PropertyMappings = new Dictionary<string, string>();
            var properties = ReflectionHelper<T>.GetGetProperties(false)();
            foreach (var propertyInfo in properties)
            {
                var jsonProperty = AttributeHelper.GetAttribute<JsonPropertyAttribute>(propertyInfo);
                if (jsonProperty != null)
                {
                    PropertyMappings.Add(jsonProperty.PropertyName, propertyInfo.Name);
                }
            }
        }

        protected override string ResolvePropertyName(string propertyName)
        {
            string resolvedName = null;
            var resolved = this.PropertyMappings.TryGetValue(propertyName, out resolvedName);
            return (resolved) ? resolvedName : base.ResolvePropertyName(propertyName);
        }
    }

Використання:

        var settings = new JsonSerializerSettings();
        settings.DateFormatString = "YYYY-MM-DD";
        settings.ContractResolver = new IgnoreJsonPropertyResolver<PlanViewModel>();
        var model = new PlanViewModel() {Amount = 100};
        var strModel = JsonConvert.SerializeObject(model,settings);

Модель:

public class PlanViewModel
{

    /// <summary>
    ///     The customer is charged an amount over an interval for the subscription.
    /// </summary>
    [JsonProperty(PropertyName = "RecurringPrice")]
    public double Amount { get; set; }

    /// <summary>
    ///     Indicates the number of intervals between each billing. If interval=2, the customer would be billed every two
    ///     months or years depending on the value for interval_unit.
    /// </summary>
    public int Interval { get; set; } = 1;

    /// <summary>
    ///     Number of free trial days that can be granted when a customer is subscribed to this plan.
    /// </summary>
    public int TrialPeriod { get; set; } = 30;

    /// <summary>
    /// This indicates a one-time fee charged upfront while creating a subscription for this plan.
    /// </summary>
    [JsonProperty(PropertyName = "SetupFee")]
    public double SetupAmount { get; set; } = 0;


    /// <summary>
    /// String representing the type id, usually a lookup value, for the record.
    /// </summary>
    [JsonProperty(PropertyName = "TypeId")]
    public string Type { get; set; }

    /// <summary>
    /// Billing Frequency
    /// </summary>
    [JsonProperty(PropertyName = "BillingFrequency")]
    public string Period { get; set; }


    /// <summary>
    /// String representing the type id, usually a lookup value, for the record.
    /// </summary>
    [JsonProperty(PropertyName = "PlanUseType")]
    public string Purpose { get; set; }
}

2
Дякуємо за ваш IgnoreJsonPropertyResolver, оскільки я хотів зробити те саме (ігноруйте JsonProperty лише для серіалізації). На жаль, ваше рішення працює лише для атрибутів верхнього рівня, а не вкладених типів. Правильний спосіб ігнорувати всі атрибути JsonProperty при серіалізації - це перекриття CreatePropertyContractResolver. Там зателефонуйте на базу: var jsonProperty = base.CreateProperty(memberInfo, memberSerialization);і тоді встановіть jsonProperty.PropertyName = memberInfo.Name;. Нарешті, return jsonProperty;це все, що вам потрібно.
Нейт Кук

1
що це за помічники?
мертвийManN

1
@NateCook ви можете мені показати зразок? мені це зараз погано потрібно
deadManN

4

Розширюючи відповідь Rentering.com , у сценаріях, коли слід подбати про цілий графік багатьох типів, і ви шукаєте сильно набране рішення, цей клас може допомогти, див. Використання (вільно) нижче. Він працює як чорний або білий список за типом. Тип не може бути обом ( Gist - також містить глобальний список ігнору).

public class PropertyFilterResolver : DefaultContractResolver
{
  const string _Err = "A type can be either in the include list or the ignore list.";
  Dictionary<Type, IEnumerable<string>> _IgnorePropertiesMap = new Dictionary<Type, IEnumerable<string>>();
  Dictionary<Type, IEnumerable<string>> _IncludePropertiesMap = new Dictionary<Type, IEnumerable<string>>();
  public PropertyFilterResolver SetIgnoredProperties<T>(params Expression<Func<T, object>>[] propertyAccessors)
  {
    if (propertyAccessors == null) return this;

    if (_IncludePropertiesMap.ContainsKey(typeof(T))) throw new ArgumentException(_Err);

    var properties = propertyAccessors.Select(GetPropertyName);
    _IgnorePropertiesMap[typeof(T)] = properties.ToArray();
    return this;
  }

  public PropertyFilterResolver SetIncludedProperties<T>(params Expression<Func<T, object>>[] propertyAccessors)
  {
    if (propertyAccessors == null)
      return this;

    if (_IgnorePropertiesMap.ContainsKey(typeof(T))) throw new ArgumentException(_Err);

    var properties = propertyAccessors.Select(GetPropertyName);
    _IncludePropertiesMap[typeof(T)] = properties.ToArray();
    return this;
  }

  protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
  {
    var properties = base.CreateProperties(type, memberSerialization);

    var isIgnoreList = _IgnorePropertiesMap.TryGetValue(type, out IEnumerable<string> map);
    if (!isIgnoreList && !_IncludePropertiesMap.TryGetValue(type, out map))
      return properties;

    Func<JsonProperty, bool> predicate = jp => map.Contains(jp.PropertyName) == !isIgnoreList;
    return properties.Where(predicate).ToArray();
  }

  string GetPropertyName<TSource, TProperty>(
  Expression<Func<TSource, TProperty>> propertyLambda)
  {
    if (!(propertyLambda.Body is MemberExpression member))
      throw new ArgumentException($"Expression '{propertyLambda}' refers to a method, not a property.");

    if (!(member.Member is PropertyInfo propInfo))
      throw new ArgumentException($"Expression '{propertyLambda}' refers to a field, not a property.");

    var type = typeof(TSource);
    if (!type.GetTypeInfo().IsAssignableFrom(propInfo.DeclaringType.GetTypeInfo()))
      throw new ArgumentException($"Expresion '{propertyLambda}' refers to a property that is not from type '{type}'.");

    return propInfo.Name;
  }
}

Використання:

var resolver = new PropertyFilterResolver()
  .SetIncludedProperties<User>(
    u => u.Id, 
    u => u.UnitId)
  .SetIgnoredProperties<Person>(
    r => r.Responders)
  .SetIncludedProperties<Blog>(
    b => b.Id)
  .Ignore(nameof(IChangeTracking.IsChanged)); //see gist

0

Я використовую атрибути JsonProperty при серіалізації, але ігноруючи їх, коли десеріалізувати, використовуючи це ContractResolver:

public class IgnoreJsonPropertyContractResolver: DefaultContractResolver
    {
        protected override IList<JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
        {
            var properties = base.CreateProperties(type, memberSerialization);
            foreach (var p in properties) { p.PropertyName = p.UnderlyingName; }
            return properties;
        }
    }

ContractResolverПросто встановлює все майно назад до імені класу власності (спрощеним з розчину шіммі в). Використання:

var airplane= JsonConvert.DeserializeObject<Airplane>(json, 
    new JsonSerializerSettings { ContractResolver = new IgnoreJsonPropertyContractResolver() });
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.