Add caching to SchemaRegistryClient (Azure#23274)

* Add caching to SchemaRegistryClient

* Add comments for warnings being disabled

Author: JoshLove-msft

sdk/schemaregistry/Azure.Data.SchemaRegistry/CHANGELOG.md

@@ -1,7 +1,7 @@
 # Release History
 
-## 1.0.0-beta.3 (Unreleased)
-
+## 1.0.0-beta.3 (2021-08-16)
+- Added caching to `SchemaRegistryClient`
 
 ## 1.0.0-beta.2 (2020-09-22)
 - Fixed schema encoding issue

sdk/schemaregistry/Azure.Data.SchemaRegistry/README.md

@@ -9,7 +9,7 @@ Azure Schema Registry is a schema repository service hosted by Azure Event Hubs,
 Install the Azure Schema Registry client library for .NET with [NuGet][nuget]:
 
 ```bash
-dotnet add package Azure.Data.SchemaRegistry --version 1.0.0-beta.1
+dotnet add package --prerelease Azure.Data.SchemaRegistry
 ```
 
 ### Prerequisites
@@ -125,17 +125,17 @@ string schemaContent = @"
     ]
 }";
 
-Response<SchemaProperties> schemaProperties = client.GetSchemaId(groupName, schemaName, schemaType, schemaContent);
-string schemaId = schemaProperties.Value.Id;
+SchemaProperties schemaProperties = client.GetSchemaId(groupName, schemaName, schemaType, schemaContent);
+string schemaId = schemaProperties.Id;
 ```
 
 ### Retrieve a schema
 
 Retrieve a previously registered schema's content from the Azure Schema Registry.
 
 ```C# Snippet:SchemaRegistryRetrieveSchema
