Prototype moving JsonData to be backed by JsonDocument

sdk/core/Azure.Core.Experimental/api/Azure.Core.Experimental.netstandard2.0.cs

@@ -115,52 +115,62 @@ public static partial class BinaryDataExtensions
     public abstract partial class DynamicData
     {
         protected DynamicData() { }
-        internal abstract void WriteTo(System.Text.Json.Utf8JsonWriter writer);
-        public static void WriteTo(System.Text.Json.Utf8JsonWriter writer, Azure.Core.Dynamic.DynamicData data) { }
+        internal abstract void WriteTo(System.IO.Stream stream);
+        public static void WriteTo(System.IO.Stream stream, Azure.Core.Dynamic.DynamicData data) { }
     }
-    [System.Diagnostics.DebuggerDisplayAttribute("{DebuggerDisplay,nq}")]
-    public partial class JsonData : Azure.Core.Dynamic.DynamicData, System.Dynamic.IDynamicMetaObjectProvider, System.IEquatable<Azure.Core.Dynamic.JsonData>
+    public partial class DynamicJson : Azure.Core.Dynamic.DynamicData, System.Dynamic.IDynamicMetaObjectProvider, System.IEquatable<Azure.Core.Dynamic.MutableJsonDocument>
     {
-        internal JsonData() { }
-        public bool Equals(Azure.Core.Dynamic.JsonData other) { throw null; }
+        internal DynamicJson() { }
+        public bool Equals(Azure.Core.Dynamic.MutableJsonDocument? other) { throw null; }
         public override bool Equals(object? obj) { throw null; }
         public override int GetHashCode() { throw null; }
-        public static bool operator ==(Azure.Core.Dynamic.JsonData? left, bool right) { throw null; }
-        public static bool operator ==(Azure.Core.Dynamic.JsonData? left, double right) { throw null; }
-        public static bool operator ==(Azure.Core.Dynamic.JsonData? left, int right) { throw null; }
-        public static bool operator ==(Azure.Core.Dynamic.JsonData? left, long right) { throw null; }
-        public static bool operator ==(Azure.Core.Dynamic.JsonData? left, float right) { throw null; }
-        public static bool operator ==(Azure.Core.Dynamic.JsonData? left, string? right) { throw null; }
-        public static bool operator ==(bool left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator ==(double left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator ==(int left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator ==(long left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator ==(float left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator ==(string? left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static implicit operator bool (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator double (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator int (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator long (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator bool? (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator double? (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator int? (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator long? (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator float? (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator float (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static implicit operator string (Azure.Core.Dynamic.JsonData json) { throw null; }
-        public static bool operator !=(Azure.Core.Dynamic.JsonData? left, bool right) { throw null; }
-        public static bool operator !=(Azure.Core.Dynamic.JsonData? left, double right) { throw null; }
-        public static bool operator !=(Azure.Core.Dynamic.JsonData? left, int right) { throw null; }
-        public static bool operator !=(Azure.Core.Dynamic.JsonData? left, long right) { throw null; }
-        public static bool operator !=(Azure.Core.Dynamic.JsonData? left, float right) { throw null; }
-        public static bool operator !=(Azure.Core.Dynamic.JsonData? left, string? right) { throw null; }
-        public static bool operator !=(bool left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator !=(double left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator !=(int left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator !=(long left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator !=(float left, Azure.Core.Dynamic.JsonData? right) { throw null; }
-        public static bool operator !=(string? left, Azure.Core.Dynamic.JsonData? right) { throw null; }
         System.Dynamic.DynamicMetaObject System.Dynamic.IDynamicMetaObjectProvider.GetMetaObject(System.Linq.Expressions.Expression parameter) { throw null; }
-        public override string ToString() { throw null; }
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct DynamicJsonElement : System.Dynamic.IDynamicMetaObjectProvider, System.IEquatable<Azure.Core.Dynamic.DynamicJsonElement>
+    {
+        private object _dummy;
+        private int _dummyPrimitive;
+        public bool Equals(Azure.Core.Dynamic.DynamicJsonElement other) { throw null; }
+        public override bool Equals(object obj) { throw null; }
+        public override int GetHashCode() { throw null; }
+        public static implicit operator bool (Azure.Core.Dynamic.DynamicJsonElement value) { throw null; }
+        public static implicit operator double (Azure.Core.Dynamic.DynamicJsonElement value) { throw null; }
+        public static implicit operator int (Azure.Core.Dynamic.DynamicJsonElement value) { throw null; }
+        public static implicit operator long (Azure.Core.Dynamic.DynamicJsonElement value) { throw null; }
+        public static implicit operator float (Azure.Core.Dynamic.DynamicJsonElement value) { throw null; }
+        public static implicit operator string? (Azure.Core.Dynamic.DynamicJsonElement value) { throw null; }
+        System.Dynamic.DynamicMetaObject System.Dynamic.IDynamicMetaObjectProvider.GetMetaObject(System.Linq.Expressions.Expression parameter) { throw null; }
+    }
+    [System.Text.Json.Serialization.JsonConverterAttribute(typeof(System.Text.Json.Serialization.JsonConverter))]
+    public partial class MutableJsonDocument
+    {
+        internal MutableJsonDocument() { }
+        public Azure.Core.Dynamic.MutableJsonElement RootElement { get { throw null; } }
+        public static Azure.Core.Dynamic.MutableJsonDocument Parse(System.BinaryData utf8Json) { throw null; }
+        public static Azure.Core.Dynamic.MutableJsonDocument Parse(string json) { throw null; }
+        public void WriteTo(System.IO.Stream stream, System.Buffers.StandardFormat format = default(System.Buffers.StandardFormat)) { }
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public partial struct MutableJsonElement
+    {
+        private object _dummy;
+        private int _dummyPrimitive;
+        public bool GetBoolean() { throw null; }
+        public double GetDouble() { throw null; }
+        public float GetFloat() { throw null; }
+        public int GetInt32() { throw null; }
+        public long GetInt64() { throw null; }
+        public Azure.Core.Dynamic.MutableJsonElement GetProperty(string name) { throw null; }
+        public string? GetString() { throw null; }
+        public void RemoveProperty(string name) { }
+        public void Set(Azure.Core.Dynamic.MutableJsonElement value) { }
+        public void Set(bool value) { }
+        public void Set(double value) { }
+        public void Set(int value) { }
+        public void Set(object value) { }
+        public void Set(string value) { }
+        public void SetProperty(string name, object value) { }
+        public bool TryGetProperty(string name, out Azure.Core.Dynamic.MutableJsonElement value) { throw null; }
     }
 }

sdk/core/Azure.Core.Experimental/src/Azure.Core.Experimental.csproj

@@ -1,11 +1,11 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Description>Experimental types that might eventually move to Azure.Core</Description>
     <AssemblyTitle>Microsoft Azure Client Pipeline Experimental Extensions</AssemblyTitle>
     <Version>0.1.0-preview.24</Version>
     <PackageTags>Microsoft Azure Client Pipeline</PackageTags>
     <Nullable>enable</Nullable>
-    <TargetFrameworks>$(RequiredTargetFrameworks)</TargetFrameworks>
+    <TargetFrameworks>$(RequiredTargetFrameworks);net461;net6.0</TargetFrameworks>
     <NoWarn>$(NoWarn);AZC0001;AZC0012</NoWarn>
     <IncludeOperationsSharedSource>true</IncludeOperationsSharedSource>
   </PropertyGroup>

sdk/core/Azure.Core.Experimental/src/BinaryDataExtensions.cs

@@ -15,7 +15,7 @@ public static class BinaryDataExtensions
         /// </summary>
         public static dynamic ToDynamic(this BinaryData data)
         {
-            return JsonData.Parse(data);
+            return new DynamicJson(MutableJsonDocument.Parse(data).RootElement);
         }
     }
 }

sdk/core/Azure.Core.Experimental/src/DynamicData.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-using System.Text.Json;
+using System.IO;
 
 namespace Azure.Core.Dynamic
 {
@@ -14,15 +14,15 @@ namespace Azure.Core.Dynamic
     public abstract class DynamicData
     {
         /// <summary>
-        /// Writes the data to the provided writer as a JSON value.
+        /// Writes the data to the provided stream.
         /// </summary>
-        /// <param name="writer">The writer to which to write the document.</param>
+        /// <param name="stream">The stream to which to write the document.</param>
         /// <param name="data">The dynamic data value to write.</param>
-        public static void WriteTo(Utf8JsonWriter writer, DynamicData data)
+        public static void WriteTo(Stream stream, DynamicData data)
         {
-            data.WriteTo(writer);
+            data.WriteTo(stream);
         }
 
-        internal abstract void WriteTo(Utf8JsonWriter writer);
+        internal abstract void WriteTo(Stream stream);
     }
 }

sdk/core/Azure.Core.Experimental/src/DynamicJson.DynamicMetaObject.cs

@@ -0,0 +1,181 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using System;
+using System.Dynamic;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text.Json;
+
+namespace Azure.Core.Dynamic
+{
+    public partial class DynamicJson : IDynamicMetaObjectProvider
+    {
+        private static readonly MethodInfo GetPropertyMethod = typeof(DynamicJson).GetMethod(nameof(GetProperty), BindingFlags.NonPublic | BindingFlags.Instance)!;
+        private static readonly MethodInfo SetMethod = typeof(DynamicJson).GetMethod(nameof(Set), BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(object) }, null)!;
+        private static readonly MethodInfo GetViaIndexerMethod = typeof(DynamicJson).GetMethod(nameof(GetViaIndexer), BindingFlags.NonPublic | BindingFlags.Instance)!;
+        private static readonly MethodInfo SetViaIndexerMethod = typeof(DynamicJson).GetMethod(nameof(SetViaIndexer), BindingFlags.NonPublic | BindingFlags.Instance)!;
+
+        /// <summary>
+        /// Gets a value indicating whether the current instance has a valid value of its underlying type.
+        /// </summary>
+        // TODO: Decide if this is the API we want for this.  We could also expose ValueKind.
+        public bool HasValue => _element.ValueKind != JsonValueKind.Null;
+
+        private object GetProperty(string name)
+        {
+            if (name == nameof(HasValue))
+            {
+                return HasValue;
+            }
+
+            return new DynamicJson(_element.GetProperty(name));
+        }
+
+        private object GetViaIndexer(object index)
+        {
+            switch (index)
+            {
+                case string propertyName:
+                    return GetProperty(propertyName);
+                case int arrayIndex:
+                    return new DynamicJson(_element.GetIndexElement(arrayIndex));
+            }
+
+            throw new InvalidOperationException($"Tried to access indexer with an unsupported index type: {index}");
+        }
+
+        private object? Set(object value)
+        {
+            switch (value)
+            {
+                case int i:
+                    _element.Set(i);
+                    break;
+                case double d:
+                    _element.Set(d);
+                    break;
+                case string s:
+                    _element.Set(s);
+                    break;
+                case bool b:
+                    _element.Set(b);
+                    break;
+                case MutableJsonElement e:
+                    _element.Set(e);
+                    break;
+                default:
+                    _element.Set(value);
+                    break;
+
+                    // TODO: add support for other supported types
+            }
+
+            // Binding machinery expects the call site signature to return an object
+            return null;
+        }
+
+        private object? SetViaIndexer(object index, object value)
+        {
+            DynamicJson element = (DynamicJson)GetViaIndexer(index);
+            return element.Set(value);
+        }
+
+        private T ConvertTo<T>()
+        {
+            // TODO: Respect user-provided serialization options
+
+#if NET6_0_OR_GREATER
+            return JsonSerializer.Deserialize<T>(_element.GetJsonElement(), MutableJsonDocument.DefaultJsonSerializerOptions)!;
+#else
+            // TODO: Could we optimize this by serializing from the byte array instead?  We don't currently slice into this in WriteTo(), but could look at storing that.
+            return JsonSerializer.Deserialize<T>(_element.ToString(), MutableJsonDocument.DefaultJsonSerializerOptions);
+#endif
+        }
+
+        /// <inheritdoc />
+        DynamicMetaObject IDynamicMetaObjectProvider.GetMetaObject(Expression parameter) => new MetaObject(parameter, this);
+
+        private class MetaObject : DynamicMetaObject
+        {
+            internal MetaObject(Expression parameter, IDynamicMetaObjectProvider value) : base(parameter, BindingRestrictions.Empty, value)
+            {
+            }
+
+            public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
+            {
+                UnaryExpression this_ = Expression.Convert(Expression, LimitType);
+
+                Expression[] getPropertyArgs = new Expression[] { Expression.Constant(binder.Name) };
+                MethodCallExpression getPropertyCall = Expression.Call(this_, GetPropertyMethod, getPropertyArgs);
+
+                BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(Expression, LimitType);
+                return new DynamicMetaObject(getPropertyCall, restrictions);
+            }
+
+            public override DynamicMetaObject BindGetIndex(GetIndexBinder binder, DynamicMetaObject[] indexes)
+            {
+                UnaryExpression this_ = Expression.Convert(Expression, LimitType);
+
+                Expression[] arguments = new Expression[] { Expression.Convert(indexes[0].Expression, typeof(object)) };
+                MethodCallExpression getViaIndexerCall = Expression.Call(this_, GetViaIndexerMethod, arguments);
+
+                BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(Expression, LimitType);
+                return new DynamicMetaObject(getViaIndexerCall, restrictions);
+            }
+
+            public override DynamicMetaObject BindConvert(ConvertBinder binder)
+            {
+                Expression targetObject = Expression.Convert(Expression, LimitType);
+                BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(Expression, LimitType);
+
+                Expression convertCall;
+
+                //if (binder.Type == typeof(IEnumerable))
+                //{
+                //    convertCall = Expression.Call(targetObject, GetDynamicEnumerableMethod);
+                //    return new DynamicMetaObject(convertCall, restrictions);
+                //}
+
+                if (CastFromOperators.TryGetValue(binder.Type, out MethodInfo? castOperator))
+                {
+                    convertCall = Expression.Call(castOperator, targetObject);
+                    return new DynamicMetaObject(convertCall, restrictions);
+                }
+
+                convertCall = Expression.Call(targetObject, nameof(ConvertTo), new Type[] { binder.Type });
+                return new DynamicMetaObject(convertCall, restrictions);
+            }
+
+            public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
+            {
+                UnaryExpression this_ = Expression.Convert(Expression, LimitType);
+
+                Expression[] getPropertyArgs = new Expression[] { Expression.Constant(binder.Name) };
+                MethodCallExpression getPropertyCall = Expression.Call(this_, GetPropertyMethod, getPropertyArgs);
+
+                UnaryExpression property = Expression.Convert(getPropertyCall, typeof(DynamicJson));
+
+                Expression[] setDynamicArgs = new Expression[] { Expression.Convert(value.Expression, typeof(object)) };
+                MethodCallExpression setCall = Expression.Call(property, SetMethod, setDynamicArgs);
+
+                BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(Expression, LimitType);
+                return new DynamicMetaObject(setCall, restrictions);
+            }
+
+            public override DynamicMetaObject BindSetIndex(SetIndexBinder binder, DynamicMetaObject[] indexes, DynamicMetaObject value)
+            {
+                UnaryExpression this_ = Expression.Convert(Expression, LimitType);
+
+                Expression[] setArgs = new Expression[2] {
+                    Expression.Convert(indexes[0].Expression, typeof(object)),
+                    Expression.Convert(value.Expression, typeof(object))
+                };
+                MethodCallExpression setCall = Expression.Call(this_, SetViaIndexerMethod, setArgs);
+
+                BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(Expression, LimitType);
+                return new DynamicMetaObject(setCall, restrictions);
+            }
+        }
+    }
+}