いいえ、この機能は現時点ではサポートされていませんが、vNextで検討する必要があります。 機能リクエストを動機付けるための使用例はありますか？

未来としてマークします。

System.NotSupportedException : The collection type 'System.Dynamic.ExpandoObject' is not supported.

@ahsonkhanGraphQLは良い例です。

仕様ではJSONを推奨していますが、応答の特定のシリアル化には関連付けられていません。
これは、応答の「データ」フィールドが動的であるということを意味します。 推測できないので。
ExpandoObjectがない場合、逆シリアル化により動的にJSON作成の一種になります。 したがって、その抽象的な動的「データ」へのアクセスは、実際には動的がJTokenであることを認識して行う必要があります。

ExpandoObjectを使用すると、一般的なオブジェクトのように動的な「データ」へのアクセスを強制できると思います。

@ahsonkhan別の例は、プロジェクトの構成サービスです。 これは、MongoDBでコレクションを作成するRESTエンドポイントのようなコレクションを公開します（これは単なるダミーのRESTラッパーではなく、RESTコレクションとmongoコレクションには正確な1-1マッピングがなく、特定のルールもアサートします）。

したがって、私たちのプロジェクトでは、動的/ ExpandoObjectのサポートが必要です。

他のマイクロサービスでも使用しています。

また、この制限に遭遇しました。 私たちのユースケースは、jsonシリアル化の前に動的オブジェクトを徐々に構築しています。 より成熟したJson.NETシリアライザーに戻りました。

やあみんな

今のところ散歩は何ですか？
どちらを使用するかを構成できますか？
@SidShetyeあなたは何かがより成熟したものに戻ったと言いました、あなたは説明してもらえますか？

@MickeyReznikov ： https ： //stackoverflow.com/questions/15455304/deserialize-a-property-as-an-expandoobject-using-json-netまたはgoogle「json.netexpandoobject」を参照してください

@MickeyReznikov 、あなたの質問は答えられましたか？ @SidShetyeは、Newtonsoft.Jsonを使用することを意味していると思います。 asp.netアプリの場合は、AddNewtonsoftJsonに戻すように構成できます。

https://docs.microsoft.com/en-us/aspnet/core/migration/22-to-30?view=aspnetcore-3.0&tabs=visual-studio#jsonnet-supportを参照して

これのユースケースもあります。HttpClientを使用してRESTAPIを呼び出し、応答から単一のプロパティを取得したいだけです。 応答を解析するためだけに専用のクラスを作成したくありません... JSON.NETを使用すると、「動的」を使用して、選択したプロパティにアクセスできます。

https://github.com/dotnet/corefx/issues/41472から@ ghost1372 ：

こんにちは私はこれがこの質問をするのに良い場所であることを願っています
動的オブジェクトを逆シリアル化できないようです
私はこのコードを使用しましたが、機能しませんでしたこれを行う方法はありますか？

var objList = System.Text.Json.JsonSerializer.Deserialize<List<dynamic>>(json);

多くのアプリケーションでは、ストアドプロシージャからのデータのフィールドを制御し、jquery.jtableを使用してリストページと検索リストページを動的にレンダリングしています。

ExpandoObjectのJsonSerializer組み込みサポートがないと、dotnetcore組み込みJsonシリアル化を使用できません。

@estillerと@SidShetyeがすでに述べたのと同じユースケースを共有しています
その間に、Json.NETに戻す必要がありました。

Futureよりも_now_に近いマイルストーンを持つことは可能ですか？ 🤔

ExpandoObjectは長い間BCLに含まれていました

ExpandoObjectの代替手段はありますか？

@fatihyildizhanいいえ、代替手段はありません。

ただし、独自のExpandoObjectコンバーターを作成したので、この記事からヒントを得ることができますASP.NET Core 3.0：新しいSystem.Text.JsonのカスタムJsonConverter

シリアル化のみが必要なので、シリアル化を作成するだけです

