Нет, эта функция на данный момент не поддерживается, но мы должны учесть это в vNext. У вас есть пример использования, чтобы мотивировать запрос функции?

Отмечено как будущее.

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

@ahsonkhan GraphQL - хороший пример.

В спецификации рекомендуется JSON, но он не привязан к какой-либо конкретной сериализации в ответе.
Это означает, что поле «данные» ответа имеет вид: динамическое. Поскольку это невозможно предположить.
Без ExpandoObject десериализация делает динамический тип создания JSON. Таким образом, доступ к этим абстрактным динамическим «данным» должен осуществляться с учетом того, что на самом деле эти динамические данные являются JToken.

Я думаю, что с ExpandoObject мы могли бы обеспечить доступ к динамическим «данным» как к обычному объекту.

@ahsonkhan еще один пример - служба конфигурации в нашем проекте. Он предоставляет коллекцию, такую ​​как конечные точки REST, которые создают коллекции в MongoDB (это не просто фиктивная оболочка 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.net expandoobject»

@MickeyReznikov , ответили на ваш вопрос? Я считаю, что @SidShetye означало вернуться к использованию Newtonsoft.Json для сериализации динамических объектов, поскольку встроенная библиотека (System.Text.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

У меня также есть вариант использования для этого - я просто хочу вызвать REST API с HttpClient и получить одно свойство из ответа. Я не хочу создавать специальный класс только для анализа ответа ... С JSON.NET я мог бы просто использовать «динамический» и получить доступ к выбранному свойству.

С https://github.com/dotnet/corefx/issues/41472 от @ ghost1372 :

привет, я надеюсь, это хорошее место, чтобы задать этот вопрос
Кажется, мы не можем десериализовать динамические объекты
Я использовал этот код, но не работал, есть ли способ сделать это?

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

Во многих наших приложениях мы контролируем поля данных из хранимых процедур и динамически отображаем страницы списка и списка поиска с помощью jquery.jtable.

Без встроенной поддержки JsonSerializer для ExpandoObject мы не можем использовать встроенную сериализацию Json в ядре dotnet.

Мы используем тот же вариант использования, который уже упоминался @estiller и @SidShetye.
Тем временем нам пришлось вернуться на Json.NET.

Возможно ли иметь веху ближе к _ сейчас_, чем к будущему ? 🤔

ExpandoObject был в BCL в течение долгого времени

Есть ли альтернатива ExpandoObject?

@fatihyildizhan Нет альтернативы.

но мы написали наш собственный конвертер ExpandoObject, вы можете воспользоваться подсказкой из этой статьи ASP.NET Core 3.0: Custom JsonConverter для нового System.Text.Json

Нам нужна только сериализация, поэтому мы просто создаем сериализацию

Я был удивлен, что это еще не поддерживается.

Переход на 5.0.

Переходите на 5.0? Значит, надо ждать минимум год? Вернемся к 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);
        }
    }

Мы больше не можем использовать следующее действие POST в присутствии System.Text.Json:

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

Вместо этого нам пришлось использовать следующий метод, но не было прямого использования «модели» в нисходящем бэкэнд-коде:

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

«модель» - это сложный объект, который может содержать набор объектов и / или других вложенных сложных объектов. Чтобы иметь возможность заключить объект dynamic из JsonElement , нам пришлось вызвать model.GetRawText () и заставить Newtonsoft декодировать его в динамический объект. Это нежелательный способ, поскольку основной целью этого упражнения было исключить Newtonsoft.json из проекта.

Могу ли я предположить, что обращение к этой заявке / проблеме подразумевает исправление нашей проблемы, с которой мы столкнулись? Кажется, это немного срочный вопрос, поэтому можно ли решить его раньше, чем позже?

/ cc @ahsonkhan @terrajobst

.NET Core 3.0 JsonSerializer.Deserialize в динамический объект

Поддержка JsonSerializer для ExpandoObject (временные меры)
Я новичок, многие места не идеальны, приглашаем всех изменить
.net Core3 не поддерживается

Добавить конвертер Json

добавить, используя:

• using System.Text.Json;
• using System.Text.Json.Serialization;

`` С #
///

        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 , я внес некоторые изменения в ваш код - переработал его так, чтобы он использовал динамически генерируемые "проекционные" типы (имеющие подмножество свойств из базового типа), а не ExpandoObject. Я разместил код (в примере проекта консоли) здесь: EDennis.DynamicDeserialization .

Я буду тестировать этот подход с более сложными объектами и в различных сценариях (например, десериализация динамических объектов, используемых для исправления существующих, полностью типизированных сущностей EF Core; десериализация json-объектов и массивов для тестовых случаев). Дайте мне знать, если вы найдете это полезным или что-то проблематичное.

