web-dev-qa-db-ja.com

Newtonsoft JSON動的プロパティ名

シリアル化中にDataプロパティの名前を変更する方法はあるので、このクラスをWEB Apiで再利用できます。

たとえば、ユーザーのページリストを返す場合、Dataプロパティは「users」としてシリアル化する必要があり、アイテムのリストを返す場合は「items」などと呼ばれる必要があります。

このようなものは可能ですか：

public class PagedData
{
    [JsonProperty(PropertyName = "Set from constructor")]??
    public IEnumerable<T> Data { get; private set; }
    public int Count { get; private set; }
    public int CurrentPage { get; private set; }
    public int Offset { get; private set; }
    public int RowsPerPage { get; private set; }
    public int? PreviousPage { get; private set; }
    public int? NextPage { get; private set; }
}

編集：

できれば使用する名前を渡すなど、この機能を制御したいと思います。 classがUserDTOと呼ばれる場合でも、シリアル化されたプロパティはUsersではなくUserDTOsと呼ばれます。

例

var usersPagedData = new PagedData("Users", params...);
c#jsonjson.netasp.net-web-api2
18
Robert

これは、カスタムContractResolverを使用して実行できます。リゾルバーは、JSONプロパティの名前が列挙可能なアイテムのクラスに基づいていることを通知するカスタム属性を検索できます。アイテムクラスに複数の名前を指定する別の属性がある場合、その名前が列挙可能なプロパティに使用されます。そうでない場合、アイテムクラス名自体が複数になり、列挙可能なプロパティ名として使用されます。以下が必要なコードです。

まず、いくつかのカスタム属性を定義しましょう。

public class JsonPropertyNameBasedOnItemClassAttribute : Attribute
{
}

public class JsonPluralNameAttribute : Attribute
{
    public string PluralName { get; set; }
    public JsonPluralNameAttribute(string pluralName)
    {
        PluralName = pluralName;
    }
}

そして、リゾルバー：

public class CustomResolver : DefaultContractResolver
{
    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty prop = base.CreateProperty(member, memberSerialization);
        if (prop.PropertyType.IsGenericType && member.GetCustomAttribute<JsonPropertyNameBasedOnItemClassAttribute>() != null)
        {
            Type itemType = prop.PropertyType.GetGenericArguments().First();
            JsonPluralNameAttribute att = itemType.GetCustomAttribute<JsonPluralNameAttribute>();
            prop.PropertyName = att != null ? att.PluralName : Pluralize(itemType.Name);
        }
        return prop;
    }

    protected string Pluralize(string name)
    {
        if (name.EndsWith("y") && !name.EndsWith("ay") && !name.EndsWith("ey") && !name.EndsWith("oy") && !name.EndsWith("uy"))
            return name.Substring(0, name.Length - 1) + "ies";

        if (name.EndsWith("s"))
            return name + "es";

        return name + "s";
    }
}

これで、PagedData<T>属性を使用して、[JsonPropertyNameBasedOnItemClass]クラスの可変名のプロパティを修飾できます。

public class PagedData<T>
{
    [JsonPropertyNameBasedOnItemClass]
    public IEnumerable<T> Data { get; private set; }
    ...
}

そして、[JsonPluralName]属性でDTOクラスを飾ります：

[JsonPluralName("Users")]
public class UserDTO
{
    ...
}

[JsonPluralName("Items")]
public class ItemDTO
{
    ...
}

最後に、シリアル化するには、JsonSerializerSettingsのインスタンスを作成し、ContractResolverプロパティを設定し、次のようにJsonConvert.SerializeObjectに設定を渡します。

JsonSerializerSettings settings = new JsonSerializerSettings
{
    ContractResolver = new CustomResolver()
};

string json = JsonConvert.SerializeObject(pagedData, settings);

フィドル： https://dotnetfiddle.net/GqKBnx

Web APIを使用している場合（見た目は似ています）、RegisterクラスのWebApiConfigメソッド（App_Start内）を介して、カスタムリゾルバーをパイプラインにインストールできます。フォルダ）。

JsonSerializerSettings settings = config.Formatters.JsonFormatter.SerializerSettings;
settings.ContractResolver = new CustomResolver();

別のアプローチ

別の可能なアプローチでは、カスタムJsonConverterを使用して、上記のより一般的な「リゾルバー+属性」アプローチを使用する代わりに、PagedDataクラスのシリアル化を処理します。コンバーターアプローチでは、列挙可能なPagedDataプロパティに使用するJSON名を指定するDataクラスに別のプロパティが必要です。この名前をPagedDataコンストラクターに渡すか、シリアル化の前に行う限り、個別に設定できます。コンバーターはその名前を検索し、列挙可能なプロパティのJSONを書き込むときにそれを使用します。

コンバーターのコードは次のとおりです。