これがまだサポートされていないことに驚きました。

これを5.0に移動します。

5.0に移行しますか？ つまり、少なくとも1年は待たなければならないということですか？ JSON.Netに戻ります。

5.0？ うわー、それは間違いなくひどいです。

一時的な醜い回避策として、カスタムコンバーターを備えたJsonDocumentを使用できますが、IDisposableです。

public sealed class EventObject
    {
        [JsonPropertyName("id")]
        public long Id
        {
            get; set;
        }

        [JsonPropertyName("eventData")]
        [JsonConverter(typeof(JsonDocumentConverter))]
        public System.Text.Json.JsonDocument EventData
        {
            get; set;
        }
    }

    internal sealed class JsonDocumentConverter
        : JsonConverter<System.Text.Json.JsonDocument>
    {
        public override JsonDocument Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return JsonDocument.ParseValue(ref reader);
        }

        public override void Write(Utf8JsonWriter writer, JsonDocument value, JsonSerializerOptions options)
        {
            value.WriteTo(writer);
        }
    }

System.Text.Jsonが存在する場合、次のPOSTアクションを使用できなくなります。

[HttpPost]
public async Task<IActionResult> SubmitAsync(dynamic model)

代わりに、次の方法を使用する必要がありましたが、ダウンストリームのバックエンドコードで「model」を使用するのは簡単ではありませんでした。

[HttpPost]
public async Task<IActionResult> SubmitAsync(JsonElement model)

「モデル」は複雑なオブジェクトであり、オブジェクトのコレクションやその他のネストされた複雑なオブジェクトが含まれている場合があります。 JsonElementからdynamicオブジェクトを結論付けることができるようにするには、model.GetRawText（）を呼び出し、Newtonsoftにそれを動的オブジェクトにデコードさせる必要がありました。 この演習の主な目的はプロジェクトからNewtonsoft.jsonを廃止することであったため、この方法は望ましい方法ではありません。

このチケット/問題に対処することは、私たちが経験している問題の修正を意味すると思いますか？ 対処するのは少し緊急の問題のようですが、遅かれ早かれ対処できますか？

/ cc @ahsonkhan @terrajobst

.NET Core 3.0JsonSerializer。動的オブジェクトへの逆シリアル化

ExpandoObject（暫定措置）に対するJsonSerializerのサポート
私は初心者です、多くの場所は完璧ではありません、誰もが変更することを歓迎します
.netCore3はサポートされていません

JsonConverterを追加する

使用して追加：

• System.Text.Jsonを使用します。
• System.Text.Json.Serializationを使用します。