Спасибо за обходной путь сообщества. Удивительно, что Microsoft не может реализовать эту функцию в разумные сроки. Работа с ответами 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.

Это правильный вопрос? или я должен поднять / подписаться на другой?

Это правильный вопрос? или я должен поднять / подписаться на другой?

Это правильный вопрос. Нет необходимости открывать одну для двух половинок одного и того же элемента. Эта проблема связана с добавлением поддержки для объекта expando (что означает для обеих сторон сериализацию и десериализацию).

Я столкнулся с этой проблемой сегодня - хотел сказать, что JsonElement будет работать нормально, если это не зависит от удаленного JsonDocument . Один из способов решения этой проблемы - реализовать деструктор для JsonDocument чтобы его удаление можно было отложить на более позднее время - после того, как все объекты JsonElement будут собраны.

Еще мне нужен был динамический объект. Однако это еще не реализовано. Мое решение было использовать словарь.
JsonSerializer.Deserialize<Dictionary<string, string>>(response)
А потом ищи нужный мне ключ :)

Просто для моего рассудка - относится ли проблема к 5.0, в частности, к поддержке ExpandoObject или возможности десериализации в динамический объект? Не все разговоры здесь соответствуют названию проблемы, и мне определенно нужно последнее. В моем случае я десериализую вложенную динамику, в частности List<Dictionary<string, dynamic>> . На данный момент переключился обратно на Newtonsoft :(

просто хотел поделиться некоторыми модификациями синтаксиса 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 спасибо за код, это именно то, что мне нужно. Хотел указать на очень тонкое, но необходимое изменение. Две строки, анализирующие тип «Число», неверны в вашей сжатой версии:

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. Я запрашиваю с помощью нового .NET SDK, который использует этот JsonSerializer, и, поскольку это база данных без схемы, я не хочу создавать класс для каждой проекции данных базы данных, которые мне нужно сделать (существует множество разных запросов) .
Мне нужны результаты запросов в виде списков динамических объектов.

@ SocVi100 Не @layomia развеяла все надежды на интеграцию в ближайшем будущем. Похоже, им наплевать на нужды разработчика. Сначала они кричали: «Забудьте о json.net, мы вас прикрыли!» К счастью, разработчики не забыли про json.net и тому подобное.

почему ты не участвуешь? реализовать и поставить в пиар!

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)

почему ты не участвуешь? реализовать и поставить в пиар!

Я бы хотел.

Мой сценарий касается CosmosDB. Я запрашиваю с помощью нового .NET SDK, который использует этот JsonSerializer, и, поскольку это база данных без схемы, я не хочу создавать класс для каждой проекции данных базы данных, которые мне нужно сделать (существует множество разных запросов) .
Мне нужны результаты запросов в виде списков динамических объектов.

Можно настроить другой сериализатор с помощью CosmosClientBuilder.WithCustomSerializer .

Вот пример: CosmosJsonNetSerializer

Мы не смогли уместить эту функцию в 5.0. Нам пришлось расставить приоритеты вместе с остальной работой над функциями 5.0, и эта не подошла. FWIW это было очень близко к линии разреза, следовательно, поздний ход.

@layomia развеяла все надежды на интеграцию в ближайшем будущем. Похоже, им наплевать на нужды разработчика. Сначала они кричали: «Забудьте о json.net, мы вас прикрыли!» К счастью, разработчики не забыли про json.net и тому подобное.

@RobbyDeLaet, можем ли мы попытаться сохранить конструктивность этого обсуждения? Мы стараемся сделать все возможное, чтобы удовлетворить самые популярные запросы клиентов, сохраняя при этом принципы дизайна. Что касается паритета функций с Newtonsoft.Json, вот что мы должны сказать .

System.Text.Json в первую очередь ориентирован на производительность, безопасность и соответствие стандартам. Для некоторых сценариев System.Text.Json не имеет встроенных функций, но есть рекомендуемые обходные пути. Если ваше приложение зависит от отсутствующей функции, рассмотрите возможность регистрации проблемы, чтобы узнать, можно ли добавить поддержку для вашего сценария.

Мы не стремимся заменить Newtonsoft.JSON. Если это сработало, продолжайте использовать. Мы сделаем все возможное, чтобы сделать System.Text.Json максимально полезным, сохранив при этом достигнутые нами успехи в производительности, безопасности, соответствии стандартам и многоуровневости. Со временем мы надеемся, что это сработает для как можно большего числа людей. Я слышу здесь интерес и постараюсь сосредоточиться на этом в дальнейшем.