public class PagedDataConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(PagedData<>);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        Type type = value.GetType();

        var bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public;
        string dataPropertyName = (string)type.GetProperty("DataPropertyName", bindingFlags).GetValue(value);
        if (string.IsNullOrEmpty(dataPropertyName)) 
        {
            dataPropertyName = "Data";
        }

        JObject jo = new JObject();
        jo.Add(dataPropertyName, JArray.FromObject(type.GetProperty("Data").GetValue(value)));
        foreach (PropertyInfo prop in type.GetProperties().Where(p => !p.Name.StartsWith("Data")))
        {
            jo.Add(prop.Name, new JValue(prop.GetValue(value)));
        }
        jo.WriteTo(writer);
    }

    public override bool CanRead
    {
        get { return false; }
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

このコンバータを使用するには、最初にDataPropertyNameという文字列プロパティをPagedDataクラスに追加し（必要に応じてプライベートにすることもできます）、次に[JsonConverter]属性をクラスに追加して結び付けますそれをコンバータに：

[JsonConverter(typeof(PagedDataConverter))]
public class PagedData<T>
{
    private string DataPropertyName { get; set; }
    public IEnumerable<T> Data { get; private set; }
    ...
}

以上です。 DataPropertyNameプロパティを設定している限り、シリアル化時にコンバーターによって取得されます。

フィドル： https://dotnetfiddle.net/8E8fEE

18
Brian Rogers

Jsonフォーマッタを使用したり、文字列の置換を使用したりする必要のない別のオプション-継承とオーバーライドのみ（まだナイスなソリューションではありません、imo）：

public class MyUser { }
public class MyItem { }

// you cannot use it out of the box, because it's abstract,
// i.e. only for what's intended [=implemented].
public abstract class PaginatedData<T>
{
    // abstract, so you don't forget to override it in ancestors
    public abstract IEnumerable<T> Data { get; }
    public int Count { get; }
    public int CurrentPage { get; }
    public int Offset { get; }
    public int RowsPerPage { get; }
    public int? PreviousPage { get; }
    public int? NextPage { get; }
}

// you specify class explicitly
// name is clear,.. still not clearer than PaginatedData<MyUser> though
public sealed class PaginatedUsers : PaginatedData<MyUser>
{
    // explicit mapping - more agile than implicit name convension
    [JsonProperty("Users")]
    public override IEnumerable<MyUser> Data { get; }
}

public sealed class PaginatedItems : PaginatedData<MyItem>
{
    [JsonProperty("Items")]
    public override IEnumerable<MyItem> Data { get; }
}
6
pkuderov

Jsonシリアライザーの使用方法を変更する必要のないソリューションを次に示します。実際、他のシリアライザーでも動作するはずです。クールな DynamicObject クラスを使用します。

使い方はあなたが望んでいた通りです：

var usersPagedData = new PagedData<User>("Users");
....

public class PagedData<T> : DynamicObject
{
    private string _name;

    public PagedData(string name)
    {
        if (name == null)
            throw new ArgumentNullException(nameof(name));

        _name = name;
    }

    public IEnumerable<T> Data { get; private set; }
    public int Count { get; private set; }
    public int CurrentPage { get; private set; }
    public int Offset { get; private set; }
    public int RowsPerPage { get; private set; }
    public int? PreviousPage { get; private set; }
    public int? NextPage { get; private set; }

    public override IEnumerable<string> GetDynamicMemberNames()
    {
        yield return _name;
        foreach (var prop in GetType().GetProperties().Where(p => p.CanRead && p.GetIndexParameters().Length == 0 && p.Name != nameof(Data)))
        {
            yield return prop.Name;
        }
    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
        if (binder.Name == _name)
        {
            result = Data;
            return true;
        }

        return base.TryGetMember(binder, out result);
    }
}
2
Simon Mourier

以下は、.NET Standard 2でテストされた別のソリューションです。

public class PagedResult<T> where T : class
{

    [JsonPropertyNameBasedOnItemClassAttribute]
    public List<T> Results { get; set; }

    [JsonProperty("count")]
    public long Count { get; set; }

    [JsonProperty("total_count")]
    public long TotalCount { get; set; }

    [JsonProperty("current_page")]
    public long CurrentPage { get; set; }

    [JsonProperty("per_page")]
    public long PerPage { get; set; }

    [JsonProperty("pages")]
    public long Pages { get; set; }
}

Humanizerを複数形化に使用しています。

    protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
    {
        JsonProperty property = base.CreateProperty(member, memberSerialization);
        if (member.GetCustomAttribute<JsonPropertyNameBasedOnItemClassAttribute>() != null)
        {
            Type[] arguments = property.DeclaringType.GenericTypeArguments;
            if(arguments.Length > 0)
            {
                string name = arguments[0].Name.ToString();
                property.PropertyName = name.ToLower().Pluralize();
            }
            return property;
        }
        return base.CreateProperty(member, memberSerialization);
    }
0
gv1507

こちらをご覧ください： JSONキーの名前を変更する方法

シリアル化中には行われませんが、文字列操作が行われます。

（私の目には）あまり素敵ではありませんが、少なくとも可能性はあります。

乾杯トーマス

0
Thomas Voß