`` `C＃
///

        if (reader.TokenType == JsonTokenType.True)
        {
            return true;
        }

        if (reader.TokenType == JsonTokenType.False)
        {
            return false;
        }

        if (reader.TokenType == JsonTokenType.Number)
        {
            if (reader.TryGetInt64(out long l))
            {
                return l;
            }

            return reader.GetDouble();
        }

        if (reader.TokenType == JsonTokenType.String)
        {
            if (reader.TryGetDateTime(out DateTime datetime))
            {
                return datetime;
            }

            return reader.GetString();
        }

        if (reader.TokenType == JsonTokenType.StartObject)
        {
            using JsonDocument documentV = JsonDocument.ParseValue(ref reader);
            return ReadObject(documentV.RootElement);
        }
        // Use JsonElement as fallback.
        // Newtonsoft uses JArray or JObject.
        JsonDocument document = JsonDocument.ParseValue(ref reader);
        return document.RootElement.Clone();
    }

    private object ReadObject(JsonElement jsonElement)
    {
        IDictionary<string, object> expandoObject = new ExpandoObject();
        foreach (var obj in jsonElement.EnumerateObject())
        {
            var k = obj.Name;
            var value = ReadValue(obj.Value);
            expandoObject[k] = value;
        }
        return expandoObject;
    }
    private object? ReadValue(JsonElement jsonElement)
    {
        object? result = null;
        switch (jsonElement.ValueKind)
        {
            case JsonValueKind.Object:
                result = ReadObject(jsonElement);
                break;
            case JsonValueKind.Array:
                result = ReadList(jsonElement);
                break;
            case JsonValueKind.String:
                //TODO: Missing Datetime&Bytes Convert
                result = jsonElement.GetString();
                break;
            case JsonValueKind.Number:
                //TODO: more num type
                result = 0;
                if (jsonElement.TryGetInt64(out long l))
                {
                    result = l;
                }
                break;
            case JsonValueKind.True:
                result = true;
                break;
            case JsonValueKind.False:
                result = false;
                break;
            case JsonValueKind.Undefined:
            case JsonValueKind.Null:
                result = null;
                break;
            default:
                throw new ArgumentOutOfRangeException();
        }
        return result;
    }

    private object? ReadList(JsonElement jsonElement)
    {
        IList<object?> list = new List<object?>();
        foreach (var item in jsonElement.EnumerateArray())
        {
            list.Add(ReadValue(item));
        }
        return list.Count == 0 ? null : list;
    }
    public override void Write(Utf8JsonWriter writer,
        object value,
        JsonSerializerOptions options)
    {
       // writer.WriteStringValue(value.ToString());
    }
}

## How to Use?

```C#
var serializerOptions = new JsonSerializerOptions
{
    Converters = { new DynamicJsonConverter() }
};
return JsonSerializer.Deserialize<dynamic>("{OK:"200"}", serializerOptions);

@tchivs 、あなたの解決策は私のために働いた。 ただし、Convertersプロパティは読み取り専用であるため、次のような操作を行う必要がありました。
c# var serializerOptions = new JsonSerializerOptions(); serializerOptions.Converters.Add(new DynamicJsonConverter()); return JsonSerializer.Deserialize<dynamic>("{OK:"200"}", serializerOptions);

JsonElementタイプを使用してみてください。

public JsonElement MyProperty {get; set;}

@tchivs 、コードにいくつかの変更を加えましたなく、動的に生成された「射影」タイプ（基本タイプのプロパティのサブセットを持つ）を使用するようにコードを作り直しました。 コードを（サンプルコンソールプロジェクトで）ここに投稿しました： EDennis.DynamicDeserialization 。

このアプローチは、より複雑なオブジェクトを使用して、さまざまなシナリオでテストします（たとえば、既存の完全に型指定されたEFコアエンティティにパッチを適用するために使用される動的オブジェクトの逆シリアル化、テストケースのjsonオブジェクトと配列の逆シリアル化）。 これが役立つと思われる場合、または問題がある場合はお知らせください。

コミュニティの回避策をありがとう。 マイクロソフトがこの機能を適切な時間枠で提供できないのは驚くべきことです。 ある種の動的オブジェクトなしでGraphQL応答を操作すると、多くの冗長で醜いコードになります。 または、深くネストされたプロパティの存在を確認するだけでもかまいません。

コメントのスレッドを読みましたが、ほとんどが逆シリアル化に焦点を当てています。動的オブジェクトのシリアル化も明らかに「失敗」するという問題に直面しています。 私のシナリオを再現するために、次の最小限の再現を思いつきました。

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Text.Json;

namespace SampleConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            dynamic d = new CustomDynamicObject();
            d.AProperty = 10;
            var s = JsonSerializer.Serialize(d);

            Console.WriteLine(s);
            Console.Read();
        }
    }

    class CustomDynamicObject : DynamicObject 
    {
        private readonly IDictionary<string, object> properties = new Dictionary<string, object>();

        public override bool TryGetMember(GetMemberBinder binder, out object result) => properties.TryGetValue(binder.Name, out result);

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            properties[binder.Name] = value;
            return true;
        }

        public override IEnumerable<string> GetDynamicMemberNames()
        {
            foreach (var item in properties.Keys)
            {
                yield return item;
            }
        }
    }
}