Спасибо за ваши предложения. Я наконец дошел до середины, используя сериализатор Newtonsoft только для десериализации, но мне все еще нужно протестировать. Я надеюсь, что поддержка ExpandoObject в сериализаторе по умолчанию CosmosDB не продлится слишком долго, чтобы я мог избавиться от старого.
@RobbyDeLaet , спасибо за комментарий! У меня нет особых надежд на то, что Microsoft внедрит какие-либо элементы, я слишком много раз разочаровывался в них. Как разработчик-фрилансер, я годами буквально ждал, пока важные функции будут реализованы в инфраструктуре CosmosDB, EntityFramework и Identity, и они по-своему игнорируют нас. Неважно, сколько у них голосов на UserVoice или чем-то еще. Я предполагаю, что такие функции не нужны для его собственных разработок, поэтому они выходят за рамки ...
Проблема всегда одна и та же: слишком много маркетинга = слишком много ожиданий.

Чтобы помочь тем, кому нужна эта функция, см. Приведенные выше примеры кода для разблокировки:

• От @tchivs (который использует ExpandoObject для объектов и List<object> для коллекций)
• От @denmitchell (который использует IL Emit для объектов вместо ExpandoObject )

Чтобы помочь с требованиями к этой функции, я предоставлю новый образец настраиваемого конвертера и свяжу его здесь, когда он будет готов. После этого я добавлю этот образец в раздел обходных решений Newtonsoft . cc @tdykstra

Одна деталь, которая еще не обсуждалась, заключается в том, что для поддержки dynamic требуется ссылка на очень большую сборку System.Linq.Expressions.dll ; это осложнение может означать, что в будущем мы добавим динамический преобразователь в новую сборку (например, System.Text.Json.Converters.dll ), чтобы получить плату за игру для тех, кто заботится о размере развертывания (например, автономное приложение или Blazor клиентское приложение).

Просто для моего рассудка - относится ли проблема к 5.0, в частности, к поддержке ExpandoObject или возможности десериализации в динамический объект? Не все разговоры здесь соответствуют названию проблемы, и мне определенно нужно последнее. В моем случае я десериализую вложенную динамику, в частности List<Dictionary<string, dynamic>> . На данный момент переключился обратно на Newtonsoft :(

Сейчас я тестирую старую функцию, которую реализовал для десериализации вложенных объектов, и вижу ту же проблему, что и в этом разделе, с «valueKind».

Был ли способ исправить это с помощью новых пакетов neetonsoft.json? Поскольку приведенный выше код работал для объекта корневого уровня, но не для вложенных объектов.

@ericstj Извините, моя реакция была, возможно, слишком негативной и резкой, но, как и @ SocVi100, я внештатный разработчик, и иногда разочарование

Просто для моего рассудка - это проблема, относящаяся к 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 . Это отличается от сегодняшнего дня, когда создаются расширенные свойства только для корневых свойств и экземпляров JsonElement для всех вложенных свойств.
• Serialize<ExpandoObect>() работает должным образом
• Serialize<IDynamicMetaObjectProvider ()> может или не может быть реализовано в зависимости от того, существуют ли сценарии, в которых ExpandoObject не используется.

Семантика в 3.0 - 5.0:

• Сериализация ExpandoObject работает, поскольку ExpandoObject реализует IDictionary<string, object> а STJ правильно сериализует каждое значение object будь то примитив, коллекция или объект.
• Десериализация в вид ExpandoObject работает, но только корневые свойства являются «правильными» расширяемыми свойствами; любые вложенные свойства будут иметь вид JsonElement поэтому в модели программирования существует несогласованность, поэтому следует избегать десериализации ExpandoObject если для этого не используется специальный преобразователь.

Варианты 3.0-5.0:

• Напишите собственный конвертер для ExpandoObject и \ или object как указано в сообщениях выше; Я скоро предоставлю ссылку на новый образец, который идеально соответствует функции 6.0.
• Если вы только сериализуете, а не десериализуете, вы можете использовать ExpandoObject (или dynamic если тип основан на ExpandoObject ). Поскольку десериализация ExpandoObject имеет проблему несогласованности в STJ, ExpandoObject не рекомендуется при десериализации.
• Используйте JsonElement вместо динамических объектов. JsonElement не пытается «угадать», какому типу сопоставляется JSON, поэтому вы должны явно указать, вызывая GetString (), GetInt32 () и т. Д.

Кроме того, в зависимости от реализации реализация настраиваемого конвертера, вероятно, означает, что есть некоторые «догадки» о том, какие типы CLR сопоставляются JSON во время десериализации. Например, строка 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 ранее в этом потоке.