-Response<SchemaProperties> schemaProperties = client.GetSchema(schemaId);
-string schemaContent = schemaProperties.Value.Content;
+SchemaProperties schemaProperties = client.GetSchema(schemaId);
+string schemaContent = schemaProperties.Content;
 ```
 
 ## Troubleshooting

sdk/schemaregistry/Azure.Data.SchemaRegistry/api/Azure.Data.SchemaRegistry.netstandard2.0.cs

@@ -11,10 +11,10 @@ public partial class SchemaRegistryClient
         protected SchemaRegistryClient() { }
         public SchemaRegistryClient(string endpoint, Azure.Core.TokenCredential credential) { }
         public SchemaRegistryClient(string endpoint, Azure.Core.TokenCredential credential, Azure.Data.SchemaRegistry.SchemaRegistryClientOptions options) { }
-        public virtual Azure.Response<Azure.Data.SchemaRegistry.SchemaProperties> GetSchema(string schemaId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
-        public virtual System.Threading.Tasks.Task<Azure.Response<Azure.Data.SchemaRegistry.SchemaProperties>> GetSchemaAsync(string schemaId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
-        public virtual Azure.Response<Azure.Data.SchemaRegistry.SchemaProperties> GetSchemaId(string groupName, string schemaName, Azure.Data.SchemaRegistry.SerializationType serializationType, string schemaContent, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
-        public virtual System.Threading.Tasks.Task<Azure.Response<Azure.Data.SchemaRegistry.SchemaProperties>> GetSchemaIdAsync(string groupName, string schemaName, Azure.Data.SchemaRegistry.SerializationType serializationType, string schemaContent, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public virtual Azure.Data.SchemaRegistry.SchemaProperties GetSchema(string schemaId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public virtual System.Threading.Tasks.ValueTask<Azure.Data.SchemaRegistry.SchemaProperties> GetSchemaAsync(string schemaId, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public virtual Azure.Data.SchemaRegistry.SchemaProperties GetSchemaId(string groupName, string schemaName, Azure.Data.SchemaRegistry.SerializationType serializationType, string schemaContent, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
+        public virtual System.Threading.Tasks.ValueTask<Azure.Data.SchemaRegistry.SchemaProperties> GetSchemaIdAsync(string groupName, string schemaName, Azure.Data.SchemaRegistry.SerializationType serializationType, string schemaContent, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public virtual Azure.Response<Azure.Data.SchemaRegistry.SchemaProperties> RegisterSchema(string groupName, string schemaName, Azure.Data.SchemaRegistry.SerializationType serializationType, string schemaContent, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
         public virtual System.Threading.Tasks.Task<Azure.Response<Azure.Data.SchemaRegistry.SchemaProperties>> RegisterSchemaAsync(string groupName, string schemaName, Azure.Data.SchemaRegistry.SerializationType serializationType, string schemaContent, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) { throw null; }
     }

sdk/schemaregistry/Azure.Data.SchemaRegistry/src/SchemaRegistryClient.cs

@@ -2,13 +2,12 @@
 // Licensed under the MIT License.
 
 using System;
-using System.Globalization;
-using System.Text.Encodings.Web;
-using System.Text.Json;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Azure.Core;
 using Azure.Core.Pipeline;
+using Azure.Data.SchemaRegistry.Models;
 
 namespace Azure.Data.SchemaRegistry
 {
@@ -21,6 +20,9 @@ public class SchemaRegistryClient
         internal SchemaRestClient RestClient { get; }
         private const string CredentialScope = "https://eventhubs.azure.net/.default";
 
+        private readonly Dictionary<string, SchemaProperties> _schemaIdToPropertiesMap = new();
+        private readonly Dictionary<(string, string, string, SerializationType), SchemaProperties> _contentToPropertiesMap = new();
+
         /// <summary>
         /// Initializes a new instance of the <see cref="SchemaRegistryClient"/>.
         /// </summary>
@@ -68,22 +70,14 @@ internal SchemaRegistryClient(ClientDiagnostics clientDiagnostics, HttpPipeline
         /// <param name="schemaContent">The string representation of the schema's content.</param>
         /// <param name="cancellationToken">The cancellation token for the operation.</param>
         /// <returns>The properties of the schema.</returns>
-        public virtual async Task<Response<SchemaProperties>> RegisterSchemaAsync(string groupName, string schemaName, SerializationType serializationType, string schemaContent, CancellationToken cancellationToken = default)
-        {
-            using DiagnosticScope scope = _clientDiagnostics.CreateScope(RegisterSchemaScopeName);
-            scope.Start();
-            try
-            {
-                var response = await RestClient.RegisterAsync(groupName, schemaName, serializationType, schemaContent, cancellationToken).ConfigureAwait(false);
-                var properties = new SchemaProperties(schemaContent, response.Headers.Location, response.Headers.SerializationType, response.Headers.SchemaId, response.Headers.SchemaVersion);
-                return Response.FromValue(properties, response);
-            }
-            catch (Exception e)
-            {
-                scope.Failed(e);
-                throw;
-            }
-        }
+        public virtual async Task<Response<SchemaProperties>> RegisterSchemaAsync(
+            string groupName,
+            string schemaName,
+            SerializationType serializationType,
+            string schemaContent,
+            CancellationToken cancellationToken = default) =>
+                await RegisterSchemaInternalAsync(groupName, schemaName, serializationType, schemaContent, true, cancellationToken)
+                    .ConfigureAwait(false);
 
         /// <summary>
         /// Registers a schema with the SchemaRegistry service.
@@ -96,14 +90,41 @@ public virtual async Task<Response<SchemaProperties>> RegisterSchemaAsync(string
         /// <param name="schemaContent">The string representation of the schema's content.</param>
         /// <param name="cancellationToken">The cancellation token for the operation.</param>
         /// <returns>The properties of the schema.</returns>
-        public virtual Response<SchemaProperties> RegisterSchema(string groupName, string schemaName, SerializationType serializationType, string schemaContent, CancellationToken cancellationToken = default)
+        public virtual Response<SchemaProperties> RegisterSchema(
+            string groupName,
+            string schemaName,
+            SerializationType serializationType,
+            string schemaContent,
+            CancellationToken cancellationToken = default) =>
+                RegisterSchemaInternalAsync(groupName, schemaName, serializationType, schemaContent, false, cancellationToken)
+                    .EnsureCompleted();
+
+        private async Task<Response<SchemaProperties>> RegisterSchemaInternalAsync(
+            string groupName,
+            string schemaName,
+            SerializationType serializationType,
+            string schemaContent,
+            bool async,
+            CancellationToken cancellationToken = default)
         {
             using DiagnosticScope scope = _clientDiagnostics.CreateScope(RegisterSchemaScopeName);
             scope.Start();
             try
             {
-                var response = RestClient.Register(groupName, schemaName, serializationType, schemaContent, cancellationToken);
+                ResponseWithHeaders<SchemaId, SchemaRegisterHeaders> response;
+                if (async)
+                {
+                    response = await RestClient.RegisterAsync(groupName, schemaName, serializationType, schemaContent, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    response = RestClient.Register(groupName, schemaName, serializationType, schemaContent, cancellationToken);
+                }
+
                 var properties = new SchemaProperties(schemaContent, response.Headers.Location, response.Headers.SerializationType, response.Headers.SchemaId, response.Headers.SchemaVersion);
+                _schemaIdToPropertiesMap[properties.Id] = properties;
+                _contentToPropertiesMap[(groupName, schemaName, schemaContent, serializationType)] = properties;
+
                 return Response.FromValue(properties, response);
             }
             catch (Exception e)
@@ -122,22 +143,16 @@ public virtual Response<SchemaProperties> RegisterSchema(string groupName, strin
         /// <param name="schemaContent">The string representation of the schema's content.</param>
         /// <param name="cancellationToken">The cancellation token for the operation.</param>
         /// <returns>The properties of the schema, including the schema ID provided by the service.</returns>
-        public virtual async Task<Response<SchemaProperties>> GetSchemaIdAsync(string groupName, string schemaName, SerializationType serializationType, string schemaContent, CancellationToken cancellationToken = default)
-        {
-            using DiagnosticScope scope = _clientDiagnostics.CreateScope(GetSchemaIdScopeName);
-            scope.Start();
-            try
-            {
-                var response = await RestClient.QueryIdByContentAsync(groupName, schemaName, serializationType, schemaContent, cancellationToken).ConfigureAwait(false);
-                var properties = new SchemaProperties(schemaContent, response.Headers.Location, response.Headers.SerializationType, response.Headers.SchemaId, response.Headers.SchemaVersion);
-                return Response.FromValue(properties, response);
-            }
-            catch (Exception e)
-            {
-                scope.Failed(e);
-                throw;
-            }
-        }
+#pragma warning disable AZC0015 // Unexpected client method return type.
+        public virtual async ValueTask<SchemaProperties> GetSchemaIdAsync(
+            string groupName,
+            string schemaName,
+            SerializationType serializationType,
+            string schemaContent,
+            CancellationToken cancellationToken = default) =>
+#pragma warning restore AZC0015 // Unexpected client method return type.
+                await GetSchemaIdInternalAsync(groupName, schemaName, serializationType, schemaContent, true, cancellationToken)
+                    .ConfigureAwait(false);
 
         /// <summary>
         /// Gets the schema ID associated with the schema from the SchemaRegistry service.
@@ -148,15 +163,50 @@ public virtual async Task<Response<SchemaProperties>> GetSchemaIdAsync(string gr
         /// <param name="schemaContent">The string representation of the schema's content.</param>
         /// <param name="cancellationToken">The cancellation token for the operation.</param>
         /// <returns>The properties of the schema, including the schema ID provided by the service.</returns>
-        public virtual Response<SchemaProperties> GetSchemaId(string groupName, string schemaName, SerializationType serializationType, string schemaContent, CancellationToken cancellationToken = default)
+#pragma warning disable AZC0015 // Unexpected client method return type.
+        public virtual SchemaProperties GetSchemaId(
+            string groupName,
+            string schemaName,
+            SerializationType serializationType,
+            string schemaContent,
+            CancellationToken cancellationToken = default) =>
+#pragma warning restore AZC0015 // Unexpected client method return type.
+                GetSchemaIdInternalAsync(groupName, schemaName, serializationType, schemaContent, false, cancellationToken).EnsureCompleted();
+
+        private async ValueTask<SchemaProperties> GetSchemaIdInternalAsync(
+            string groupName,
+            string schemaName,
+            SerializationType serializationType,
+            string schemaContent,
+            bool async,
+            CancellationToken cancellationToken)
         {
+            if (_contentToPropertiesMap.TryGetValue(
+                (groupName, schemaName, schemaContent, serializationType),
+                out SchemaProperties schema))
+            {
+                return schema;
+            }
+
             using DiagnosticScope scope = _clientDiagnostics.CreateScope(GetSchemaIdScopeName);
             scope.Start();
             try
             {
-                var response = RestClient.QueryIdByContent(groupName, schemaName, serializationType, schemaContent, cancellationToken);
+                ResponseWithHeaders<SchemaId, SchemaQueryIdByContentHeaders> response;
+                if (async)
+                {
+                    response = await RestClient.QueryIdByContentAsync(groupName, schemaName, serializationType, schemaContent, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    response = RestClient.QueryIdByContent(groupName, schemaName, serializationType, schemaContent, cancellationToken);
+                }
+
                 var properties = new SchemaProperties(schemaContent, response.Headers.Location, response.Headers.SerializationType, response.Headers.SchemaId, response.Headers.SchemaVersion);
-                return Response.FromValue(properties, response);
+                _schemaIdToPropertiesMap[properties.Id] = properties;
+                _contentToPropertiesMap[(groupName, schemaName, schemaContent, serializationType)] = properties;
+
+                return properties;
             }
             catch (Exception e)
             {
@@ -171,38 +221,47 @@ public virtual Response<SchemaProperties> GetSchemaId(string groupName, string s
         /// <param name="schemaId">The schema ID of the the schema from the SchemaRegistry.</param>
         /// <param name="cancellationToken">The cancellation token for the operation.</param>
         /// <returns>The properties of the schema, including the schema content provided by the service.</returns>
-        public virtual async Task<Response<SchemaProperties>> GetSchemaAsync(string schemaId, CancellationToken cancellationToken = default)
-        {
-            using DiagnosticScope scope = _clientDiagnostics.CreateScope(GetSchemaScopeName);
-            scope.Start();
-            try
-            {
-                var response = await RestClient.GetByIdAsync(schemaId, cancellationToken).ConfigureAwait(false);
-                var properties = new SchemaProperties(response.Value, response.Headers.Location, response.Headers.SerializationType, response.Headers.SchemaId, response.Headers.SchemaVersion);
-                return Response.FromValue(properties, response);
-            }
-            catch (Exception e)
-            {
-                scope.Failed(e);
-                throw;
-            }
-        }
+#pragma warning disable AZC0015 // Unexpected client method return type.
+        public virtual async ValueTask<SchemaProperties> GetSchemaAsync(string schemaId, CancellationToken cancellationToken = default) =>
+#pragma warning restore AZC0015 // Unexpected client method return type.
+            await GetSchemaInternalAsync(schemaId, true, cancellationToken).ConfigureAwait(false);
 
         /// <summary>
         /// Gets the schema content associated with the schema ID from the SchemaRegistry service.
         /// </summary>
         /// <param name="schemaId">The schema ID of the the schema from the SchemaRegistry.</param>
         /// <param name="cancellationToken">The cancellation token for the operation.</param>
         /// <returns>The properties of the schema, including the schema content provided by the service.</returns>
-        public virtual Response<SchemaProperties> GetSchema(string schemaId, CancellationToken cancellationToken = default)
+#pragma warning disable AZC0015 // Unexpected client method return type.
+        public virtual SchemaProperties GetSchema(string schemaId, CancellationToken cancellationToken = default) =>
+#pragma warning restore AZC0015 // Unexpected client method return type.
+            GetSchemaInternalAsync(schemaId, false, cancellationToken).EnsureCompleted();
+
+        private async ValueTask<SchemaProperties> GetSchemaInternalAsync(string schemaId, bool async, CancellationToken cancellationToken)
         {
+            if (_schemaIdToPropertiesMap.TryGetValue(schemaId, out SchemaProperties schema))
+            {
+                return schema;
+            }
+
             using DiagnosticScope scope = _clientDiagnostics.CreateScope(GetSchemaScopeName);
             scope.Start();
             try
             {
-                var response = RestClient.GetById(schemaId, cancellationToken);
+                ResponseWithHeaders<string, SchemaGetByIdHeaders> response;
+                if (async)
+                {
+                    response = await RestClient.GetByIdAsync(schemaId, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    response = RestClient.GetById(schemaId, cancellationToken);
+                }
+
                 var properties = new SchemaProperties(response.Value, response.Headers.Location, response.Headers.SerializationType, response.Headers.SchemaId, response.Headers.SchemaVersion);
-                return Response.FromValue(properties, response);
+                _schemaIdToPropertiesMap[schemaId] = properties;
+
+                return properties;
             }
             catch (Exception e)
             {

sdk/schemaregistry/Azure.Data.SchemaRegistry/tests/Samples/Sample01_ReadmeSnippets.cs

@@ -79,8 +79,8 @@ public void RetrieveSchemaId()
                 ]
             }";
 
-            Response<SchemaProperties> schemaProperties = client.GetSchemaId(groupName, schemaName, schemaType, schemaContent);
-            string schemaId = schemaProperties.Value.Id;
+            SchemaProperties schemaProperties = client.GetSchemaId(groupName, schemaName, schemaType, schemaContent);
+            string schemaId = schemaProperties.Id;
             #endregion
 
             Assert.AreEqual(_schemaProperties.Id, schemaId);
@@ -93,8 +93,8 @@ public void RetrieveSchema()
             var schemaId = _schemaProperties.Id;
 
             #region Snippet:SchemaRegistryRetrieveSchema
-            Response<SchemaProperties> schemaProperties = client.GetSchema(schemaId);
-            string schemaContent = schemaProperties.Value.Content;
+            SchemaProperties schemaProperties = client.GetSchema(schemaId);
+            string schemaContent = schemaProperties.Content;
             #endregion
 
             Assert.AreEqual(Regex.Replace(_schemaProperties.Content, @"\s+", string.Empty), schemaContent);