s実行すると{}になるため、シリアル化は失敗しませんが、空のjsonオブジェクトが生成されます。

これは正しい問題ですか？ または、別のものをレイズ/フォローする必要がありますか？

これは正しい問題ですか？ または、別のものをレイズ/フォローする必要がありますか？

これは正しい問題です。 同じ機能の2つの半分のために1つを開く必要はありません。 この問題は、expandoオブジェクトのサポートを追加することに関するものです（つまり、両側でシリアル化と逆シリアル化を行います）。

私は今日この問題に遭遇しました-それが処分されたJsonDocument依存していなければ、 JsonElementはうまくいくと言いたかったのです。 この問題を回避する方法の1つは、 JsonDocumentデストラクタを実装して、すべてのJsonElementオブジェクトが収集されたら、破棄を後で延期できるようにすることです。

動的オブジェクトも必要でした。 ただし、まだ実装されていません。 私の解決策は辞書を使うことでした。
JsonSerializer.Deserialize<Dictionary<string, string>>(response)
そして、必要なキーを探します:)

私自身の正気のために-問題の範囲は5.0、特にExpandoObjectのサポートですか、それとも動的オブジェクトに逆シリアル化する機能ですか？ ここでの会話はすべて問題のタイトルと一致していないようで、私は間違いなく後者が必要です。 私の場合、ネストされたダイナミック、具体的にはList<Dictionary<string, dynamic>>逆シリアル化します。 今のところNewtonsoftに切り替えました:(

@tchivsの役立つコードのc＃8構文シュガーモッドを共有したかっただけです:)

/// <summary>
/// Temp Dynamic Converter with c# 8
/// by:[email protected]
/// </summary>
public class DynamicJsonConverter : JsonConverter<dynamic>
{
    public override dynamic Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        => reader.TokenType switch
        {
            JsonTokenType.True => true,
            JsonTokenType.False => false,
            JsonTokenType.Number => reader.TryGetInt64(out long l) ? 1 : reader.GetDouble(),
            JsonTokenType.String => reader.TryGetDateTime(out DateTime datetime) ? datetime.ToString() : reader.GetString(),
            JsonTokenType.StartObject =>  ReadObject(JsonDocument.ParseValue(ref reader).RootElement),
            // Use JsonElement as fallback.
                _ =>JsonDocument.ParseValue(ref reader).RootElement.Clone()
        };

    private object ReadObject(JsonElement jsonElement)
    {
        IDictionary<string, object> expandoObject = new ExpandoObject();
        foreach (var obj in jsonElement.EnumerateObject())
        {
            var k = obj.Name;
            var value = ReadValue(obj.Value);
            expandoObject[k] = value;
        }
        return expandoObject;
    }
    private object? ReadValue(JsonElement jsonElement)
        =>
         jsonElement.ValueKind switch
        {
            JsonValueKind.Object => ReadObject(jsonElement),
            JsonValueKind.Array => ReadList(jsonElement),
            JsonValueKind.String => jsonElement.GetString(),
            JsonValueKind.Number =>  jsonElement.TryGetInt64(out long l) ? 1 :0,
            JsonValueKind.True => true,
            JsonValueKind.False =>false,
            JsonValueKind.Undefined => null,
            JsonValueKind.Null => null,
                _ => throw new ArgumentOutOfRangeException()
        };

    private object? ReadList(JsonElement jsonElement)
    {
        var list = new List<object?>();
        jsonElement.EnumerateArray().ToList().ForEach(j => list.Add(ReadValue(j)));
        return list.Count == 0 ? null : list;
    }

    public override void Write(Utf8JsonWriter writer,
        object value,
        JsonSerializerOptions options)
        {
        // writer.WriteStringValue(value.ToString());
        }
}

@ rs38ここのコードに感謝します、まさに私が必要としていたものでした。 非常に微妙だが重要な変更が必要であることを指摘したかった。 「数値」タイプを解析する2行は、圧縮バージョンでは正しくありません。

JsonTokenType.Number => reader.TryGetInt64(out long l) ? 1 : reader.GetDouble(),

する必要があります

JsonTokenType.Number => reader.TryGetInt64(out long l) ? l : reader.GetDouble(),

JsonValueKind.Number => jsonElement.TryGetInt64(out long l) ? 1 :0,

する必要があります

JsonValueKind.Number => jsonElement.TryGetInt64(out long l) ? l :0,

@layomiaこれは深刻ではありません。 サポートはずっと前に行われるべきでした（実際、私の意見では、System.Text.Jsonはそれなしで起動されるべきではありませんでした）！ そして、期限もありません！

私のシナリオはCosmosDBに関するものです。 このJsonSerializerを使用する新しい.NETSDKを使用してクエリを実行しています。これはスキーマレスデータベースであるため、実行する必要のあるデータベースデータの投影ごとにクラスを作成したくありません（さまざまなクエリが多数あります） 。
動的オブジェクトのリストとしてクエリの結果が必要です。

@ SocVi100これについてMicrosoftに期待しないでください。 NewtonsoftのJson.netを使い続けることをお勧めします。 @layomiaは、近い将来の統合へのすべての期待を

貢献してみませんか？ それを実装してPRに入れてください！

https://github.com/dotnet/runtime/blob/master/docs/coding-guidelines/adding-api-guidelines.md
https://github.com/dotnet/runtime/blob/master/docs/area-owners.md （リード：
@ericstj |、所有者： @layomia @steveharter @jozkee）

貢献してみませんか？ それを実装してPRに入れてください！

私もそう出来ればいいけど。

私のシナリオはCosmosDBに関するものです。 このJsonSerializerを使用する新しい.NETSDKを使用してクエリを実行しています。これはスキーマレスデータベースであるため、実行する必要のあるデータベースデータの投影ごとにクラスを作成したくありません（さまざまなクエリが多数あります） 。
動的オブジェクトのリストとしてクエリの結果が必要です。

CosmosClientBuilder.WithCustomSerializerを使用して、別の

次に例を示します。CosmosJsonNetSerializer

この機能を5.0に適合させることができませんでした。 5.0の機能の残りの部分と一緒に優先順位を付ける必要がありましたが、これは適合しませんでした。 FWIWこれはカットラインに非常に近かったため、動きが遅くなりました。

@layomiaは、近い将来の統合へのすべての期待を

@RobbyDeLaetこの議論を建設的に保つことを試みることができますか？ 私たちは、設計原則を維持しながら、最も要求された顧客の機能に対応するために最善を尽くしています。 Newtonsoft.Jsonとの機能の同等性に関して、これが私たちが言わなければなら

System.Text.Jsonは、主にパフォーマンス、セキュリティ、および標準への準拠に重点を置いています。 一部のシナリオでは、System.Text.Jsonに組み込みの機能はありませんが、推奨される回避策があります。 アプリケーションが不足している機能に依存している場合は、問題を提出して、シナリオのサポートを追加できるかどうかを確認することを検討してください。

Newtonsoft.JSONを置き換えることは目指していません。 それがあなたのために働くならば、それを使い続けてください。 System.Text.Jsonを可能な限り有用なものにするために最善を尽くし、パフォーマンス、セキュリティ、標準への準拠、および階層化で達成した利益を維持します。 時間をかけて、できるだけ多くの人々のためにそれが機能するようにしたいと思っています。 私はここで関心を聞いており、今後もこれに焦点を当てることを確認します。

あなたの提案をありがとう。 Newtonsoftシリアライザーを逆シリアル化にのみ使用して、ようやく途中で終わりましたが、それでもテストする必要があります。 CosmosDBのデフォルトのシリアライザーでExpandoObjectのサポートを取得して、古いシリアライザーを削除できるようになるまで、それほど長くは続かないことを願っています。
@RobbyDeLaet 、コメントありがとう
問題は常に同じです：マーケティングが多すぎる=期待が多すぎる

この機能が必要なユーザーを支援するには、上記のコードサンプルを参照してブロックを解除してください。

• @tchivsから（オブジェクトにはExpandoObjectを使用し、コレクションにはList<object>を使用します）
• @denmitchellから（ ExpandoObject代わりにオブジェクトにIL Emitを使用します）

この機能の要件を支援するために、新しいカスタムコンバーターのサンプルを提供し、準備ができたらここにリンクします。 その後、そのサンプルをNewtonsoftの回避策セクションに追加します。 cc @tdykstra

まだ説明されていない詳細の1つは、 dynamicをサポートするには、非常に大きなSystem.Linq.Expressions.dllアセンブリへの参照が必要であることです。 この複雑さは、将来、新しいアセンブリ（ System.Text.Json.Converters.dll ）に動的コンバーターを追加して、デプロイサイズを気にする人（自己完結型アプリやBlazorなど）のペイ・トゥ・プレイを取得することを意味する可能性がありますクライアントアプリ）。

私自身の正気のために-問題の範囲は5.0、特にExpandoObjectのサポートですか、それとも動的オブジェクトに逆シリアル化する機能ですか？ ここでの会話はすべて問題のタイトルと一致していないようで、私は間違いなく後者が必要です。 私の場合、ネストされたダイナミック、具体的にはList<Dictionary<string, dynamic>>逆シリアル化します。 今のところNewtonsoftに切り替えました:(

現在、ネストされたオブジェクトを逆シリアル化するために実装した古い関数をテストしており、このトピックで「valueKind」に記載されているのと同じ問題が発生しています。

新しいneetonsoft.jsonパッケージを使用してこれを修正する方法はありましたか？ 上記のコードはルートレベルのオブジェクトでは機能しましたが、ネストされたオブジェクトでは機能しなかったためです。

@ericstj申し訳ありませんが、私の反応はおそらく少し否定的で厳しいものでしたが、 優勢になります。 しかし、少なくともここで議論が始まりました。 ご返信いただきありがとうございます。このリクエストのステータスについて、少なくとも明確なメッセージが届きました。

私自身の正気のために-5.0、特にExpandoObjectのサポートまたは動的オブジェクトにデシリアライズする機能の対象となる問題です

必要なセマンティクスは動的タイプであると想定しているため、逆シリアル化した後、すべてのプロパティ（ネストされたものを含む）にレイトバウンドでアクセスできます。

dynamic obj = JsonSerializer.Deserialize<dynamic>(json);
string s = obj.MyChildProperty.MyStringList[2];

そして、必要なセマンティクスも明示的にExpandoObjectサポートすると思います。

ExpandoObject expando = JsonSerializer.Deserialize<ExpandoObject>(json);
dynamic obj = expando;
string s = obj.MyChildProperty.MyStringList[2];

だから私のスコープの理解：

• Deserialize<dynamic>(json)は、プリミティブ、コレクション、またはオブジェクトのいずれかを返します。 ここでのオブジェクトはおそらくExpandoObjectが、実装に応じてIDynamicMetaObjectProviderまたはJITedタイプになる可能性があります。 これは、常にJsonElement返す今日とは異なります。
• Deserialize<ExpandoObject>(json) （ IDynamicMetaObjectProviderを実装）は適切なExpandoObjectを作成する必要があり、これをdynamicで使用できます。 これは、ルートプロパティのexpando-propertiesと、ネストされたすべてのプロパティのJsonElementインスタンスのみを作成する今日とは異なります。
• Serialize<ExpandoObect>()は期待どおりに機能します
• Serialize<IDynamicMetaObjectProvider （）>は、 ExpandoObjectが使用されないシナリオがあるかどうかに応じて、実装される場合とされない場合があります。

3.0-5.0のセマンティクス：

• ExpandoObjectはIDictionary<string, object>を実装し、STJはプリミティブ、コレクション、オブジェクトのいずれであっても、各object値を正しくシリアル化するため、 ExpandoObjectシリアル化は機能します。
• ExpandoObject種類の作品に逆シリアル化しますが、ルートプロパティのみが「適切な」expando-propertiesです。 ネストされたプロパティはJsonElementなるため、プログラミングモデルに一貫性がないため、カスタムコンバーターを使用しない限り、 ExpandoObject逆シリアル化

3.0〜5.0のオプション：

• 上記の投稿に記載されているように、 ExpandoObjectおよび\またはobjectカスタムコンバーターを作成します。 6.0の機能に理想的にマッピングされる新しいサンプルへのリンクをすぐに提供します。
• あなただけのシリアル化、逆シリアル化されていない場合は、使用することができますExpandoObject （またはdynamicタイプはに基づいている場合、 ExpandoObject ）。 ExpandoObject逆シリアル化には、今日のSTJでの不整合の問題があるため、逆シリアル化する場合はExpandoObjectはお勧めしません。
• 動的オブジェクトの代わりにJsonElement使用します。 JsonElementは、JSONがどのタイプにマップされるかを「推測」しようとしないため、GetString（）、GetInt32（）などを呼び出して明示的にする必要があります。

また、実装によっては、カスタムコンバーターの実装は、逆シリアル化中にJSONマップをCLRタイプするものについて何らかの「推測」があることを意味する可能性があります。 たとえば、JSON文字列はDateTimeまたはstringいずれかにマップされ、JSON番号はdoubleまたはlongにマップされます。 JSON配列タイプを決定する必要があります。 これを精査し、Newtonsoftセマンティクスと比較する必要があります。 これは、プロパティがタイプobject （現在はJsonElement ）の場合に返されるタイプにも一致する必要があります。

3.0〜5.0のSTJセマンティクスの例を次に示します。

using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Diagnostics;
using System.Linq;
using System.Text.Json;

namespace ConsoleApp
{
    class Program
    {
        const string ExpectedJson = "{\"A\":\"A\",\"B\":[1,2],\"C\":42,\"D\":\"2020-01-01T00:00:00\",\"E\":{\"A_Child\":\"A_Child\"}}";

        static void Main(string[] args)
        {
            DateTime dateTime = new DateTime(2020, 1, 1);

            dynamic myDynamicChild = new ExpandoObject();
            myDynamicChild.A_Child = "A_Child";

            dynamic myDynamic = new ExpandoObject();
            myDynamic.A = "A";
            myDynamic.B = new List<int>() { 1, 2 };
            myDynamic.C = 42;
            myDynamic.D = dateTime;
            myDynamic.E = myDynamicChild;

            // Verify we can call late-bound property.
            int c = myDynamic.C;
            Debug.Assert(c == 42);

            // STJ can serialize with ExpandoObject since it implements IDictionary<string, object>.
            string json = JsonSerializer.Serialize<ExpandoObject>(myDynamic);
            Debug.Assert(json == ExpectedJson);

            // Using 'dynamic' against backing ExpandoObject works.
            json = JsonSerializer.Serialize<dynamic>(myDynamic);
            Debug.Assert(json == ExpectedJson);

            // Deserialize with <dynamic>, <object> and <JsonElement>.
            // For 5.0, using one of these is recommended over ExpandoObject because the programming model will be
            // consistent for the root type and all nested types.
            // Using <JsonElement> makes it clear and non-abiguous.
            // Using <object> by default uses 'JsonElement', but can be overridden by a custom converter.
            // Using <dynamic> uses 'object' which uses 'JsonElement'.
            {
                dynamic d = JsonSerializer.Deserialize<dynamic>(json);
                VerifyJsonElement(d);

                try
                {
                    // We will get an exception here if we try to access a dynamic property since 'object' is deserialized
                    // as a JsonElement and not an ExpandoObject.
                    c = d.C;
                    Debug.Fail("Should have thrown Exception!");
                }
                catch (Exception ex)
                {
                    Debug.Assert(ex.Message == "'System.Text.Json.JsonElement' does not contain a definition for 'C'");
                }

                // Serializing with <object> creates a JsonElement by default (can be changed by a custom converter).
                object o = JsonSerializer.Deserialize<object>(json);
                VerifyJsonElement((JsonElement)o);

                // Serialize with explicit <JsonElement>.
                JsonElement e = JsonSerializer.Deserialize<JsonElement>(json);
                VerifyJsonElement(e);
            }

            // Deserialize with ExpandoObject. This creates an ExpandoObject with the root Type having Expando-properties
            // but the value of those properties will be JsonElement. All other nested properties\objects\collections will
            // also be JsonElement. Due to the inconsistency of having only root-level Expando-properties (such as A_Child),
            // deserializing as ExpandoObject is not recommended (unless a ExpandoObject custom converter is used).
            {
                // When STJ deserializes, it creates ExpandoObjects via IDictionary<string, object> where 'object' is JsonElement.
                ExpandoObject expando = JsonSerializer.Deserialize<ExpandoObject>(json);
                Debug.Assert(((IDictionary<string, object>)expando).Keys.Count == 5);
                myDynamic = expando;

                JsonElement jsonElement = myDynamic.A;
                Debug.Assert(jsonElement.GetString() == "A");

                jsonElement = myDynamic.B;
                Debug.Assert(jsonElement.EnumerateArray().Count() == 2);

                jsonElement = myDynamic.C;
                Debug.Assert(jsonElement.GetInt32() == 42);

                jsonElement = myDynamic.D;
                Debug.Assert(jsonElement.GetDateTime() == dateTime);

                jsonElement = myDynamic.E;
                // Here we have an inconsistency. Nested object property must use JsonElement (not a dynamic property).
                Debug.Assert(jsonElement.GetProperty("A_Child").GetString() == "A_Child");

                // Re-serialize works as expected.
                json = JsonSerializer.Serialize<ExpandoObject>(myDynamic);
                Debug.Assert(json == ExpectedJson);

                // Re-serialize works as expected; dynamic works here since backed by ExpandoObject in this example.
                json = JsonSerializer.Serialize<dynamic>(myDynamic);
                Debug.Assert(json == ExpectedJson);
            }

            void VerifyJsonElement(JsonElement elem)
            {
                // Verify JsonElement
                Debug.Assert(elem.GetProperty("A").GetString() == "A");
                Debug.Assert(elem.GetProperty("B").EnumerateArray().Count() == 2);
                Debug.Assert(elem.GetProperty("C").GetInt32() == 42);
                Debug.Assert(elem.GetProperty("D").GetDateTime() == dateTime);
                Debug.Assert(elem.GetProperty("E").GetProperty("A_Child").GetString() == "A_Child");

                // Re-serialize
                json = JsonSerializer.Serialize<dynamic>(elem);
                Debug.Assert(json == ExpectedJson);

                json = JsonSerializer.Serialize<JsonElement>(elem);
                Debug.Assert(json == ExpectedJson);
            }
        }
    }
}

@ rs38 @ ryan -hollister-q2が指摘したことに基づいて、コードスニペットを修正できますか？

約束どおり、動的な実装サンプルを提供するPRはhttps://github.com/dotnet/runtime/pull/42097にあります。

@ rs38 @ ryan -hollister-q2が指摘したことに基づいて、コードスニペットを修正できますか？

それは私のコードではなく、このスレッドの前半で@tchivsからのスニペットを共有しただけです。